高级排序之希尔排序、归并排序、快速排序，及排序稳定性

这几个算法确实难理解记录一下，以免忘记。
希尔排序
个人理解就是特殊的插入排序，只不过是比插入排序步子迈的大一些，跨好几个元素进行比较，再缩小步子。
具体做法是初始化一个增量，逐步缩小增量，对由增量分组的元素进行插入排序；
Shell.class

public class Shell {
    //对数组a中的元素进行排序
    public static void sort(Comparable[] a){
        //1.根据数组a的长度，确定增长量h的初始值；
        int h = 1;
        while(h<a.length/2){
            h=2*h+1;
        }
        //2.希尔排序
        while(h>=1){
            //排序
            //2.1找到带插入的元素
            for(int i = h;i< a.length;i++){
                //2.2把待插入元素插入到有序数列中
                for (int j=i;j>=h;j-=h){

                   //带插入元素是a[j],比较a[j]与a[j-h]
                   if(greater(a[j-h],a[j])){
                       //交换元素
                       exch(a,j-h,j);
                   }else {
                       //待插入元素已经找到了合适的位置，结束循环
                       break;
                   }
                }
            }
            //减小h的值
            h=h/2;
        }
    }

    //比较v元素是否大于W元素
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    //数组元素i与j交换位置
    private  static  void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] =temp;
    }
}

这里的h和插入排序的1一样。

归并排序

个人理解就是分而治之的思想，先把元素分开，之后将元素逐步合并为有序元素
具体做法就是有两个阶段，第一个阶段就是分阶段即递归拆分为子序列，第二个阶段就是将有序的子序列合并为一个有序序列。

public class Merge {
    //归并所需要的辅助数组
    private static Comparable[] assist;

    //比较v元素是否小于W元素
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }

    //对数组a中的元素进行排序
    public static  void  sort(Comparable[] a){
        //1.初始化辅助数组assist
        assist = new Comparable[a.length];
        //2.定义一个变量lo变量和hi变量，分别记录宿主中最小的索引和最大的索引
        int lo=0;
        int hi=a.length-1;
        //3.调用sort重载方法完成数组a中，从索引lo到索引hi中的元素的排序
        sort(a,lo,hi);

    }

    //对数组a中从lo到hi的元素进行排序
    private  static void  sort(Comparable[] a,int lo, int hi){
        //做安全性校验；
        if (hi<=lo){
            return;
        }
        //对lo到hi之间的数据进行分为两个组
        int mid = lo+(hi-lo)/2;

        //分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);

        //再把两个组中的数据进行归并
        merge(a,lo,mid,hi);

    }

    //对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
    private  static  void merge(Comparable[] a,int lo,int mid,int hi){
        //定义三个指针
        int i=lo;
        int p1=lo;
        int p2=mid+1;

        //遍历，移动p1指针和p2指针，比较对应索引处的值，找出小的那个，放到辅助数组的对应索引处
          while(p1<=mid && p2<=hi){
            //比较对应索引处的值
            if (less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else {
                assist[i++] = a[p2++];
            }
        }

        //遍历，如果p1的指针没有走完，那么顺序移动p1指针，把对应元素放到辅助数组的对应索引处
       while (p1<=mid){
           assist[i++]=a[p1++];
       }
        //遍历，如果p2的指针没有走完，那么顺序移动p2指针，把对应元素放到辅助数组的对应索引处
        while (p2<=hi){
            assist[i++]=a[p2++];
        }
        //把辅助数组中的元素拷贝到原数组中
        for (int index=lo;index<=hi;index++){
            a[index]=assist[index];
        }
    }
}

快速排序
快速排序个人理解就是选一个元素左边的都比其小，右边的都比其大，之后在对左右继续选取元素，直到有序。
具体做法就是先选取第一个元素为分界值，右指针与左指针分别从右往左扫描寻找比第一个元素小的，从左往右寻找比第一元素大的，交换，一直进行直到左指针大于右指针，找到分界值。以分界值左右为俩部分分别继续即可

Merge.class

public class Quick {
    //比较v元素是否小于W元素
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    //数组元素i与j交换位置
    private  static  void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] =temp;
    }
    //对数组内的元素进行排序
    public static void sort(Comparable[] a){
        int lo = 0;
        int hi = a.length-1;
        sort(a,lo,hi);
    }

    //对数组a中从索引lo到索引hi之间的元素进行排序
    private static  void sort(Comparable[] a,int lo,int hi){
        //安全性校验
        if(hi<=lo){
            return;
        }

        //需要对数组中lo索引到hi索引处的元素进行分组(左子组与右子组)；
        int partition = partition(a,lo,hi);//返回的是分组的分界值所在的索引，分界值变换后的索引
        //让左子树右序
        sort(a,lo,partition-1);
        //让右子组有序
        sort(a,partition+1,hi);

    }
    //对数组a中，从索引lo到索引hi之间的元素进行分组，并返回分组界线对应的索引
    public static int partition(Comparable[] a,int lo,int hi){
        //确定分界值
        Comparable key = a[lo];
        //定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一个位置
        int left = lo;
        int right = hi+1;

        //切分
        while(true){
            //先从右往左扫描，移动right指针，找到一个比分界值小的元素，停止
            while(less(key,a[--right])) {
                if (right == lo) {
                    break;
                }
            }
            //再从左往右扫描，移动right指针，找到一个比分界值小的元素，停止
              while (less(a[++left],key)){
                  if(left>=right){
                      break;
                  }
              }
            //判断left>=right,如果是，则证明元素扫描完毕，结束循环，如果不是，则交换元素即可
                if (left>=right){
                    break;
                }else {
                    exch(a,left,right);
                }
            }
        //交换分解值
        exch(a,lo,right);
        return right;
    }
}

排序稳定性
A1、A2如果在排序时将原来A1与A2的位置顺序发生变化，则这个算法为不稳定算法，反之，则称为稳定算法。在应用中最常见的就是第一次根据价格排序、第二次根据销量排序，如果是稳定排序算法，则会减少元素交换次数，提高效率。

1. 稳定算法
   冒泡排序、插入排序、归并排序，这三个算法为稳定排序算法

2. 不稳定算法
   选择排序，在选取最小元素时，会将相同元素顺序颠倒
   希尔排序。多次插入排序会将相同元素位置顺序变化
   快速排序，选取基数元素时，会发生元素位置顺序发生变化