数据结构-堆(Heap)

本文详细介绍了堆的主要知识点,包括堆结构的概念、堆的类型、heapInsert和heapify操作及其应用场景,以及堆排序的原理和时间复杂度。在Java中,PriorityQueue即采用了堆结构,作为默认的小根堆实现。

堆的主要知识点

1.堆结构就是用数组实现的完全二叉树结构
2.完全二叉树中如果每棵子树的最大值都在顶部就是大根堆
3.完全二叉树中如果每棵子树的最小值都在顶部就是小根堆
4.堆结构的heapInsert与heapify操作
5.堆结构的增大和减少
6.优先级队列结构,就是堆结构(在Java中是PriorityQueue)

堆是用数组实现的,二叉树的结构实际上不存在,只是我们脑补出来的结构。
若数组下标i从0开始,则存在一下关系:
左孩子下标:i * 2 + 1
右孩子下标:i * 2 + 2
父节点下标:(i - 1) / 2
注意以下讨论的情况都是围绕大根堆的。

heapInsert操作(把节点向上调的过程)

适用场景:1.新加一个元素到最后一个节点;2.某元素的值变大,需要调整大根堆
时间复杂度:O(logN)。因为完全二叉树的高度为log(2, N),所以最多比较log(2, N)次,故时间复杂度为O(logN)。
Code:

	public static void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
        }
    }

heapify操作(把节点向下调的过程)

把节点向下调的过程,与子节点中较大的节点交换。因为要是交换较小的节点以后,那么这个节点调上去之后子节点都比自己大,这就破坏了大根堆的结构。
适用场景:某元素的值变小,需要调整大根堆
时间复杂度:O(logN)

如果元素的值变化,但不知道是变大还是变小,可以同时尝试heapifyheapInsert,因为只会发生其中的一个操作,所以时间复杂度为O(logN)。
Code:

	public static void heapify(int[] arr, int index, int size) {
        int left = index * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left] < arr[left + 1] ? left + 1 : left; // 这个条件很重要
            largest = arr[index] < arr[largest] ? largest : index;
            if (largest == index) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

堆排序

堆排序就是先把未排序的数组调整成大根堆(以升序为例,如果是降序,则需要调整为小根堆),然后每次都把大根堆的堆顶调整到最后,再把堆的大小减去1。因为堆的大小变小了,我们再把这个堆继续调整为大根堆,把堆顶调整到最后,再把堆的大小减1,周而复始,直到堆的大小变为0。由于每次调整堆后都把堆顶的置换到最后,所以我们得到的最终结果一定是一个排序的数组。
思路:
1.把数组变成大根堆(heapInsert)
2.a[0]与a[size]交换(size为堆的长度),size-1
3.把a[0]向下heapify
4.重复2、3,直到size=0
时间复杂度:O(n*logN)
Code:

public class HeapSort {

    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

		//先把数组调整成大根堆
        for (int i = 0; i < arr.length; i++) { // O(n)
            heapInsert(arr, i); //O(nlogN)
        }
		//由于大根堆的第一个节点最大,所以直接把它调到最后
        int size = arr.length;
        swap(arr, 0, --size);

        while (size > 0) { // O(n)
            heapify(arr, 0, size); // O(logN)
            swap(arr, 0, --size);
        }
    }

    public static void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
        }
    }

    public static void heapify(int[] arr, int index, int size) {
        int left = index * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left] < arr[left + 1] ? left + 1 : left; // 判断右孩子是否存在,以及左右孩子哪个比较大
            largest = arr[index] < arr[largest] ? largest : index;
            if (largest == index) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }


    public static void main(String[] args) {
        int[] arr = {1, 8, 4, 7, 3, 6, 5, 2};
        printArray(arr);
        heapSort(arr);
        printArray(arr);
    }

}

注意heapify代码中的这个条件要这样写

int largest = left + 1 < size && arr[left] < arr[left + 1] ? left + 1 : left;

只有同时满足两个条件最大索引才是left + 1。
上述的堆排序建堆的时候是从上往下建堆,时间复杂度是O(n*logN)。
如果从下往上建堆,则需要的时间复杂度为O(N)。具体实现思路是从最后一个节点开始依次往前heapify。

Java中的优先队列

在Java中,PriorityQueue实际上就是堆的结构,默认上是小根堆。

		//默认小根堆(底层就是堆结构)
		PriorityQueue<Integer> heap = new PriorityQueue<>();
		heap.add(4);
		heap.add(7);
		heap.add(2);
		heap.add(1);
		heap.add(0);
		heap.add(9);
		while(!heap.isEmpty()) {
			System.out.println(heap.poll());
		}
		//0 1 2 4 7 9

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值