一、基本概念

1. 排序：就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

2. 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排算法是稳定的；否则称为不稳定的。

3. 常见的排序：直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序。

4. 内部排序：数据元素全部放在内存中的排序。

5. 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

二、常见排序算法的实现

1. 直接插入排序

   1.1 基本思想

   把待排序的元素按其值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。

   1.2 思路

    

   1.3 代码

   public static void insertSort(int[] array) {
           for(int i=0;i<array.length;i++){
               int tmp=array[i];
               int j=i-1;
               for(;j>=0;j--){
                   if(array[j]>tmp){
                       array[j+1]=array[j];
                   }else{
                       break;
                   }
               }
               array[j+1]=tmp;
           }
       }

   1.4 总结

   时间复杂度：

   最坏情况：O(N^2)即逆序时

   最好情况：O(N)即有序

   如果以后 数据量不大 趋于有序【优化】 使用

   空间复杂度：O(1)

   稳定性：稳定

2. 希尔排序

   2.1 基本思想

   先选定一个整数，把待排序文件中所有记录分成个组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达gap=1时，所有记录在统一组内排好序。

   2.2 思路

    

   2.3 代码

   public static void shellSort(int[] array) {
           int gap = array.length;//10
           while (gap > 1) {
               gap /= 2;
               shell(array,gap);
           }
           shell(array,1);
   }
   public static void shell(int[] array,int gap) {
           for(int i=gap;i<array.length;i++){
               int tmp=array[i];
               int j=i-gap;
               for(;j>=0;j-=gap){
                   if(array[j]>tmp){
                       array[j+gap]=array[j];
                   }else{
                       break;
                   }
               }
               array[j+gap]=tmp;
           }
   }

   2.4 总结

   时间复杂度：

   最坏情况：O(1.6*N^1.25)

   最好情况：O(N^1.25)

   空间复杂度：O(1)

   稳定性：不稳定

3. 选择排序

   3.1 基本思想

   每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

   3.2 思路

    

   3.3 代码

   //交换
   public static void swap(int[] array,int i,int j){
           int tmp=array[i];
           array[i]=array[j];
           array[j]=tmp;
   }
   //每次都交换
   public static void selectSort(int[] array) {
           for(int i=0;i< array.length;i++){
               for (int j=i+1;j< array.length;j++){
                   if(array[j]<array[i]){
                       swap(array,i,j);
                   }
               }
           }
   }
   
   //交换次数少一些，直接交换
   public static void selectSort2(int[] array) {
           for(int i=0;i< array.length;i++){
               int minIndex=i;
               for (int j=i+1;j< array.length;j++){
                   if(array[j]<array[minIndex]){
                       minIndex=j;
                   }
               }
               swap(array,i,minIndex);
           }
   }

   3.4 总结

   时间复杂度：O(N^2)

   空间复杂度：O(1)

   稳定性：不稳定

4. 冒泡排序

   4.1 基本思想

   是根据序列中两个元素值的比较结果来交换这两个元素在序列中的位置，即将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

   4.2 思路

    

   4.3 代码

   public static void bubbleSort(int[] array){
           for (int i = 0; i < array.length-1; i++) {
               for (int j = 0; j < array.length-1-i; j++) {
                   if(array[j]>array[j+1]){
                       swap(array,j,j+1);
                   }
               }
           }
   }
   
   
   //改进
   public static void bubbleSort(int[] array){
           for (int i = 0; i < array.length-1; i++) {
               boolean flg=false;
               for (int j = 0; j < array.length-1-i; j++) {
                   if(array[j]>array[j+1]){
                       swap(array,j,j+1);
                       flg=true;
                   }
               }
               if(flg==false){
                   break;
               }
           }
       }

   4.4总结

   时间复杂度：O(N^2)

   空间复杂度：O(1)

   稳定性：稳定