排序算法（2）

希尔排序

希尔排序也被叫做增小量排序，是一种对于插入排序的优化排序。

对于插入排序，越是有序的是数据就越高效，相对的数组越无序那则也低效，所以就产生了一种对于它的优化排序。

特点：在排序前先获得一个增量gap(如gap=5)，

           第一趟对于下标为i,i+5,i+10,....以此类推的数据进行插入排序，然后gap/=2；

          第二趟对于下标为i,i+2,i+4,.....插入排序，继续gap/=2；

         ......

         最后一趟是取gap=1，对数组进行插入排序，此时数组基本有序，插入排序的就会很高效。

         

public static void shellSort(int[] arr){
        for (int gap=arr.length;gap>0 ;gap/=2 ) {
            for (int i = gap; i < arr.length; i++) {
                for (int j=i;j-gap>=0 && j<arr.length;j+=gap ){
                    int temp=arr[j];
                    if (arr[j]<arr[j-gap]){
                        arr[j]=arr[j-gap];
                        arr[j-gap]=temp;
                    }
                }
            }
        }
    }

归并排序

来源百度百科：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

过程描述：

归并过程为：比较a[i]和b[j]的大小，若a[i]≤b[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素b[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

原理：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出序列尾

将另一序列剩下的所有元素直接复制到合并序列尾

下面我就来做个小小的总结：

• 将两个已排好序的数组合并成一个有序的数组,称之为归并排序
• 步骤：遍历两个数组，比较它们的值。谁比较小，谁先放入大数组中，直到数组遍历完成

下面插入代码实现

 public static void mergeSort(int[] arrays, int l, int r) {
        //if
        if (l == r) {
            return;
        } else {
            int m = (l + r) / 2;
            mergeSort(arrays, l, m);
            mergeSort(arrays, m + 1, r);
            merge(arrays, l, m + 1, r);
        }
    }

    private static void merge(int[] arrays, int l, int m, int r) {
        //左数组
        int[] leftArray = new int[m - l];
        //有数组
        int[] rightArray = new int[r - m + 1];//
        //对左右数组填充
        for (int i = l; i < m; i++) {
            leftArray[i - l] = arrays[i];
        }
        for (int j = m; j <= r; j++) {
            rightArray[j - m] = arrays[j];
        }
        //比较左右数组  那个数据小放到arr里  一次操作一个数据
        int i = 0, j = 0, k = l;
        while (i < leftArray.length && j < rightArray.length) {
            if (leftArray[i] < rightArray[j]) {
                arrays[k] = leftArray[i];
                i++;
                k++;
            } else {
                arrays[k] = rightArray[j];
                j++;
                k++;
            }
        }
        while (i < leftArray.length) {
            arrays[k] = leftArray[i];
            i++;
            k++;
        }
        //如果右边的数组还没比较完，左边的数都已经完了，那么将右边的数抄到大数组中(剩下的都是大数字)
        while (j < rightArray.length) {
            arrays[k] = rightArray[j];
            j++;
            k++;
        }
    }

快速排序

基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

快速排序用基准来对数组进行分组，所以对越乱的数据排序的效率就越高，对越有序的数据排序的效率就越低。

public static void quickSort(int[] arr,int l,int r){
        int i=l;
        int j=r;
        if (i > j) return;//跳出条件
        int temp=arr[l];//以第一个数为基准
        while (i < j ){//保证左半边数都小于基准  右半边数都大于基准
            while (arr[j]>=temp && i<j){//先从数组右边开始 找到第一个比基准小的数
                j--;
            }
            while (arr[i]<=temp && i<j){//从数组左边开始 找到第一个比基准大的数字
                i++;
            }
            if (i<j){//交换两个数的位置
                int tempValue=arr[i];
                arr[i]=arr[j];
                arr[j]=tempValue;
            }
        }
        //此时 i==j
        //交换基准 把下标为i的数当作新的基准
        arr[l]=arr[i];
        arr[i]=temp;
        quickSort(arr,l,i-1);//左边数组
        quickSort(arr,i+1,r);//右边数组
    }