八大排序算法JAVA实现（时间复杂度O(n*logn)篇）

本文讲述时间复杂度为n*logn的排序算法：归并排序、快速排序、堆排序以及希尔排序的原理、Java实现以及变形应用。

一、归并排序

• 原理：把两个有序数列合并为一个有序数列。需递归实现。
• Java实现：

 1     public int[] mergeSort(int[] a, int n)
 2     {
 3         return doMergeSort(a, n, 0, n - 1);
 4     }
 5         public int[] doMergeSort(int[] a, int n, int start, int end)
 6     {
 7         int[] res = new int[n];
 8         if (n <= 1)
 9         {
10             res[0] = a[start];
11             return res;
12         }
13         // n>=2时，对其左右数组进行处理
14         int half = n / 2;
15         int leftEnd = start + half - 1;
16         int rightStart = leftEnd + 1;
17         //递归调用本函数，获取有序的左数组以及右数组
18         int[] left = doMergeSort(a, half, start, leftEnd);
19         int[] right = doMergeSort(a, n - half, rightStart, end);
20         // 将左右序列合并
21         int k = 0, i = 0, j = 0;
22         while (i < half && j < n - half)
23         {//由前往后比较两个序列，取较小值填充到res中，取值后该序列往后移动取下一个值比较
24             if (left[i] <= right[j])
25             {
26                 res[k++] = left[i++];
27             }
28             else
29             {
30                 res[k++] = right[j++];
31             }
32         }
33         // 剩余的直接放入
34         while (i < half)
35         {
36             res[k++] = left[i++];
37         }
38         while (j < n - half)
39         {
40             res[k++] = right[j++];
41         }
42         return res;
43     }            

二、快速排序

• 原理：每一次将一个数放在一个左边的数全部比它小，且右边的数全部比它大的位置，然后递归调用函数，将其左右序列排好。这边有一个比较好理解的做法：在数组的左边维护一个小于区间，在遍历的时候，发现比当前数小的数字的时候，将，扩增小于区间，并其放到小于区间内，结束后将当前数填充在小于区间后即可。
• Java实现：

 1     public int[] quickSort(int[] a, int n)
 2     {
 3         doQuickSort(a, n, 0, n - 1);
 4         return a;
 5     }
 6     public void doQuickSort(int[] a, int n, int start, int end)
 7     {
 8         if (n > 1)
 9         {
10             int current = a[end];
11             int minLen = 0;// 小于区间的长度
12             int i = start;
13             for (; i < end; i++)
14             {
15                 if (a[i] < current)
16                 {//发现比当前数小的数，扩充小于区间
17                     int temp = a[start + minLen];
18                     a[start + minLen] = a[i];
19                     a[i] = temp;
20                     minLen++;
21                 }
22             }
23             a[end] = a[start + minLen];
24             a[start + minLen] = current;
25             //当前位置已经确定，排左右序列
26             doQuickSort(a, minLen, start, start + minLen - 1);
27             doQuickSort(a, n - minLen - 1, start + minLen + 1, end);
28         }
29     }        

• 变形应用：三色排序练习题

[0,1,1,0,2,2],6

返回：[0,0,1,1,2,2]

解析：运用快排的原理。用数字1来处理，在数组左右各维护一个小于区间和大于区间。

三、堆排序

• 原理：维护一个大根堆（小根堆同理），即维护一棵二叉树，该数子节点永远比父节点小。每次在大根堆中取出根，根为此时待排序列最大值，放在待排序列最后，然后调整大根堆，重复上诉过程即可。
• Java实现：博主不太会插图，关于大小根堆的调整细节可自行百度。原理总结来说是从最后一个非叶子节点开始，往前调整。设当前调整的非叶子节点为n，选举n，n的左，n的右三个节点的最大值作为父节点。且每次调整了靠前的非叶子节点的值后，可能会破坏下面的数的大根堆规则，需要再次调整。嗯我觉得我并没有讲清楚，百度看看图就好。

    public int[] heapSort(int[] a, int n)
    {
        for (int len = n; len > 0; len--)
        {// len为构建的堆的大小
            for (int i = len / 2 - 1; i >= 0; i--)
            {// 从后往前遍历非叶子节点
                while (2 * i + 1 < len)
                {
                    int j = 2 * i + 1;// 左节点序号
                    if (j + 1 < len && a[j] < a[j + 1])
                    {
                        j++;
                    }
                    if (a[i] < a[j])
                    {
                        int temp = a[j];
                        a[j] = a[i];
                        a[i] = temp;
                        i = j;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            int temp = a[len - 1];
            a[len - 1] = a[0];
            a[0] = temp;
        }
        return a;
    }

• 变形应用：常规应用如在1000+个数中找出最大的10个数之类的。

四、希尔排序

• 原理：变形后的插入排序，每个数只与它前面固定步长的倍数的位置进行比对。如：步长step，当前数与它前面step，step*2，step*3....位置进行比较，插入到合适的位置。
• Java实现：

    public int[] shellSort(int[] a, int n)
    {
        // 步长选择
        for (int k = 1, step = 10; step > 1; k++)
        {
            step = n / (2 * k);
            for (int i = step; i < n; i++)
            {
                if (a[i] < a[i - step])
                {
                    int temp = a[i];
                    a[i] = a[i - step];
                    a[i - step] = temp;
                    int pre = i - step;
                    while (pre - step > 0)
                    {
                        if (a[pre] < a[pre - step])
                        {
                            temp = a[pre];
                            a[pre] = a[pre - step];
                            a[pre - step] = temp;
                            pre -= step;
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
        }
        return a;
    }