五种排序算法

冒泡排序（BubbleSort）

• 比较相邻两个数据，如果第一个数大，就交换位置
• 从前向后两两比较，直到最大数到最后一位。
• 重复上述过程

平均时间复杂度：O（n^2）

public static void BubbleSort(int [] arr){

     int temp;//临时变量
     for(int i=0; i<arr.length-1; i++){   //表示趟数，一共arr.length-1次。
         for(int j=0; j<arr.length-1-i; j++){
             if(arr[j] > arr[j+1]){
                 temp = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = temp;
             }
         }
     }
 }

快速排序

• 取数列中第一个数作为key值
• 用挖空填数，将比这个数小的书放在它的左边，大于或等于它的钱全部放在右边；
• 将左右两个小数列重复第二步，至各区间只有1个数。

public static void quickSort(int[] a,int l,int r){
     if(l>=r)
       return;

     int i = l; int j = r; int key = a[l];//选择第一个数为key

     while(i<j){

         while(i<j && a[j]>=key)//从右向左找第一个小于key的值
             j--;
         if(i<j){
             a[i] = a[j];
             i++;
         }

         while(i<j && a[i]<key)//从左向右找第一个大于key的值
             i++;

         if(i<j){
             a[j] = a[i];
             j--;
         }
     }
     //i == j
     a[i] = key;
     quickSort(a, l, i-1);//递归调用
     quickSort(a, i+1, r);//递归调用
 }

时间复杂度：O（nlogn）

选择排序

• 在长度为N的无序数组中，第一次遍历n-1个数，找到最小的数值与第一个元素交换
• 第二次遍历n-2个数，找到最小的数值与第二个元素交换
• 直至n-1次遍历。

public static void select_sort(int[] array){

   for(int i=0;i<array.length-1;i++){

       int minIndex = i;
       for(int j=i+1;j<array.length;j++){
          if(array[j]<array[minIndex]){
              minIndex = j;
          }
       }
       if(minIndex != i){
           int temp = array[i];
           array[i] = array[minIndex];
           array[minIndex] = temp;
       }
   }
}

时间复杂度：O（n^2）

插入排序

• 从第一个与第二个元素开始比较，若后一个小于前一个元素，则更换位置
• 直至比较到最后一个

public static void  insertSort(int[] array){

   int temp;
   for(int i=0;i<array.length-1;i++){
       for(int j=i+1;j>0;j--){
           if(array[j] < array[j-1]){
               temp = array[j-1];
               array[j-1] = array[j];
               array[j] = temp;
           }else{         //不需要交换
               break;
           }
       }
   }
}

时间复杂度：O（n^2）

希尔排序

• 设置一增量，根据增量将数组分为若干数组（即相隔一个增量的元素在同一数组），对子序列进行插入排序
• 逐渐减少增量，直至增量为1

public static void shell_sort(int[] array){

   int temp = 0;
   int incre = array.length;

   while(true){
       incre = incre/2;

       for(int k = 0;k<incre;k++){    //根据增量分为若干子序列

           for(int i=k+incre;i<lenth;i+=incre){

               for(int j=i;j>k;j-=incre){
                   if(array[j]<array[j-incre]){
                       temp = array[j-incre];
                       array[j-incre] = array[j];
                       array[j] = temp;
                   }else{
                       break;
                   }
               }
           }
       }

       if(incre == 1){
           break;
       }
   }
}