java排序——选择、插入、冒泡、二分法

1.简单选择排序：（选出最小值，放在第一位，然后第一位向后推移，如此循环）第一位与后面每一个逐个比较，每次都使最小的置顶，第一位向后推进（即刚选定的第一位是最小值，不再参与比较，比较次数减1）

复杂度： 所需进行记录移动的操作次数较少 0--3(n-1) ，无论记录的初始排列如何，所需的关键字间的比较次数相同，均为n(n-1)/2，总的时间复杂度为O(n2)；
空间复杂度 O(1)

算法改进：每次对比，都是为了将最小的值放到第一位，所以可以一比到底，找出最小值，直接放到第一位，省去无意义的调换移动操作。也可以换一个方向，最后一位与前面每一个比较，每次使最大值沉底，最后一位向前推进。

Java代码   

1. int[]  selectionSort(int []a){    
2.               
3.         for (int i = 0; i < a.length - 1; i++) {   
4.             int min = i;   
5.             // Find smallest name   
6.             for (int j = i + 1; j < a.length; j++) {   
7.                 if (a[j] < a[min]) // 找到最小值 注意此处不是判断a[j]<a[i]   
8.                     min = j;   
9.             }   
10.             // Swap data if necessary   
11.             if (min != i) {   
12.                 int temp = a[i];   
13.                 a[i] = a[min];   
14.                 a[min] = temp;   
15.             }   
16.         }   
17.         return a;   
18.     }  

 

2. 插入排序
      基本思想：排序值列中的前2个值，并在必要时交换它们。在相对于前2个值（有序的）的适当位置插入值列的第三个值。然后，在相对于前3个值（有序的）的适当位置插入值列的第4个值。每进行一次插入操作，有序子集中的数值个数将递增1。重复该过程，直至值列中的所有值都按照次序排列为止。插入过程需要移动数组中的其他值，为插入的元素腾出存储空间。
      在大多数情况下，它比冒泡排序快一倍，比选择排序快一些，仍需O(n2)时间。常被用在比较复杂的算法的最后阶段，比如快速排序。
      

 

Java代码   

1. int[] insertionSort(int[] a) {   
2.         for (int i = 1; i < a.length; i++) {   
3.             int temp = a[i];   
4.             int j = i;   
5.             while (j > 0 && temp < a[j - 1]) {   
6.                 a[j] = a[j - 1];//all larger elements are moved one pot to the right   
7.                 j- -;   
8.             }   
9.             a[j] = temp;   
10.         }   
11.         return a;   
12.     }  
13. 
    

 

 3.二分法

算法：当数据量很大适宜采用该方法。采用二分法查找时，数据需是有序不重复的。 基本思想：假设数据是按升序排序的，对于给定值 x，从序列的中间位置开始比较，如果当前位置值等于 x，则查找成功；若 x 小于当前位置值，则在数列的前半段中查找；若 x 大于当前位置值则在数列的后半段中继续查找，直到找到为止。

假设有一个数组 { 12, 23, 34, 45, 56, 67, 77, 89, 90 }，现要求采用二分法找出指定的数值并将其在数组的索引返回，如果没有找到则返回 -1。代码如下：

package cn.sunzn.dichotomy;

public class DichotomySearch {
   public static void main(String[] args) {
       int[] arr = new int[] { 12, 23, 34, 45, 56, 67, 77, 89, 90 };
       System.out.println(search(arr, 12));
       System.out.println(search(arr, 45));
       System.out.println(search(arr, 67));
       System.out.println(search(arr, 89));
       System.out.println(search(arr, 99));
   }

   public static int search(int[] arr, int key) {
       int start = 0;
       int end = arr.length - 1;
       while (start <= end) {
           int middle = (start + end) / 2;
           if (key < arr[middle]) {
               end = middle - 1;
           } else if (key > arr[middle]) {
               start = middle + 1;
           } else {
               return middle;
           }
       }
       return -1;
   }
}

4.冒泡排序

     原理:相邻两个数进行比较 小的向前移动 当第一轮移动 也就是下面代码中的内层循环，从数组的第一个数开始 首先是第一、二个数进行比较 若后者比前者大则两数交换位置，然后是第二、三个数进行比较。。。循环比较的次数是 num.length-1。

当第一轮排序完成后 接着从数组的第二 和第三个数的比较开始 循环比较的次数是num.length-2

...依次类推

直到最后两个数进行比较

 

 

int[] num=new int[]{1，6，5，8，9，4，7};

int temp = 0;//用于两个数进行交换的中间变量

for(int i=0;i<num.length;i++){
//外层循环开始 控制比较的开始位置 和比较的次数

for(int j=num.length-1;j>i;j--){

//内层循环开始 对相邻的两个数进行比较 若后者比前者大则交换位置
if(num[j]>num[j-1]){
  temp=num[j-1];
  num[j-1]=num[j];
  num[j]=temp;
  }

}

}

5. 几种排序的比较

        一般不太使用冒泡排序，然而当数据量小时，他会有些应用价值。

        选择排序虽然可以把交换次数降到最低，但比较的次数仍然很大。当数据量很小，并且交换数据相对于比较数据更加耗时，可以使用。

        在大多数情况下，假设数据量较小或基本有序时，插入排序是三种中最好的选择。对于更大数据量的排序来说，快速排序是更好的选择。