Java学习笔记——排序算法之进阶排序（堆排序与分治并归排序）

春蚕到死丝方尽，蜡炬成灰泪始干

　　　　　　　　　　　　　　——无题

这里介绍两个比较难的算法：

1、堆排序

2、分治并归排序

先说堆。

这里请大家先自行了解完全二叉树的数据结构。

堆是完全二叉树。大顶堆是在堆中，任意双亲值都大于（或等于）其孩子值，就称其为大顶堆。

堆排序的步骤：

1、把数组想象成一个堆。数组的index+1就是其对应在堆中的序号

2、调堆中各值的顺序，得到大顶堆

3、将堆首位值与堆末尾值交换，最大值排序完毕

4、将堆得大小减1，重复步骤2和步骤3，直到堆中只剩下一个元素。排序完毕

上代码：

public class HeapSort {

    public static void heapSort(int[] arr){
        //建立完全二叉树，从最后一个双亲开始调整双亲值，直到根，调整完毕后大顶堆建立完成
        for (int i = arr.length >> 1; i > 0; i --) {
            heapAdjust(arr, i, arr.length);//调用堆要从1到length才符合堆的定义
        }
        //堆顶和堆低交换,获取最大值,然后调整大顶堆
        for (int i = arr.length - 1; i > 0; i--) {
            arr[i] = arr[i]^arr[0];
            arr[0] = arr[i]^arr[0];
            arr[i] = arr[i]^arr[0];
            heapAdjust(arr, 1, i);//因为堆计数要从1开始,所以size = endIndex + 1
        }
    }
    //调整大顶堆.先找左子,然后和右子比,取值大的,在和双亲自己比,自己比儿子大,break,否则交换.注意:根要从1开始才能找到左子
    public static void heapAdjust(int[] arr, int parents, int size){
        int j;//孩子们的标记是j,索引全部-1
        int i = parents;//双亲是i,索引全部-1
        while (i << 1 <= size) {
            j = i << 1;//左子
            if (j + 1 <= size) {//有右子
                if (arr[j - 1] < arr[j + 1 -1])
                    j ++;
            }
            if (arr[i - 1] > arr[j - 1])
                break;
            arr[i-1] = arr[i-1]^arr[j-1];
            arr[j-1] = arr[i-1]^arr[j-1];
            arr[i-1] = arr[i-1]^arr[j-1];
            i = j;//儿子变为父亲,这里不知道是左子还是右子,所以不能直接通过for循环的迭代步骤<<i调整i值,如果是右子的话就错了(右子<<1+1)
        }
    }
}

再说分治并归排序

这里先要了解什么是递归

public class MergingTest {

    public static void main(String[] args) {
        mSort(0, 3);
    }
    private static void mSort(int left, int right) {
        int m = (left + right)/2;
        if (left == right) {
            System.out.println(left);
            return;
        }
        mSort(left, m);
        mSort(m+1, right);
    }
}

这几行代码是并归算法的核心。运行代码将输出0123456789，虽然看上去很简单，但是如果真能明白，说明你已经完全理解递归的思想了，写出并归算法也就不在话下了。

为什么会输出0123呢？

代码执行的走向：1→2→4→2→5→2→1→3→6→3→7→3→1→return

能领悟这个东西就好办了，上代码:

public class MergingSort {

    public static void mergingSort(int[] arr) {
        int[] temp = new int[arr.length];
　　　　　　//temp是相当于一张牌，通过left,m,right在逻辑上分成两个数组，进行分治排序,arr是原数组，对数组排序不传数组怎么行？！
        mSort(arr, temp, 0, arr.length-1);
    }
    private static void mSort(int[] arr, int[] temp, int left, int right) {
　　　　　　//这里的分组逻辑没有使用到temp和arr，而是把它们作为参数传入merge方法
        int m = (left+right)/ 2;
        if (left == right) {
            return;
        }
        mSort(arr, temp, left, m);
        mSort(arr, temp, m+1, right);
        merge(arr,temp,left,m,right);
    }
    private static void merge(int[]arr, int[] temp, int left, int m, int right) {
　　　　　　//分治排序极其简单，已知两个有序数组，要把他们合并成一个有序数组，用什么方法都不用说，大家一想就知道了。
        for (int c = 0;c < arr.length;c++){
            temp[c] = arr[c];
        }
        for (int p = 0; p < temp.length; p++) {
            System.out.println("temp["+p+"] = " + temp[p]);
        }
        int i = left;
        int j = m + 1;
        int k = left;
        while (i<=m && j<=right) {
　　　　　　　　//使用分支结构，把每摞牌最小的那个挑出来给arr
            if (temp[i] < temp[j]) {
                arr[k++] = temp[i++];
            }
            if (temp[j] < temp[i]) {
                arr[k++] = temp[j++];
            }
        }
　　　　　　　　//使用分支结构，把剩下的那摞牌都塞给arr
        if (i > m) {
            while (j <= right) {
                arr[k++] = temp[j++];
            }
        }
        if (j > right) {
            while (i <= m) {
                arr[k++] = temp[i++];
            }
        }
    }
    
}