数据结构 Java数据结构 ---- 堆(优先级队列)

转x33g5p2x  于2022-03-10 转载在 Java  
字(5.9k)|赞(0)|评价(0)|浏览(541)

堆(优先级队列)

1.二叉树的顺序存储

1.1 存储方式

使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。
一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。
这种方式的主要用法就是堆的表示。

1.2 下标的关系

  1. 如果 已知双亲下标(parent) ,则:
    左孩子的下标(left child) = 2 * parent + 1;
    右孩子的下标(right child) = 2 * parent + 2;
  2. 如果 已知任意孩子下标(child),则:
    双亲的下标(parent) = ( child - 1 ) / 2;

2.堆

2.1 概念

  1. 堆逻辑上是一棵完全二叉树
  2. 堆物理上是保存在数组中
  3. 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆
  4. 反之，则是小堆，或者小根堆，或者最小堆
  5. 堆的基本作用是，快速找集合中的最值

3.模拟实现PriorityQueue

①基本操作

  1. class TestHeap {
  2.     public int[] elem;
  3.     public int usedSize;
  5.     public TestHeap(){
  6.         this.elem = new int[10];
  7.     }
  8. }

②向下调整

思路:

代码实现:

  1. //len是有效数据长度
  2.     public void adjustDown(int root,int len) {
  3.         int parent = root;
  4.         int child = 2 * parent + 1;
  6.         while(child < len){
  7.             //找到左右孩子的最大值
  8.             //1. 没有右孩子,左孩子就是最大.child下标下就是最大
  9.             //2. 有右孩子,但是左孩子更大,即左孩子是最大.child下标下就是最大
  10.             //3. 有右孩子,但是右孩子更大,即右孩子是最大.child+1 下标下就是最大
  11.             if(child+1 < len && this.elem[child] < this.elem[child+1]){
  12.                 child++;
  13.             }
  14.             //此时child下标下就是最大值.
  15.             if(this.elem[child] > this.elem[parent]){
  16.                 int tmp = this.elem[child];
  17.                 this.elem[child] = this.elem[parent];
  18.                 this.elem[parent] = tmp;
  19.                 parent = child;
  20.                 child = 2 * parent + 1;
  21.             }else {
  22.                 break;
  23.             }
  24.         }
  25.     }

③建堆

建大堆 - 思路:
从最后一个数据的 双亲开始 向下调整. 每次调整完 让parent-- 直到调整到parent = 0;

  1. /**
  2.      * 建大堆
  3.      * @param array
  4.      */
  5.     public void createHeap(int[] array){
  6.     	//这一步相当于 数组的拷贝
  7.         for (int i = 0; i < array.length; i++) {
  8.             this.elem[i] = array[i];
  9.             this.usedSize++;
  10.         }
  11.         //parent 就代表每颗子树的根节点
  12.         for (int parent = (array.length-1-1)/2;parent >= 0; parent--) {
  13.             adjustDown(parent,this.usedSize);
  14.         }
  15.     }

时间复杂度的分析:

④入队列

思路:从队尾入,每次入队列都要进行向上调整
向上调整:
① 如果插入的child比parent大 则需要交换
② 交换后需要让child = parent; parent = (child - ) / 2;
③ 如果插入的child比parent小 则不需要交换
④循环①②③操作,直到不需要交换或则 child<0结束循环.

代码实现:

  1. public void adjustUp(int child){
  2.     	//parent等于child的双亲
  3.         int parent = (child - 1) / 2;
  5. 		//child>0进入循环
  6.         while(child > 0) {
  7.             if (this.elem[child] > this.elem[parent]){
  8.                 int tmp = this.elem[parent];
  9.                 this.elem[parent] = this.elem[child];
  10.                 this.elem[child] = tmp;
  11.                 child = parent;
  12.                 parent = (child - 1) / 2;
  13.             }else {
  14.             	//不需要交换直接跳出循环
  15.                 break;
  16.             }
  17.         }
  18.     }

入队思路:
1.首先判断是否需要扩容
2.如果需要扩容则要先扩容然后插入,不需要扩容直接插入
3.插入后进行向上调整
代码实现:

  1. public void push(int val){
  2.         if(isFull()){
  3.         	//扩容
  4.             Arrays.copyOf(this.elem,2*this.elem.length);
  5.         }
  6.         //插入   向上调整
  7.         this.elem[this.usedSize++] = val;
  8.         adjustUp(usedSize - 1);
  9.     }
  10. 	//判断是否满
  11.     public boolean isFull(){
  12.         return this.usedSize == this.elem.length;
  13.     }

⑤出队列

出队列思路:
1.首先需要判断是否为空
2.为空直接返回
3.不为空,首先交换队首元素和队尾元素,然后从0下标开始进行向下调整.

代码实现:

  1. //判断是否为空
  2.     public boolean isEmpty(){
  3.         return this.usedSize == 0;
  4.     }
  5.     public void pop(){
  6.         if(!isEmpty()){
  7.         	//不为空首先进行交换
  8.             int tmp = this.elem[0];
  9.             this.elem[0] = this.elem[usedSize - 1];
  10.             this.elem[usedSize - 1] = tmp;
  11.             this.usedSize--;
  12.             //然后进行向下调整
  13.             adjustDown(0,this.usedSize);
  14.         }
  15.     }

⑥堆排序

堆排序思路:
1.让end指向队尾元素
2.让队首元素和end交换
3.从0下标位置进行向下调整 然后end–;
4.重复以上操作直到end=0;

代码实现:

  1. /**
  2.      * 前提是要先创建大堆
  3.      */
  4.     public void heapSort() {
  5.         int end = this.usedSize - 1;
  6.         while(end > 0) {
  7.             int tmp = this.elem[0];
  8.             this.elem[0] = this.elem[end];
  9.             this.elem[end] = tmp;
  10.             adjustDown(0,end--);
  11.         }
  12.     }

4.堆的应用-优先级队列

4.1 java 中的优先级队列

PriorityQueue implements Queue

错误处理抛出异常返回特殊值
入队列add(e)offer(e)
出队列remove()poll()
队首元素element()peek()

4.2 java 中堆的使用

注意:

  1. 堆的默认大小是 11 默认为小堆
  2. 可以指定堆的大小,可以指定堆为大小堆.
  1. public static void main (String[] args) {
  2.         //堆 默认是大小为11
  3.         PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
  4.         //默认是 小堆
  5.         priorityQueue.add(1);
  6.         priorityQueue.add(2);
  7.         priorityQueue.add(3);
  8.         System.out.println(priorityQueue);
  9.     }

5. 集合框架中PriorityQueue的比较方式

集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比大小，PriorityQueue采用了：
Comparble和Comparator两种方式。

  1. Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接
    口，并覆写compareTo方法
  2. 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现
    Comparator接口并覆写compare方法。

6.堆的其他应用-TopK 问题

TopK问题,找前K个最大(最小)的数.

用堆的思路:

  1. 放入k个元素到堆中
    ①找前k个最大的数,建小堆.
    ②找前k个最小的数,建大堆.
  2. 如果找的是前k个最大的数,先建小堆将k个元素放入堆中,然后让堆顶元素 和 后面的数比较,如果小于后面的数,就和堆顶元素交换,然后变成小堆继续此操作.
  3. 反之则是找前k个最小的数.
  4. 遍历结束后,堆中的元素就是要找的数

画图解析:

代码实现:

  1. /**
  2.      * 找前k个最大的元素
  3.      * @param array
  4.      * @param k
  5.      */
  6.     public static void topk2(int[] array,int k){
  7.         PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
  8.             @Override
  9.             public int compare(Integer o1, Integer o2) {
  10.                 return o1 - o2;//大堆
  11.             }
  12.         });
  13.         for (int i = 0; i < array.length; i++) {
  14.             if (maxHeap.size() < k) {
  15.                 maxHeap.offer(array[i]);
  16.             } else {
  17.                 int top = maxHeap.peek();//获取队顶元素
  18.                 if (top < array[i]) {
  19.                     maxHeap.poll();
  20.                     maxHeap.offer(array[i]);
  21.                 }
  22.             }
  23.         }
  24.         System.out.println(maxHeap);
  25.     }
  26.     /**
  27.      * 找前k个最小的元素
  28.      * @param array
  29.      * @param k
  30.      */
  31.     public static void topk1(int[] array,int k){
  32.         PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
  33.             @Override
  34.             public int compare(Integer o1, Integer o2) {
  35.                 return o2 - o1;//大堆
  36.             }
  37.         });
  38.         for (int i = 0; i < array.length; i++) {
  39.             if (maxHeap.size() < k) {
  40.                 maxHeap.offer(array[i]);
  41.             } else {
  42.                 int top = maxHeap.peek();//获取队顶元素
  43.                 if (top > array[i]) {
  44.                     maxHeap.poll();
  45.                     maxHeap.offer(array[i]);
  46.                 }
  47.             }
  48.         }
  49.         System.out.println(maxHeap);
  50.     }
  52.     public static void main(String[] args) {
  53.         int[] array = {1,3,2,6,5,78,22,15,28};//找前3个最大的数据.
  54.         topk1(array,3);
  55.         topk2(array,4);
  56.     }

运行结果:

7.面试题—查找和最小的K对数字

LeetCode 373: 查找和最小的K对数字
描述:
给定两个以升序排列的整数数组 nums1 和 nums2 , 以及一个整数 k 。
定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2 。
请找到和最小的 k 个数对 (u1,v1), (u2,v2) … (uk,vk) 。
示例 1:
输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3
输出: [1,2],[1,4],[1,6]
解释: 返回序列中的前 3 对数：
[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]

解题思路:

  1. 根据题意找最小的k对数字,建立大小为k的大堆
  2. 如果堆没放满,直接放入堆中.
  3. 如果堆放满了,每次需要和堆顶比较,如果小于堆顶,需要交换.
  4. 遍历时注意,如果数组过大,遍历会超时,所以遍历次数可以优化为 只最多遍历到 k，而且要满足小于数组长度的要求.(i<k && i<nums.length)
  5. 在遍历结束后,将数据插入list中的时候注意.可能堆没满.

代码实现:

  1. class Solution {
  2.     public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
  3.         PriorityQueue<List<Integer>> MaxHeap = new PriorityQueue<>(k, new Comparator<List<Integer>>() {
  4.             @Override
  5.             public int compare(List<Integer> o1, List<Integer> o2) {
  6.                 return (o2.get(0) + o2.get(1)) - (o1.get(0) + o1.get(1));
  7.             }
  8.         });
  9.         // 只最多遍历到 k，而且要满足小于数组长度的要求
  10.         for (int i = 0; i < nums1.length && i < k; i++) {
  11.             for (int j = 0; j < nums2.length && j < k; j++) {
  12.             	// 堆没满 首先放入堆中
  13.                 if (MaxHeap.size() < k){
  14.                     List<Integer> list1 = new ArrayList<>();
  15.                     list1.add(nums1[i]);
  16.                     list1.add(nums2[j]);
  17.                     MaxHeap.offer(list1);
  18.                 }else {
  19.                     List<Integer> top = MaxHeap.peek();
  20.                     int topValue = top.get(0) + top.get(1);
  21. 					//堆满了后要进行比较,大于堆顶的值要出队然后把大于的数据入队
  22.                     if(topValue > nums1[i] + nums2[j]){
  23.                         MaxHeap.poll();
  24.                         List<Integer> list1 = new ArrayList<>();
  25.                         list1.add(nums1[i]);
  26.                         list1.add(nums2[j]);
  27.                         MaxHeap.offer(list1);
  28.                     }
  29.                 }
  30.             
  31.             }
  32.         }
  33.         //将数据放入ret中要注意 可能堆没放满
  34.         List<List<Integer>> ret = new ArrayList<>();
  35.         for (int i = 0; i < k && !MaxHeap.isEmpty(); i++) {
  36.             ret.add(MaxHeap.poll());
  37.         }
  38.         return ret;
  39.     }
  40. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/wwzzzzzzzzzzzzz/article/details/122195666

内容来源于网络，如有侵权，请联系作者删除！

Java数据结构leetcode堆排序树堆

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com