来来来

设所排序序列的记录个数为n。i取1,2,…,n-1,从所有n-i+1个记录(Ri,Ri+1,…,Rn)中找出排序码最小的记录，与第i个记录交换。执行n-1趟 后就完成了记录序列的排序。

我也不会饿

{:2_34:}{:2_34:}我就默默看你水

/*
* 选择排序基本思路：
* 把第一个元素依次和后面的所有元素进行比较。
* 第一次结束后，就会有最小值出现在最前面。
* 依次类推
*/
public class SelectionSort {
        public static void sort(int[] data) {
                for (int x = 0; x < data.length - 1; x++) {
                        for (int y = x + 1; y < data.length; y++) {
                                if (data[y] < data[x]) {
                                        SortTest.swap(data, x, y);
                                }
                        }
                }
        }
}

多给你来几个排序方法
1.选择排序
private static void selectSort(int[] a) {
                for (int i = 0; i < a.length; i++) {
                        for (int j = i + 1; j < a.length - i; j++) {
                                if (a[i] > a[j]) {
                                        int temp = a[i];
                                        a[i] = a[j];
                                        a[j] = temp;
                                }
                        }
                }
                for (int i = 0; i < a.length; i++) {
                        System.out.print(a[i] + " ");
                }
        }
//冒泡排序
        private static void bubbleSort(int[] a) {
                for (int i = 0; i < a.length - 1; i++) {
                        for (int j = 0; j < a.length - i - 1; j++) {
                                if (a[j] > a[j + 1]) {
                                        int temp = a[j];
                                        a[j] = a[j + 1];
                                        a[j + 1] = temp;
                                }
                        }
                }
                for (int i = 0; i < a.length; i++) {
                        System.out.print(a[i] + " ");
                }
        }
//自带的排序方法
        private static void sort(int[] a) {
                Arrays.sort(a);
                System.out.println(Arrays.toString(a));
        }

for(int i=0;i<a.length-1;i++){
                        //找 [i, a.length)范围内的最小值,
                        //假设i位置最小，下标i赋给j
                        int j=i;
                        for(int k=i+1;k<a.length;k++){
                                if(a[k]<a[j]){
                                        j=k;
                                }
                                int c=a[j];
                                a[j]=a[i];
                                a[i]=c;
                        }

将数组的第一个元素依次和后面的每个元素比较 得出最值  把最值放在角标0的位置   把原来角标0位置的元素放在最值的角标位置上
将数组的第二个元素按上面的方法操作
。。。
直到最后一个元素为止

我学的是ios,来说说思想把,其实就是一个数组,第一次用第一个和剩下的其他数比较大小,假如从小到大排列,则比arr[0]小的数放到arr[0]中,第二次就是把arr[1]和arr[2]到arr[n]的数比较,比较小的数放到arr[1]中,以此类推.则arr[i]和其它剩下的数逐次比较,当有小的数就放到arr[i]中.

我学的是ios,来说说思想把,其实就是一个数组,第一次用第一个和剩下的其他数比较大小,假如从小到大排列,则

n个数选择排序就是（默认从小到大正序输出）：第一步：从第一个数开始，依次与后面的数进行比较，如果遇到比自己小的数后就交换直到最后一个数，然后记录最小的数放在第一位；第二步：从第二个数开始执行上述操作依次遍历剩余的数，拿出最小的放在第二位；~~~依次循环直至执行到第n-1步，然后遍历输出

选择排序就是从第一个数开始

class xuanze {         public static void selectsort(int[]arr)         {                 for(int x=0;x<arr.length-1;x++)                 {                         for(int y=x+1;y<arr.length;y++)                         {                                 if(arr[x]>arr[y])                                 {                                         int temp=arr[x];                                     arr[x]=arr[y];                                     arr[y]=temp;                                 }                                                                  }                 }         }         public static void main(String[]args)         {                 int []arr={1,5,8,6,4,2};                 selectsort(arr);

排序代码，和排序视频我上传网上了，你下载看看吧

链接: http://pan.baidu.com/s/1kUsApZx 密码: 8ssw

在要排序的一组数中找到最小的数，和第一个数交换位置，再从剩下的数找到最小的和第二个数交换位置，依次循环直到倒数第二个数和最后一个数比较为止
最佳答案
public class selectSortArray {

  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    int[]array={2,8,1,3,9,4};  //定义一个需要排序的数组
    selectSort(ar

1. public class selectSortArray {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 int[]array={2,8,1,3,9,4};                          //定义一个需要排序的数组
   
9.                 selectSort(array);                                  //调用选择排序方法
   
10.                 for (int i = 0; i < array.length; i++) {   //循环打印排序后的数组元素
    
11.                         System.out.print(array[i]+" ");
    
12.                 }
    
13.                
    
14. 
    
15.         }
    
16. 
    
17.         public static void selectSort(int[] array) {
    
18.                 // TODO Auto-generated method stub
    
19.                 for (int i = 0; i < array.length-1; i++) {         //外循环控制比较次数
    
20.                         for (int j = i+1; j < array.length; j++) { //内循环控制比较元素
    
21.                         if (array[i]>array[j]) {
    
22.                                 int temp=array[i];                        //定义一个中间变量存放较大的元素
    
23.                                 array[i]=array[j];                           //元素较小的值赋给较大元素
    
24.                                 array[j]=temp;                             //元素较大的值赋给较小元素
    
25.                                 
    
26.                         }
    
27.                                 
    
28.                         }
    
29.                         
    
30.                 }
    
31.         }
    
32. 
    
33. }
    

复制代码

给你个最终版
public  void selectSort(int[] arr){
    for(int i=0;i<arr.length-1;i++){        //遍历数组里面（除最后一个元素）的元素
         for(int j=i+1;j<arr.length){         //把遍历到的元素和他后面所有的元素进行对比
             if(arr[i]>arr[j]){                     //如果后面有比他小的元素就替换他们的位置 每次都使小的在前面
                  arr[i]=arr[i]^arr[j];
                  arr[j]=arr[i]^arr[j];
                  arr[i]=arr[i]^arr[j];

                  
}
}
}
}

新年到，也要好好学习，这个年，注定难忘。

我是来顶贴的

1. class Arrse
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr={5,1,6,4,2,8,9};
   
6.                 print(arr);//排序前打印
   
7.                 selectSort(arr);//排序
   
8.                 print(arr);//排序后打印
   
9.         }
   
10.         public static void selectSort(int[] arr)
    
11.         {
    
12.                 for (int x=0;x<arr.length-1;x++)
    
13.                 {
    
14.                         for (int y=x+1;y<arr.length;y++)
    
15.                         {
    
16.                                 if (arr[x]>arr[y])
    
17.                                 {
    
18.                                         int temp=arr[x];
    
19.                                         arr[x]=arr[y];
    
20.                                         arr[y]=temp;
    
21.                                 }
    
22.                         }
    
23.                 }
    
24.         }
    
25.         public static void print(int[] arr)
    
26.         {
    
27.                 System.out.print("[");
    
28.                 for (int x=0;x<arr.length ;x++ )
    
29.                 {
    
30.                         if (x!=arr.length-1)
    
31.                         {
    
32.                                 System.out.print(arr[x]+",");
    
33.                         }
    
34.                         else
    
35.                                 System.out.println(arr[x]+"]");
    
36.                 }
    
37.         }
    
38. }

复制代码

以上为代码，这个应该是最基本的做法了，下面附上原理图：

public static void bubble(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
                for (int j = i+1; j < arr.length; j++) {
                        if (arr[i] > arr[j]) {
                                temp = arr[i];
                                arr[i] = arr[j];
                                arr[j] = temp;
                        }        
                }
        }
        for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
        }
}