【转】堆排序Heap Sort——Java实现

首先，堆是一种数据结构，你可以把他看成一颗完全二叉树，如下图所示：圆圈上方的数字代表下标：他的特性就是：父结点的值要大于两个儿子结点的值。

        上图选自算法导论，下标从1开始，但我们写的时候，肯定是要按照从0开始的下标来写代码拉，这一点后面不会再特别说明了。

        虽然堆可以用数组表示，但堆和数组有所区别，主要是在于数组的长度（length）不一定等于堆的大小（heapSize）。heapSize <= length。下标大于heapSize但小于length的值都不属于堆结构。

        所以，在java里先新建一个类来表示堆：没有使用数组的原因是，java里数组初始化以后就不能再添加元素了，在讲解后面内容的时候会有所不方便。ps:最后面有我用数组方式实现的堆排序

    public class Heap {  
      
        private ArrayList A;  
      
        private int heapSize;  
      
        public ArrayList getA() {  
            return A;  
        }  
      
        public void setA(ArrayList a) {  
            A = a;  
        }  
      
        public int getHeapSize() {  
            return heapSize;  
        }  
      
        public void setHeapSize(int heapSize) {  
            this.heapSize = heapSize;  
        }  
          
    } 

很容易得知，结点i的左儿子右儿子或父结点的下标的计算函数

// 左节点下标
    public int left(int i) {
        return i * 2 + 1;
    }
 
    // 右节点下标
    public int right(int i) {
        return i * 2 + 2;
    }
 
    // 父节点下标
    public int parent(int i) {
        return (i - 1) / 2;
    }

要实现堆排序，我们首先得保持堆的性质。（下面用最大堆举例）

      当儿子结点大于父节点的时候，就失去了最大堆的性质，所以在这个时候，我们只要把儿子结点和父结点交换，但是交换以后，被交换的父结点的儿子结点发生了变化，可能会继续违背最大堆这个性质，所以要递归调用这个算法。过程大致如下图所示：

对2号结点进行最大堆性质的保持

要实现这个过程的代码如下：

   /**
     * 递归实现的堆排序
     * @param heap 堆
     * @param i 当前坐标
     */
    public void MaxHeapify(Heap heap, int i) {
        int l = left(i);
        int r = right(i);
        int largest = i;
        if (l < heap.getHeapSize() && heap.getA().get(l) > heap.getA().get(i)) {
            largest = l;
        }
        if (r < heap.getHeapSize() && heap.getA().get(r) > heap.getA().get(largest)) {
            largest = r;
        }
        if (largest != i) {
            int temp = heap.getA().get(i);
            heap.getA().set(i, heap.getA().get(largest));
            heap.getA().set(largest, temp);
        } else
            return;
        MaxHeapify(heap, largest);
    }

 

其实，这个算法是可以非递归实现的，可以提升效率：

/**
     * 非递归实现的堆排序
     * @param heap 堆
     * @param i 当前坐标
     */
    public void MaxHeapifyNoRecursive(Heap heap, int i) {
        while (true) {
            int l = left(i);
            int r = right(i);
            int heapSize = heap.getHeapSize();
            ArrayList A = heap.getA();
            int largest = i;
            if (l < heapSize && A.get(l) > A.get(i)) {
                largest = l;
            }
            if (r < heapSize && A.get(r) > A.get(largest)) {
                largest = r;
            }
            if (largest != i) {
                int temp = A.get(i);
                A.set(i, A.get(largest));
                A.set(largest, temp);
            } else
                return;
            i = largest;
        }
    }

 

有了上述的算法，我们就可以进行建堆操作了，建堆的过程很简单，从下标heapSize - 1开始，对每个结点都执行MaxHeapify就行了，但是叶子结点由于没有子结点，所以只需要从（heapSize - 1）/2开始，对每个结点都执行MaxHeapify就行了

/**
     * 构建最大堆
     * @param heap 堆
     */
    public void BuildMaxHeap(Heap heap) {
        int heapsize = heap.getHeapSize();
        for (int i = (heapsize - 1) / 2; i>= 0; i--) {
            MaxHeapify(heap, i);
        }
    }

这个过程大概如下图所示：

 

接下来，就是堆排序算法了。

先用BuildMaxHeap把输入的数组A构造成最大堆。然后，把下标heapSize - 1的元素和下标为0的元素对换，通过减小heapSize，让下标为heapSize - 1的元素从堆中剔除，再调用MaxHeapify（heap, 0）即可保证最大堆的性质。重复这个过程，直到堆中只剩下一个元素。

/**
     * 堆排序算法
     * @param heap 堆
     */
    public void HeapSort(Heap heap) {
        BuildMaxHeap(heap);
        int length = heap.getA().size(), heapSize = heap.getHeapSize();
        for (int i = length - 1; i > 0; i--) {
            int temp = heap.getA().get(i);
            heap.getA().set(i, heap.getA().get(0));
            heap.getA().set(0,temp);
            heap.setHeapSize(--heapSize);
            MaxHeapify(heap, 0);
        }
    }

这个过程的图示如下：

 

这样堆排序算法就算完成了，复杂度仅为O(nlg(n))，但是，其实快速排序往往优于它，虽然复杂度和它一样。

声明：此为转发博文，原博文地址：https://blog.csdn.net/sunnylinner/article/details/52585225

在此配上我用数组实现的堆排序：

package arithmetic;
import java.util.Arrays;
/**
 * 堆排序java实现
 */
public class HeapSort {
    static int k = 0; //全局k,用于排序一次后获得一个最大的，需要数组的size-1
    public static void main(String[] args) {
        int[] datas = {4,2,87,4,2,7,9,6,3,7};
        System.out.println(Arrays.toString(datas));
        //初始化堆
        buildHeap(datas);
        //进行排序
        for (int i = datas.length-1; i > 0 ; i--) {
            //堆顶的最大值与数组的最后一个元素交换（此处为k存在的原因）
            int temp = datas[i];
            datas[i] = datas[0];
            datas[0] = temp;
            k++; //使数组的size-1
            //调整堆
            adjustHeap(datas,0);
        }
        System.out.println(Arrays.toString(datas));
    }
    /**
     * 初始化堆
     * @param datas 需被初始化的数组
     */
    static void buildHeap(int[] datas){
        //(datas.length-1)>>1 从最底层的上一层开始（从最后有孩子节点的一层开始）
        for (int i = (datas.length-1)>>1; i >= 0; i--) {
            adjustHeap(datas,i);
        }
    }
    /**
     * 调整堆
     * @param datas 需被调整的堆
     * @param i  调整元素所在的位置
     */
    static void adjustHeap(int[] datas , int i){
        //循环，使可以调整到底部:因为如果上层调整，可能会影响到下层，所以要while知道该层下面的数据都满足条件
        while(true){
            int left = (i<<1)+1;  //左孩子
            int right = (i<<1)+2;  //右孩子

            int largest = i;  //标识自身和孩子中，最大值的下标
            if (left < datas.length-k && datas[i] < datas[left]){
                largest = left;
            }
            if (right < datas.length-k && datas[largest] < datas[right]){
                largest = right;
            }
            //如果满足条件，表示最大的不是节点自身，则交换
            if (largest != i){
                int temp = datas[i];
                datas[i] = datas[largest];
                datas[largest] = temp;
            }else{  //否则，退出循环
                    // 原因：因为是从最下面开始进行调整的，所以我们可以只要最大节点是节点自身，我们就可以直接退出
                return; 
            }
            i = largest;   //修改自身节点
        }
    }
}