精华内容
下载资源
问答
  • 选择排序 java

    2011-12-03 23:42:11
    该算法采用了选择排序的算法实现对数组的排序,非常的实用,是不容错过的资源
  • 选择排序 Java

    2014-11-06 10:49:13
    选择排序用于解决
    选择排序用于解决数组的排序问题,其基本思路为:最小元素应放在下标为0的位置,次小元素应放在下标为1的位置......最大的元素应放在下标为array.length-1的位置。在算法执行的过程中,外层循环用于假设当前下标为i的元素就是第i小的,内层循环用于寻找比当前下标为i元素更小的元素的下标,并修改第i小的下标指示器。代码如下:
    	public static void select_sort(int [] arr){
    		int target = 0;//第i小下标指示器
    		int tmp = 0;//用于最后的元素交换
    		for(int i = 0; i < arr.length; i++){
    			target = i;
    			for(int j = i; j < arr.length; j++){
    				if(arr[j] < arr[target]){
    					target = j;
    				}
    			}
    			//do switch
    			if(i != target){
    			tmp = arr[i];
    			arr[i] = arr[target];
    			arr[target] = tmp;
    			}
    		}
    	}

    展开全文
  • 选择排序 Java实现

    2021-04-10 17:19:55
    文章目录选择排序 Java实现一、选择排序介绍二、 选择排序排序规则三、举例说明1.手动排序2.Java代码实现 一、选择排序介绍 选择排序也是一种简单的排序方法。它的基本思想是:第一次从arr[0]~arr[n-1]中选取...


    一、选择排序介绍

    选择排序也是一种简单的排序方法。它的基本思想是:第一次从arr[0]~arr[n-1]中选取最小值,与arr[0]交换,第二次从arr[1] ~ arr[n-1]中选取最小值,与arr[1]交换,第三次从arr[2]~arr[n-1]中选取最小值,与arr[i-1]交换.....,第i次从arr[i-1]~arr[n-1]中选取最小值,与arr[i-1]交换,...总共通过n-1次,得到一个按排序从小到大排列的有序序列。
    

    二、 选择排序排序规则

    • 1,一共比较n-1轮
    • 2,每一轮拿最小的值和最新的arr[0]进行比较,如果arr[0]>最小的值,则进行交换

    三、举例说明

    1.手动排序

    给定一组数据,例如 int[] arr = {6,3,12,-1};
    第一轮:-1,3,12,6
    第二轮:-1,3,12,6
    第三轮:-1,3,6,12

    2.Java代码实现

    代码如下:

    /*选择排序规则:
    * 1,一共比较n-1论
    * 2,每一轮拿最小的值和最新的arr[0]进行比较,如果arr[0]>最小的值,则进行交换
    * */
    public class xuanZe {
        public static void main(String[] args) {
            int[] arr = {101,34,119,1,9};
            selectSolt(arr);
            System.out.println(Arrays.toString(arr));
        }
    
        public static void selectSolt(int[] arr){
            //比较的轮数
            for (int i = 0; i < arr.length-1; i++) {
                //假设一个最小值
                int minIndex = i;
                //最小值的下标
                int min = arr[i];
                //每轮里面 最小的值和arr[0]比较
                for (int j = i + 1; j < arr.length; j++) {
                    //如果最终结果想要从大到小的顺序  ,则把>换成<
                    if (min > arr[j]) {//说明假设的最小值不是最小的
                        min = arr[j];//重新定义最小值
                        minIndex = j;//重新定义最小值下标
                    }
                }
                //将最小值放在arr[0] 即交换
                if (minIndex != i) {
                    arr[minIndex] = arr[i];
                    arr[i] = min;
                }
            }
        }
    }
    结果如下:
    [1, 9, 34, 101, 119]
    
    展开全文
  • 选择排序java 代码

    2015-08-18 05:57:11
    选择排序java的代码,运行方法写在里面,分享给大家。
  • 选择排序之直接选择排序Java实现

    选择排序之直接选择排序Java实现

    <pre name="code" class="java">package com.mike.sort;
    
    import java.util.Arrays;
    
    public class SelectSort {
    	/*
    	 * 直接选择排序
    	 */
    	public static void selectSort(DataWrap[] data){
    		int length=data.length;
    		for (int i = 0; i < data.length-1; i++) {
    			int minIndex=i;
    			for (int j = i+1; j < data.length; j++) {
    				if (data[minIndex].compareTo(data[j])>0) {
    					minIndex=j;
    				}
    			}
    			if (minIndex!=i) {
    				DataWrap temp=data[minIndex];
    				data[minIndex]=data[i];
    				data[i]=temp;
    			}
    		}
    	}
        /*
    	 * 交换数组元素
    	 */
    	public static void swap(DataWrap[] data,int i,int j){
    		DataWrap temp=data[i];
    		data[i]=data[j];
    		data[j]=temp;
    	}
        public static void main(String[] args) {  
            DataWrap[] dataWraps={  
                    new DataWrap(21,""),  
                    new DataWrap(31,""),  
                    new DataWrap(2,""),  
                    new DataWrap(2338,"*"),  
                    new DataWrap(2122,""),  
                    new DataWrap(22,""),  
                    new DataWrap(55,""),  
                    new DataWrap(134,""),  
                    new DataWrap(24000,"")  
            };  
            System.out.println("排序之前:"+Arrays.toString(dataWraps));  
            selectSort(dataWraps);  
            System.out.println("排序之后:"+Arrays.toString(dataWraps));  
        }
    }
    /*
    *定义一个数据包装类
    */
    class DataWrap implements Comparable<DataWrap>{
    	int data;
    	String flag;
    	public DataWrap() {
    		// TODO Auto-generated constructor stub
    	}
    	public DataWrap(int data,String flag) {
    		this.data=data;
    		this.flag=flag;
    	}
    	@Override
    	public String toString(){
    		return data+flag;
    	}
    	@Override
    	public int compareTo(DataWrap o) {
    		// TODO Auto-generated method stub
    		return this.data>o.data?1:(this.data==o.data?0:-1);
    	}
    }
    


    
    
    
    
    展开全文
  • 冒泡和选择排序Java代码实现,简单的算法,适合新手入门级程序。
  • 二维数组选择排序 java public static void main(String[] args) { int n = 5; int m = 7; int[][] arr = new int[n][m]; for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j...

    二维数组选择排序 java

    public static void main(String[] args) {
            int[][] arr = new int[5][];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = new int[(int)(Math.random() * 6 + 5)];
                for (int j = 0; j < arr[i].length; j++) {
                    arr[i][j] = (int)(Math.random() * 101);
                }
            }
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr[i].length; j++) {
                    System.out.print(arr[i][j] + " ");
                }
                System.out.println();
            }
            System.out.println("*****************************");
    
           for (int i = 0; i < arr.length; i++) {
               for (int j = 0; j < arr[i].length; j++) {
                   int keyIndex1 = 0;
                   int keyIndex2 = 0;
                   boolean flag = false;
                   int min = arr[i][j];
                   for (int x = i; x < arr.length; x++) {
                       for (int k = j; k < arr[x].length; k++) {
                           if (min > arr[x][k]) {
                               min = arr[x][k];
                               keyIndex1 = x;
                               keyIndex2 = k;
                               flag = true;
                           }
                       }
                   }
                   //如果有值比key小  才会进行数值交换,否则 keyIndex为0  交换的话会和第一个数交换
                   if (flag) {
                       arr[keyIndex1][keyIndex2] = arr[i][j];
                       arr[i][j] = min;
                   }
               }
           }
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr[i].length; j++) {
                    System.out.print(arr[i][j] + " ");
                }
                System.out.println();
            }
        }
    
    展开全文
  • 选择排序java实现

    2020-04-10 16:59:12
    排序算法有8大,分别是:直接插入排序,希尔排序这两个是插入排序,简单选择排序,堆排序,这两个是选择排序,冒泡排序快速排序,这两个是交换排序,还有归并排序跟基数排序。 下面来介绍选择排序的实现,以及十万...
  • 选择排序Java实现

    2019-09-05 09:13:55
    选择排序 选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)...
  • 选择排序Java语言实现

    2016-04-19 09:56:36
    代码实现了二元选择排序与堆排序
  • 定义 选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在...n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序...
  • 选择排序 java实现

    2017-07-19 10:58:19
     * 选择排序  * 过程:比较这一组数据,找到该组数据中最小的项,与最左边的项进行位置交换,排除上一步已经排序好的数据,  * 继续进行比较该组数据,找到最小值,与最左边的进行交换,不断重复,进行n-1次...
  • 选择排序Java代码实现

    千次阅读 2019-05-31 20:58:15
    选择排序 表现最稳定的排序算法之一,因为无论什么数据进去都是O(n2)的时间复杂度,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。 选择排序(Selection-sort)是一种简单直观的...
  • 使用Java代码实现选择排序Java

    千次阅读 2018-06-12 15:17:51
    1.算法思想: 首先找到数组中最小的那个元素,其次,将它和数组的第一个元素交换位置(如果第一个... 为什么叫它选择排序?因为从上面的算法中可以看到它一直不断地在选择剩余元素中的最小值。2.Java代码实现:p...
  • 选择排序JAVA实现代码

    2020-05-27 11:48:28
    * 选择排序 * 每次选择一个最小的放在第一个位置,然后比对剩下的取最小值 * 以此类推 */ public static void selectSort() { int arr[] = { 22, 5, 6, 9, 87, 7, 1 }; for (int i = 0; i < arr....
  • 选择排序Java版代码

    2019-12-16 14:44:29
    public class Test { /** * 选择排序 * * @param array */ public static void selectSort(int[] array) { if (array == null) { return; } int n = a...
  • 直接选择排序 Java

    2015-06-10 23:10:02
    排序的方法有很多,一般言,很难说哪一种方法是最好的。每一种方法都有优缺点,有各自应用的环境。...选择排序:(1)直接选择排序;(2)堆排序; 交换排序:(3)冒泡排序;(4)快速排序; 插入排序:
  • 直接选择排序java实现

    2016-06-11 22:14:31
    常用的选择排序方法有:直接选择排序和堆排序 直接选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列无序区的起始位置,直到全部待排序的数据...
  • //简单选择排序!将待排序的数组每次选出一个最小或最大的数,在第i轮循环中与第i个数组进行较交换 public class SelectSort { public static void main(String[] args) { int a[]={14,5,7,2,45,1,87,98,89,3,1,34}...
  • 选择排序 Java数据结构与算法源代码:/** * * @author sunnyykn * * selectSort.java * demonstrates selection sort * to run this program:C>java SelectSortApp */ class ArraySel { private ...
  • 选择排序的思路: 每次都从未排序的序列中找到一个最小(大)的元素,把它放到已排好序的序列尾部; 重复上述过程,直到未排序的序列为空。 java代码(从小到大): public void toSelectSort(int []arr) {...
  • * 直接选择排序 * 直接选择排序是一种不稳定的排序 * 时间复杂度为 O(n^2),当记录占用字节数较多时,直接选择排序通常比直接插入排序的执行速度快些。 * 空间复杂度为O(1) * * 原理:从未排序序列中找到最小...
  • 选择排序java代码实现

    2019-01-10 16:43:42
    public class ChoiceSort { public static int[] sort(int[] array){ //总共要经过N-1轮比较 for(int i = 0 ;... System.out.println("经过选择排序后的数组顺序为:"); display(array); } }  
  • package mydemo;... * 选择排序  * @author wzq  *  */ public class SelectSort {  public static void main(String[] wzq)  {  int[] data= {9,3,5,1,6,2,8,4,7,23,44,13};  i

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,149
精华内容 5,259
关键字:

选择排序java

java 订阅