堆排序

正文之前

这一篇文章介绍一下堆的概念，以及堆排序

1. 基本概念、最大/最小堆
2. 堆排序
3. 分析

正文

1. 什么是堆

堆不是单独的一种结构，而是一种树状数据结构，通过二叉堆来实现，二叉堆也就是二叉树的一种，讲白了就是类似二叉树，只不过满足：

• 除了最底层，其他层全满，最底层按照从左至右的顺序填入节点（完全二叉树）

• 父节点大于等于或小于等于子节点，这两种情况就成为了最大堆/最小堆的定义：

最大堆：任意节点大于等于它的所有后裔（不仅是子节点，还有子节点的子节点等等），最大节点在堆顶

最小堆：任意节点小于等于它的所有后裔，最小节点在堆顶

还有一种叫法是大顶堆/小顶堆

给个图吧：

2. 堆排序

堆排序的步骤是这样的：

1. 用给定数组构建堆
   
2. 一个循环，每次选择堆顶元素，调换至末尾，然后缩小范围（相当于取出队首元素，添加至末尾，一轮循环后，数组就有序了）
   

首先我们先来写一下确定节点位置的代码：

    /**
     *  因为下标是从 0 开始的，在获取节点
     *  的时候要多 + 1
     * @param node 给定节点的位置
     * @return 对应节点位置
     */
    public int leftNode(int node){
        return 2 * node + 1;
    }
    public int rightNode(int node){
        return 2 * node + 2;
    }
    public int parentNode(int node){
        return (node - 1) / 2;
    }

这里的 parentNode() 方法没有用到，但是这个计算父节点的方式下面要用到，然后我们来写调整堆的方法，采用递归的方法，每一次递归我们只针对某个节点以及它的子节点：

    public void maxHeapify(int[] heap, int length, int node){
        //获取左右节点
        int left = leftNode(node);
        int right = rightNode(node);
        //当前最大节点（堆顶）
        int largest = node;
        //如果左子节点的值大于父节点的值，就改变 largest 的指向
        if (left < length && heap[left] > heap[largest]){
            largest = left;
        }
        //如果右子节点的值大于父节点的值，就改变 largest 的指向
        if (right < length && heap[right] > heap[largest]){
            largest = right;
        }
        //如果 largest 的指向改变了，就说明要调整堆，调换两个元素的位置
        if (largest != node){
            int temp = heap[node];
            heap[node] = heap[largest];
            heap[largest] = temp;
        } else {
            return;
        }
        maxHeapify(heap, length, largest);
    }

然后是构建堆的方法，就像在上面的代码中定义的寻找父节点位置的方法一样，(heap.length - 1) 代表的是堆中最后一个节点位置，(heap.length - 1) / 2 是最后一个节点的父节点的位置，从这里开始构建堆，避免多次不必要的递归，提高效率：

    public void buildHeap(int[] heap){
        for (int i = (heap.length - 1) / 2; i >= 0 ; i--) {
            maxHeapify(heap, heap.length, i);
        }
    }

最后便是堆排序的代码：

    public void heapSort(int[] heap){
        for (int i = heap.length - 1; i > 0; i--) {
            int temp = heap[0];
            heap[0] = heap[i];
            heap[i] = temp;
            maxHeapify(heap, i, 0);
        }
    }

划重点：这里之所以要用 i 来代替 heap.length，是因为我们要模拟从堆顶删除节点，实际上并没有删除，只是把它换到了末尾，所以通过堆大小 - 1 来达到模拟删除的效果

画了个堆排序的过程图：

数组 [3,5,2,6,4,1,10,7,9,8] 构建完后就是图中 1 的堆，然后把 4 和 10 对调，再调整堆，得到图中 2 的堆，把 6 和 9 对调，然后调整堆，以此类推：

接下来是计算的结果：

构建最大堆进行排序的结果是升序，因为大的节点在末尾，如果要降序排列，就构建最小堆

3. 分析

• 时间复杂度：

时间都花在了一开始的构建堆和接下来的调整堆过程，对于 n 个数：

首先是新建堆，时间复杂度 O(n)

每一次的调整堆都是 logn，总共有 n - 1 次，为 (n - 1) * logn = nlogn - logn

所以堆排序的时间复杂度是 O(nlogn)

• 空间复杂度

O(1)，因为是原地排序，没有借助其它辅助结构

• 稳定性

不稳定