堆排序

堆排序

堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法:

  1. 大顶堆:每个节点的值都大于或等于其子节点的值,在堆排序算法中用于升序排列;
  2. 小顶堆:每个节点的值都小于或等于其子节点的值,在堆排序算法中用于降序排列;

堆排序的平均时间复杂度为 Ο(nlogn)。不稳定

首先理解一个东西 heapify

给定一个堆(完全二叉树)


dui
  1. 把给定节点作为父节点,与其两个子节点比较,让最大的成为父节点。
  2. 产生交换之后,自然下一层就会受影响,那么需要用递归的方法对下一层的各种子树再进行heapify操作。
  3. 当递归到最后的子节点是,递归结束。
    这时就完成了把最大的数放在对顶的操作
    image.png

算法步骤

  1. 将待排序序列构建成一个堆 H[0……n-1],根据(升序降序需求)选择大顶堆或小顶堆;
    比如第一次换好的是:


    image.png
  2. 把堆首(最大值)和堆尾互换(意思就是最大的沉下去,或者砍掉最后一个子节点);


    image.png
  3. 去掉最后一个元素(已找到的最大的),即把堆的尺寸缩小 1,并调用 shift_down(0),目的是把新的数组顶端数据调整到相应位置;

  4. 重复步骤 2,直到堆的尺寸为 1。就是再heapify再砍 最后砍光就成功了。

Python

注:这个代码里是第一次建立堆时先heapify,后面就方便直接砍再heapify,也可以先按照原始数组建堆,再执行排序。

class Solution:
    def MySort(self , arr ):
        # write code here
        global arrLen
        arrLen = len(arr)
        # 先建大顶堆,把最大的元素放在对顶,并且父>子
        def buildMaxHeap(arr):
            import math
            # floor:向下取整,range(父节点,到-1,步长-1)
            for i in range(math.floor(len(arr)/2), -1, -1):
                heapify(arr, i)
                
        def heapify(arr, i):
            leaf = 2*i + 1 #左孩子
            right = 2*i + 2 #右孩子
            largest = i
            # 比较三个最大,最大的当爸, 防止越界:leaf < arrLen
            if leaf < arrLen and arr[leaf] > arr[largest]:
                largest = leaf
            if right < arrLen and arr[right] > arr[largest]:
                largest = right
            
            if largest != i :
                swap(arr, i, largest)
                heapify(arr, largest)
        
        def swap(arr, i, j):
            arr[i], arr[j] = arr[j], arr[i]
            
        buildMaxHeap(arr)
        for i in range(len(arr)-1, 0, -1):
            #堆顶和最后一个元素交换
            swap(arr, 0, i)
            #再砍去最后一个元素
            arrLen -= 1
            heapify(arr, 0)
        return arr

Java

public class HeapSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝,不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int len = arr.length;

        buildMaxHeap(arr, len);

        for (int i = len - 1; i > 0; i--) {
            swap(arr, 0, i);
            len--;
            heapify(arr, 0, len);
        }
        return arr;
    }

    private void buildMaxHeap(int[] arr, int len) {
        for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
            heapify(arr, i, len);
        }
    }

    private void heapify(int[] arr, int i, int len) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;

        if (left < len && arr[left] > arr[largest]) {
            largest = left;
        }

        if (right < len && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {
            swap(arr, i, largest);
            heapify(arr, largest, len);
        }
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

推荐阅读更多精彩内容