精华内容
下载资源
问答
  • java大根堆
    2020-06-11 17:17:32
    PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(k, new Comparator<Integer>() {
        public int compare(Integer o1, Integer o2) {
            return o2.compareTo(o1);
        }
    });
    更多相关内容
  • 主要介绍了Java实现堆排序(大根堆)的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java大根堆和小根堆

    2022-02-21 19:20:18
    java使用优先队列实现大顶堆和小顶堆,默认是小根堆,当然...大根堆创建 PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k,(a,b) -> b-a); 其中构造器中的k表示创建堆的大小,之后用Lambda表

    java使用优先队列实现大顶堆和小顶堆,默认是小根堆,当然记不住默认也没有关系

    小根堆创建

    PriorityQueue<Integer> minHeap = new PriorityQueue<>(k,(a,b) -> a-b);

    大根堆创建

    PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k,(a,b) -> b-a);

    其中构造器中的k表示创建堆的大小,之后用Lambda表达式快速实现自定义排序

    展开全文
  • //构建大根堆:将array看成完全二叉树的顺序存储结构 private int[] buildMaxHeap(int[] array){ //从最后一个节点array.length-1的父节点(array.length-1-1)/2开始,直到根节点0,反复调整堆 for(int i=(array....

    //构建大根堆:将array看成完全二叉树的顺序存储结构

    private int[] buildMaxHeap(int[] array){

    //从最后一个节点array.length-1的父节点(array.length-1-1)/2开始,直到根节点0,反复调整堆

    for(int i=(array.length-2)/2;i>=0;i–){

    adjustDownToUp(array, i,array.length);

    }

    return array;

    }

    //将元素array[k]自下往上逐步调整树形结构

    private void adjustDownToUp(int[] array,int k,int length){

    int temp = array[k];

    for(int i=2k+1; i<length-1; i=2i+1){ //i为初始化为节点k的左孩子,沿节点较大的子节点向下调整

    if(i<length && array[i]<array[i+1]){ //取节点较大的子节点的下标

    i++; //如果节点的右孩子>左孩子,则取右孩子节点的下标

    }

    if(temp>=array[i]){ //根节点 >=左右子女中关键字较大者,调整结束

    break;

    }else{ //根节点 <左右子女中关键字较大者

    array[k] = array[i]; //将左右子结点中较大值array[i]调整到双亲节点上

    k = i; //【关键】修改k值,以便继续向下调整

    }

    }

    array[k] = temp; //被调整的结点的值放人最终位置

    }

    堆排序:

    //堆排序

    public int[] heapSort(int[] array){

    array = buildMaxHeap(array); //初始建堆,array[0]为第一趟值最大的元素

    for(int i=array.length-1;i>1;i–){

    int temp = array[0]; //将堆顶元素和堆低元素交换,即得到当前最大元素正确的排序位置

    array[0] = array[i];

    array[i] = temp;

    adjustDownToUp(a

    《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

    【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

    rray, 0,i); //整理,将剩余的元素整理成堆

    }

    return array;

    }

    删除堆顶元素(即序列中的最大值):先将堆的最后一个元素与堆顶元素交换,由于此时堆的性质被破坏,需对此时的根节点进行向下调整操作。

    //删除堆顶元素操作

    public int[] deleteMax(int[] array){

    //将堆的最后一个元素与堆顶元素交换,堆底元素值设为-99999

    array[0] = array[array.length-1];

    array[array.length-1] = -99999;

    //对此时的根节点进行向下调整

    adjustDownToUp(array, 0, array.length);

    return array;

    }

    对堆的插入操作:先将新节点放在堆的末端,再对这个新节点执行向上调整操作。

    假设数组的最后一个元素array[array.length-1]为空,新插入的结点初始时放置在此处。

    //插入操作:向大根堆array中插入数据data

    public int[] insertData(int[] array, int data){

    array[array.length-1] = data; //将新节点放在堆的末端

    int k = array.length-1; //需要调整的节点

    int parent = (k-1)/2; //双亲节点

    while(parent >=0 && data>array[parent]){

    array[k] = array[parent]; //双亲节点下调

    k = parent;

    if(parent != 0){

    parent = (parent-1)/2; //继续向上比较

    }else{ //根节点已调整完毕,跳出循环

    break;

    }

    }

    array[k] = data; //将插入的结点放到正确的位置

    return array;

    }

    测试:

    public void toString(int[] array){

    for(int i:array){

    System.out.print(i+" ");

    }

    }

    public static void main(String args[]){

    HeapSort hs = new HeapSort();

    展开全文
  • 大根堆Java实现

    千次阅读 2022-03-26 11:41:12
    // 大根堆建立 // 核心方法:heapInsert和heapify /** * 插入元素时候:堆上升 * 删除元素时候:堆下沉 * 堆排序和删除相关 */ public class BigHeap{ // 大根堆 private int[] heap; // 堆结构 private int ...
    具体创建原理;自行百度,这里仅仅提供实现的思路
    import java.util.Arrays;
    //usage:
    //插入:add
    //删除;remove
    //查找;contains
    //排序:heapSort
    
    // 大根堆建立
    // 核心方法:heapInsert和heapify
    
    /**
     * 插入元素时候:堆上升
     * 删除元素时候:堆下沉
     * 堆排序和删除相关
     */
    public class BigHeap{
        // 大根堆
        private int[] heap;  // 堆结构
        private int size;   // 堆中元素数量
        private int limit;  // 当前堆容量
    
        public BigHeap(int limit){
            heap = new int[limit];
            this.limit = limit;
            this.size = 0;
        }
        public BigHeap(){
            heap = new int[10];
            this.limit = 10;
            this.size = 0;
        }
        // 插入
        // 真正对外暴露的插入方法   === 可以实现扩容
        public void add(int value){
            // 空间不够数组扩容  --复制 + 扩容0.75倍
            if (this.size + 1 > this.limit){
                // copyOf:将数组复制到heap中,并指定新长度,返回新数组
                heap = Arrays.copyOf(heap,(int)(this.limit<<1));
                this.limit = heap.length;
            }
            // 插入元素
            heap[this.size] = value;
            heapInsert(heap,this.size);
            this.size++;
        }
        // 每次插入一个插入元素
        // index是当前元素位置  index 范围:0~arr.length-1
        private void heapInsert(int[] arr,int index){
            while (arr[index] > arr[(index - 1) / 2]){
                swap(arr,index,(index - 1)/2);
                // 当前元素上移
                index = (index - 1) / 2;
            }
        }
    
        // 删除
        // 暴露在外的接口   -- 堆顶 index = 0,非堆顶index != 0
        public Integer remove(){
            if (this.size == 1){
                this.size--;
                return heap[this.size];
            }
            else if (!isEmpty()){
                swap(heap,0,this.size-1);
                this.size--;
                heapify(heap,0);
                return heap[this.size];
            }
            return null;
        }
        // 删除堆中一个堆顶元素后进行下沉调整   -- 默认删除堆顶元素
        private void heapify(int[] arr,int index){
            // 要考虑好左右孩子存在的情况,画一下就出来了
            // 3种情况
            while (index < this.size){
                int left = (index<<1 | 1);
                int right = ((index<<1) + 2);
                // 左右孩子最大元素下标,没有左右孩子返回-1
                int maxIndex = right < this.size?(arr[left] <= arr[right]?right:left):(left < this.size?left:-1);
                // 判断是否继续下沉  maxIndex == -1说明index没有左右孩子了,调整结束
                if (maxIndex == -1 || arr[index] > arr[maxIndex])
                    break;
                swap(arr,index,maxIndex);
                // 坐标下沉
                index = maxIndex;
            }
        }
        // 删除堆中指定元素  -- 以待删除元素为根的树调整结构
        public boolean remove(int value){
            // indexOf:求元素下标,-1:没有
            if (isEmpty() || indexOf(value) == -1)
                return false;
            else if (heap[this.size-1] == value){
                this.size--;
            }
            // 最后一个一定不是value,所以可以这末写
            for (int i = 0;i < this.size;i++){
                if (heap[i] == value){
                    // 调整结构
                    swap(heap,i,this.size-1);
                    this.size--;
                    heapify(heap,i);
                    break;
                }
            }
            return true;
        }
    
        // 查找
        // 查看堆顶元素  -- 只看不删
        public int peek(){
            return heap[0];
        }
        //查看堆顶元素   -- 看完删
        public int poll(){
            return remove();
        }
        // 查找元素
        public boolean contains(int value){
            // 非空情况下查找
            if (!isEmpty()){
                for (int i = 0; i < this.size; i++) {
                    if (heap[i] == value)
                        return true;
                }
            }
            return false;
        }
    
        // 工具
        // 求指定元素的下标
        public int indexOf(int value){
            if (!isEmpty()){
                for (int i = 0; i < this.size; i++) {
                    if (heap[i] == value)
                        return i;
                }
            }
            return -1;
        }
        // 交换两个元素的位置
        private void swap(int[] arr,int i,int j){
            arr[i] = arr[i] ^ arr[j];
            arr[j] = arr[i] ^ arr[j];
            arr[i] = arr[i] ^ arr[j];
        }
        // 判断堆是否为空
        public boolean isEmpty(){
            return this.size == 0;
        }
        // 打印数组
        public void print(){
            if (this.size == 0){
                System.out.println("[]");
                return;
            }
            String str = "[";
            if (size == 1){
                str += heap[0] + "]";
                System.out.println(str);
                return;
            }
            for (int i = 0; i < size-1; i++) {
                str += heap[i]+",";
            }
            str += heap[size-1]+"]";
            System.out.println(str);
        }
        // 推排序  --- 每次将最大值删除放到新数组里面   -- 知道原理读者可以自己利用已有方法写
        public static void heapSort(int[] arr){
            BigHeap b = new BigHeap(1);
            if (arr == null || arr.length == 0)
                return;
            // 插入元素
            for (int i = 0; i < arr.length; i++) {
                b.add(arr[i]);
            }
            // 复制回arr中
            int length = b.size;
            for (int i = 0; i < length; i++) {
                arr[i] = b.remove();
            }
        }
    
        // test
        public static void main(String[] args) {
            BigHeap b = new BigHeap(1);
            int[] arr = new int[]{3,1,2,5,0,89,7};
            b.add(1);
            System.out.println(b.remove());
            b.heapSort(arr);
            System.out.println(Arrays.toString(arr));
        }
    }
    
    
    展开全文
  • 初始化堆并将其调整为大根堆 初始化堆 调整堆为大根堆 大根堆的插入和删除 大根堆的插入 大根堆的删除 完整代码 堆的概念以及问题思考 堆的概念:如果有关键字集合k = {k0,k1,k2,......,k(n-1)},把...
  • Max-heap(大根堆):1.是完全二叉树2.父节点的值大于或等于子节点的值 代码: public static class MyMaxHeap { private int[] heap; private final int limit; private int heapSize; public MyMaxHeap(int ...
  • 大根堆 小根堆 Java

    2021-05-19 14:00:58
    Java 大根堆 小根堆 在Java中的堆可以使用PriorityQueue,默认是小根堆, Queue<Integer> min = new PriorityQueue<>(); 大根堆的写法: max = new PriorityQueue<>(new Comparator<Integer&...
  • Java大根堆创建和重建及堆排序

    千次阅读 2018-08-04 23:22:22
    什么是大根堆? 数据结构中堆结构【完全...堆结构在Java中十分重要,堆的创建的排序也尤为重要,因为向大根堆中插入一个数据,时间复杂度仅为O(logN) (即二叉树的深度,大根堆实为完全二叉树模型)。而大根堆的创...
  • 大根堆就是所有父结点都比它的左右孩子大。存储结构:采用数组进行存储,同完全二叉树的存储一样。数组从0开始则:2i+1为左孩子,2i+2为右孩子。数组从1开始则:2i为左孩子,2i+1为右孩子。 二、算法思想 若数组...
  • 标题:Java中优先队列,大根堆,小根堆 小根堆,得到最大的前k个, 1。在一堆元素中,先放入k个,【堆顶元素最小,内部实现的】, 2。然后放入第k+1个元素时,与堆顶元素比较, 3.若大于堆顶元素,则放入堆中,【<...
  • Java 中的大根堆和小根堆

    千次阅读 2019-09-02 22:34:15
    小根堆和大根堆 **完全二叉树:**完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时...
  • Java利用PriorityQueue类实现小根堆和大根堆(其中需要使用Comparator类) 堆:是一颗完全二叉树。通俗点说,一棵树最多只能最后一层不是满的,且不满的最后一层结点从左到右依次排列,那么这棵树就是完全二叉树。 小...
  • 如何用 PriorityQueue 实现大根堆 queueA? 这里的知识点包括: PriorityQueue 默认是小根堆,大根堆需要重写比较器。 可以在 new PriorityQueue<>() 中的参数部分加入比较器。 具体写法是:(v1, v2) -> ...
  • //构建大根堆:将array看成完全二叉树的顺序存储结构 private int[] buildMaxHeap(int[] array){ //从最后一个节点array.length-1的父节点(array.length-1-1)/2开始,直到根节点0,反复调整堆 for(int i=(array....
  • 文章目录四、堆、改进堆、对排序及其应用1、堆和完全二叉树2、用数组实现大根堆3、堆排序4、加强堆(小根堆) 四、堆、改进堆、对排序及其应用 1、堆和完全二叉树 堆(heap)是计算机科学中一类特殊的数据结构的统称...
  • Java实现小根堆和大根堆(PriorityQueue)

    千次阅读 2020-06-28 08:23:01
    Java里面的PriorityQueue底层默认使用的,所以我们使用PriorityQueue就能实现的功能。 1、小根实现 package test; import java.util.Comparator; import java.util.PriorityQueue; /* add 增加一个元索 ...
  • 2.大根堆如果根是儿童的存在留下的根值多名离开自己的孩子值。子女则根节点的值大于右子女的值。3.结论(1)堆是一棵全然二叉树(假设公有h层,那么1~h-1层均满,在h层连续缺失若干个右叶子)。(2)小根堆的根节点的值是...
  • java中的PriorityQueue默认情况下是小顶堆 Queue<Integer>A=new PriorityQueue<>() 下面是大顶堆的写法 A=new PriorityQueue<>(new Comparator<Integer>() { @Override public ...
  • Java实现堆排序(大根堆

    千次阅读 2017-04-04 12:01:24
    排序是一种树形选择排序方法。设长度为n的一组数用来排序,首先用数组存储这组数。排序的特点是:在排序的过程中,array[0,…,n-1]可看成是一颗完全二叉树的顺序存储结构,利用完全二叉树中双亲节点和孩子...
  • (二叉)数据结构是一种数组对象,如图所示(下标从0开始),它完全可以被视为一棵完全二叉树。 接下来要出现的几个词语,这里介绍一下: length[A]: 数组A中元素的个数 heap-size[A]: 存放在数组A中的元素的...
  • PriorityQueue是Java中内置的数据结构,表示。 PriorityQueue类继承于抽象类AbstractQueue,而AbstractQueue类实现了Queue接口。 创建小顶堆 public class Test { public static void main(String[] args) { //...
  • 2、最开始一直往里面加数据,直到k的大小 3、然后每次看一下大根堆里面的第一个数,如果数组的数比它小,就把它换进去。(就是先删后加),这样每次都能保证最小的只有k个。 4、最后需要把堆里的数据搬到list上。 ...
  • 大根堆和小根堆可以容易获取数据结构内最大值、最小值的数据结构,在很多地方上都有应用。 理解: 大根堆/小根堆,是一棵完全二叉树。特点是节点都大于/小于它的孩子节点。 每次弹出元素的时候,总是从树的最顶端弹...
  • 下面对Java中的栈、队列、小根堆和大根堆做一个简单的介绍。 它们都有共用的collections接口中定义的常见函数isEmpty(),可以判断该数据结构中是否还有元素。 栈 Java中有Stack类,但现在已经过时了,不推荐使用。一...
  • 大根堆Java实现:

    2021-03-04 08:11:42
    使用树组表示的完全二叉树的下表有如下规律:01 23 4 5 67 8 ...其中针对于k节点,其父节点是 (k-1)/2 (注意: 0节点除外)对于k节点,其两个儿子...向下调整算法: 用于从数组创建一个大根堆,或者删除元素的时候...
  • JAVA实现一个大根堆

    2020-05-21 22:05:20
    } } public void push(int val) { //0、是否是满的--》扩容 if(isFull()) { this.elem= Arrays.copyOf(this.elem,this.elem.length*2); } //1、放到数组的最后一个位置 val=this.elem[this.usedSize]; //2、进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,247
精华内容 2,498
关键字:

java大根堆