堆的动态操作（插入、删除、调整）

最新推荐文章于 2023-04-27 10:02:06 发布
最新推荐文章于 2023-04-27 10:02:06 发布
阅读量5.6k 收藏 5
点赞数
分类专栏： 经典算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxhlovehmm/article/details/44775469
版权
 堆有最大堆和最小堆之分，最大堆就是每个节点的值都>=其左右孩子（如果有的话）值的完全二叉树。最小堆便是每个节点的值都<=其左右孩子值的完全二叉树。 

  设有n个元素的序列{k1,k2,...,kn},当且仅当满足下列关系时,称之为堆。 
 

堆的三种基本操作(以下以最大堆为例)： 
⑴最大堆的插入   

    由于需要维持完全二叉树的形态，需要先将要插入的结点x放在最底层的最右边，插入后满 足完全二叉树的特点； 
  然后把x依次向上调整到合适位置满足堆的性质,例如下图中插入80,先将80放在最后,然后两次上浮到合适位置. 
  时间：O(logn)。  “结点上浮” 
 

程序实现: 
 
<span style="font-size:18px;"> //向最大堆中插入元素, heap:存放堆元素的数组
    public static void insert(List<Integer> heap, int value) { 
       //在数组的尾部添加
        if(heap.size()==0)
          heap.add(0);//数组下标为0的位置不放元素
        heap.add(value); 
        //开始上升操作 
       // heapUp2(heap, heap.size() - 1); 
        heapUp(heap, heap.size() - 1); 
 
    } 
 
    //上升，让插入的数和父节点的数值比较，当大于父节点的时候就和父节点的值相交换 
    public static void heapUp(List<Integer> heap, int index) { 
 
        //注意由于数值是从下标为1开始，当index = 1的时候，已经是根节点了 
        if (index > 1) { 
            //求出父亲的节点 
            int parent = index / 2; 
 
            //获取相应位置的数值 
            int parentValue = (Integer) heap.get(parent); 
            int indexValue = (Integer) heap.get(index); 
            //如果父亲节点比index的数值小，就交换二者的数值 
            if (parentValue < indexValue) { 
                //交换数值 
                swap(heap, parent, index); 
                //递归调用 
                heapUp(heap, parent); 
            } 
 
        } 
    } 
</span>


⑵删除 
   操作原理是：当删除节点的数值时，原来的位置就会出现一个孔,填充这个孔的方法就是， 
把最后的叶子的值赋给该孔并下调到合适位置，最后把该叶子删除。 
  
如图中要删除72,先用堆中最后一个元素来35替换72,再将35下沉到合适位置,最后将叶子节点删除。 
　　 “结点下沉” 

 

 
<span style="font-size:18px;">程序:
 /**
     * 删除堆中位置是index处的节点
     * 操作原理是：当删除节点的数值时，原来的位置就会出现一个孔
     * 填充这个孔的方法就是，把最后的叶子的值赋给该孔，最后把该叶子删除
     * @param heap 
     */ 
    public static void delete(List<Integer> heap,int index) { 
        //把最后的一个叶子的数值赋值给index位置 
        heap.set(index, heap.get(heap.size() - 1)); 
        //下沉操作 
        //heapDown2(heap, index); 
        heapDown(heap, index); 
        //把最后一个位置的数字删除 
        heap.remove(heap.size() - 1); 
    } 
    /**
     * 递归实现
     * 删除堆中一个数据的时候，根据堆的性质，应该把相应的位置下移，才能保持住堆性质不变
     * @param heap 保持堆元素的数组
     * @param index 被删除的那个节点的位置
     */ 
    public static void heapDown(List<Integer> heap, int index) { 
        //因为第一个位置存储的是空值，不在考虑之内 
        int n = heap.size() - 2; 
 
        //记录最大的那个儿子节点的位置 
        int child = -1; 
 
        //2*index>n说明该节点没有左右儿子节点了，那么就返回 
        if (2 * index > n) { 
            return; 
        } //如果左右儿子都存在 
        else if (2 * index < n) { 
 
            //定义左儿子节点 
            child = 2 * index; 
            //如果左儿子小于右儿子的数值，取右儿子的下标 
            if ((Integer) heap.get(child) < (Integer) heap.get(child + 1)) { 
                child++; 
            } 
 
        }//如果只有一个儿子（左儿子节点） 
        else if (2 * index == n) { 
            child = 2 * index; 
        } 
 
        if ((Integer) heap.get(child) > (Integer) heap.get(index)) { 
            //交换堆中的child，和index位置的值 
            swap(heap, child, index); 
 
            //完成交换后递归调用，继续下降 
            heapDown(heap, child); 
        } 
    } 
 </span>


⑶初始化 
方法1：插入法： 
  从空堆开始，依次插入每一个结点，直到所有的结点全部插入到堆为止。 
  时间：O(n*log(n)) 
  方法2：调整法： 
    序列对应一个完全二叉树；从最后一个分支结点（n div 2）开始，到根（1）为止，依次对每个分支结点进行调整（下沉），
以便形成以每个分支结点为根的堆，当最后对树根结点进行调整后，整个树就变成了一个堆。 
  时间：O(n) 
对如图的序列,要使其成为堆,我们从最后一个分支结点(10/2),其值为72开始,依次对每个分支节点53,18,36 45进行调整(下沉). 
 
 
 

 
<span style="font-size:18px;">程序:
     /*根据树的性质建堆，树节点前一半一定是分支节点，即有孩子的，所以我们从这里开始调整出初始堆*/  
     public static void adjust(List<Integer> heap){
        for (int i = heap.size() / 2; i > 0; i--)  
            adjust(heap,i, heap.size()-1);  
          
        System.out.println("=================================================");
        System.out.println("调整后的初始堆：");
          print(heap);
      }
    /** 
     * 调整堆，使其满足堆得定义 
     * @param i 
     * @param n 
     */  
    public static void adjust(List<Integer> heap,int i, int n) {  
       
        int child;  
        for (; i <= n / 2; ) {  
            child = i * 2;  
            if(child+1<=n&&heap.get(child)<heap.get(child+1))  
                child+=1;/*使child指向值较大的孩子*/  
            if(heap.get(i)< heap.get(child)){  
                swap(heap,i, child);  
                /*交换后，以child为根的子树不一定满足堆定义，所以从child处开始调整*/  
                i = child;  
               
            }  else break;
        }  
    }  
</span>


(4)最大堆排序  

 
<span style="font-size:18px;"> //对一个最大堆heap排序
    public static void heapSort(List<Integer> heap) {  
       
        for (int i = heap.size()-1; i > 0; i--) {  
         /*把根节点跟最后一个元素交换位置，调整剩下的n-1个节点，即可排好序*/  
            swap(heap,1, i);  
            adjust(heap,1, i - 1);  
        }  
    }  
</span>


(5)完整的代码 
 
<span style="font-size:18px;">import java.util.*; 
 
/**
 *实现的最大堆的插入和删除操作
 * @author Arthur
 */ 
public class Heap { 
     /**
     * 删除堆中位置是index处的值
     * 操作原理是：当删除节点的数值时，原来的位置就会出现一个孔
     * 填充这个孔的方法就是，把最后的叶子的值赋给该孔，最后把该叶子删除
     * @param heap 一个最大堆
     */ 
    public static void delete(List<Integer> heap,int index) { 
        //把最后的一个叶子的数值赋值给index位置 
        heap.set(index, heap.get(heap.size() - 1)); 
        //下沉操作 
        //heapDown2(heap, index); 
        heapDown(heap, index); //节点下沉
        //把最后一个位置的数字删除 
        heap.remove(heap.size() - 1); 
    } 
 
 
    /** 
     * 节点下沉递归实现
     * 删除一个堆中一个数据的时候，根据堆的性质，应该把相应的位置下移，才能保持住堆性质不变
     * @param heap 保持最大堆元素的数组
     * @param index 被删除的那个节点的位置
     */ 
    public static void heapDown(List<Integer> heap, int index) { 
        //因为第一个位置存储的是空值，不在考虑之内 
        int n = heap.size() - 2; 
 
        //记录最大的那个儿子节点的位置 
        int child = -1; 
 
        //2*index>n说明该节点没有左右儿子节点了，那么就返回 
        if (2 * index > n) { 
            return; 
        } //如果左右儿子都存在 
        else if (2 * index < n) { 
 
            //定义左儿子节点 
            child = 2 * index; 
            //如果左儿子小于右儿子的数值，取右儿子的下标 
            if ((Integer) heap.get(child) < (Integer) heap.get(child + 1)) { 
                child++; 
            } 
 
        }//如果只有一个儿子（左儿子节点） 
        else if (2 * index == n) { 
            child = 2 * index; 
        } 
 
        if ((Integer) heap.get(child) > (Integer) heap.get(index)) { 
            //交换堆中的child，和index位置的值 
            swap(heap, child, index); 
 
            //完成交换后递归调用，继续下降 
            heapDown(heap, child); 
        } 
    } 
 
    //非递归实现 
    public static void heapDown2(List<Integer> heap, int index) { 
        int child = 0;//存储左儿子的位置 
 
        int temp = (Integer) heap.get(index); 
        int n = heap.size() - 2; 
        //如果有儿子的话 
        for (; 2 * index <= n; index = child) { 
            //获取左儿子的位置 
            child = 2 * index; 
            //如果只有左儿子 
            if (child == n) { 
                child = 2 * index; 
            } //如果右儿子比左儿子的数值大 
            else if ((Integer) heap.get(child) < (Integer) heap.get(child + 1)) { 
                child++; 
            } 
 
            //如果数值最大的儿子比temp的值大 
            if ((Integer) heap.get(child) >temp) { 
                //交换堆中的child，和index位置的值 
                swap(heap, child, index); 
            } else { 
                break; 
            } 
        } 
    } 
 
    
     //打印链表 
    public static void print(List<Integer> list) { 
        for (int i = 1; i < list.size(); i++) { 
            System.out.print(list.get(i) + " "); 
        } 
        System.out.println();
    } 
 
    //把堆中的a,b位置的值互换 
    public static void swap(List<Integer> heap, int a, int b) { 
        //临时存储child位置的值 
        int temp = (Integer) heap.get(a); 
 
        //把index的值赋给child的位置 
        heap.set(a, heap.get(b)); 
 
        //把原来的child位置的数值赋值给index位置 
        heap.set(b, temp); 
    } 
 
    //向最大堆中插入元素 
    public static void insert(List<Integer> heap, int value) { 
           //在数组的尾部添加要插入的元素
        if(heap.size()==0)
          heap.add(0);//数组下标为0的位置不放元素
        heap.add(value); 
        //开始上升操作 
       // heapUp2(heap, heap.size() - 1); 
        heapUp(heap, heap.size() - 1); 
 
    } 
 
    //节点上浮，让插入的数和父节点的数值比较，当大于父节点的时候就和节点的值相交换 
    public static void heapUp(List<Integer> heap, int index) { 
 
        //注意由于数值是从小标为一开始，当index = 1的时候，已经是根节点了 
        if (index > 1) { 
            //保存父亲的节点 
            int parent = index / 2; 
 
            //获取相应位置的数值 
            int parentValue = (Integer) heap.get(parent); 
            int indexValue = (Integer) heap.get(index); 
            //如果父亲节点比index的数值小，就交换二者的数值 
            if (parentValue < indexValue) { 
                //交换数值 
                swap(heap, parent, index); 
                //递归调用 
                heapUp(heap, parent); 
            } 
 
        } 
    } 
 
    //非递归实现 
    public static void heapUp2(List<Integer> heap, int index) { 
        int parent = 0; 
        for (; index > 1; index /= 2) { 
            //获取index的父节点的下标 
            parent = index / 2; 
 
            //获得父节点的值 
            int parentValue = (Integer) heap.get(parent); 
            //获得index位置的值 
            int indexValue = (Integer) heap.get(index); 
             
            //如果小于就交换 
            if (parentValue < indexValue) { 
                swap(heap, parent, index); 
            } 
        } 
    } 
     /*根据树的性质建堆，树节点前一半一定是分支节点，即有孩子的，所以我们从这里开始调整出初始堆*/  
     public static void adjust(List<Integer> heap){
        for (int i = heap.size() / 2; i > 0; i--)  
            adjust(heap,i, heap.size()-1);  
          
        System.out.println("=================================================");
        System.out.println("调整后的初始堆：");
          print(heap);
      }
    /** 
     * 调整堆，使其满足堆得定义 
     * @param i 
     * @param n 
     */  
    public static void adjust(List<Integer> heap,int i, int n) {  
       
        int child;  
        for (; i <= n / 2; ) {  
            child = i * 2;  
            if(child+1<=n&&heap.get(child)<heap.get(child+1))  
                child+=1;/*使child指向值较大的孩子*/  
            if(heap.get(i)< heap.get(child)){  
                swap(heap,i, child);  
                /*交换后，以child为根的子树不一定满足堆定义，所以从child处开始调整*/  
                i = child;  
               
            }  else break;
        }  
    }  
  
   //对一个最大堆heap排序
    public static void heapSort(List<Integer> heap) {  
       
        for (int i = heap.size()-1; i > 0; i--) {  
        /*把根节点跟最后一个元素交换位置，调整剩下的n-1个节点，即可排好序*/  
            swap(heap,1, i);  
            adjust(heap,1, i - 1);  
        }  
    }  
   public static void main(String args[]) { 
        List<Integer> array = new ArrayList<Integer>(Arrays.asList(null, 
1, 2, 5, 10, 3, 7, 11, 15, 17, 20, 9, 15, 8, 16));
        adjust(array);//调整使array成为最大堆
       
        delete(array,8);//堆中删除下标是8的元素
        System.out.println("删除后");
        print(array);
        insert(array, 99);//堆中插入
        print(array); 
        heapSort(array);//排序
        System.out.println("将堆排序后:");
        print(array);
        System.out.println("-------------------------");
        List<Integer> array1=new ArrayList<Integer>();
        insert(array1,0);
        insert(array1, 1);insert(array1, 2);insert(array1, 5);
        insert(array1, 10);insert(array1, 3);insert(array1, 7);
        insert(array1, 11);insert(array1, 15); insert(array1, 17);
        insert(array1, 20);insert(array1, 9);
        insert(array1, 15);insert(array1, 8);insert(array1, 16);
        print(array1);
        
        System.out.println("==============================");
        array=new ArrayList<Integer>(Arrays.asList(null,45,36,18,53,72,30,48,93,15,35));
        adjust(array);
          insert(array, 80);//堆中插入
          print(array);
         delete(array,2);//堆中删除80的元素
         print(array);
         delete(array,2);//堆中删除72的元素
         print(array);
              
    } 
} 
</span>


程序运行: 
D:\java>java   Heap 
================================================= 
调整后的初始堆： 
20 17 16 15 9 15 11 1 10 3 2 7 8 5 
删除后 
20 17 16 15 9 15 11 5 10 3 2 7 8 
99 17 20 15 9 15 16 5 10 3 2 7 8 11 
将堆排序后: 
2 3 5 7 8 9 10 11 15 15 16 17 20 99 
------------------------- 
20 17 16 10 15 9 15 0 5 2 11 1 7 3 8 
============================== 
================================================= 
调整后的初始堆： 
93 72 48 53 45 30 18 36 15 35 
93 80 48 53 72 30 18 36 15 35 45 
93 72 48 53 45 30 18 36 15 35 
93 53 48 36 45 30 18 35 15 

阳光的颜色
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python实现堆和索引堆的代码示例
12-25
堆是一棵完全二叉树。...当每次插入或者删除的时候，为了保证堆的结构特征不被破坏，需要进行调整。调整分为两种，一种是从上往下，将小的数下沉。一种是从下往上，令大的数上浮。 具体实现如下： 首先编写几个魔术方
堆的创建插入删除排序（含堆的向上，向下调整）
m1059247324的博客
03-04 330
堆 堆再逻辑上可以看成一颗完全二叉树。
最大堆-插入/删除/排序-图解
12-07 1513
原文地址：http://www.java3z.com/cwbwebhome/article/article1/1362.html?id=4745  堆有最大堆和最小堆之分，最大堆就是每个节点的值都>=其左右孩子（如果有的话）值的完全二叉树。最小堆便是每个节点的值都   设有n个元素的序列{k1,k2,...,kn},当且仅当满足下列关系时,称之为堆。    堆的三种基本操作(以下以
堆排序，删除堆中任意单一元素
COALX的博客
03-13 1825
package headSort; import java.util.Arrays; public class MyHeap { public int[] arr; public int size; public MyHeap(int[] arr) { this.arr = arr; this.size=arr.length; } /** * 删除下标为i的元素 * 思路->将最大元素删除->让删除元素的
大顶堆调整
qq_25565903的博客
12-02 877
已知关键字序列（k1,k2,...,kn-1）是大顶堆，试编写算法实现将（k1,k2,...,kn-1,kn）调整为大顶堆，假设n最大值为20。
数据结构堆排序中堆的建立、调整、插入、删除等操作的详解（题目讲解 简单易懂）
showswoller的博客
04-27 2594
数据结构堆排序中堆的建立、调整、插入、删除等操作的详解（题目讲解 简单易懂）
优先队列-双端堆
05-11
作业题目：编写一个优先队列，完成 查找，删除，插入 操作。且每个操作的时间复杂度要在（logn）内。 其实很早前就拿到这个题目了，只是一直没定下用那种数据结构做，在图书馆借了本数据结构的书，认真的看了，小...
二叉堆：最大堆
07-08
使用c++实现最大堆。提供常见操作，如插入、删除、堆化数组、堆排序、上下调整、向下调整。
数据结构之堆1
08-03
1、方法一，直接删除堆顶，会将树分两个堆，不好合并起来 2、方法二，插入操作的逆操作，将堆顶元素向下调整到最后一个叶子节点，然后就可以直接 3、方法三，向下调整
Javascript-Data-Structures:二叉堆、展开树、间隔树等。 在 JavaScript 中
06-29
展开树允许搜索、插入、删除、deletemin、deletemax、拆分、连接和许多其他操作，所有这些操作都具有摊销对数性能。 由于树适应请求序列，因此它们在实际访问模式上的性能通常更好。 在许多文本和论文中描述了张开...
C++实现一个堆（更改堆中数据后，可以重新调整）
hellogoxiaowu的博客
04-12 318
库中带的堆结构，无法实现更改后再调整，此时需要自己实现 思路：使用一个hash表，保存数据与其对应的下标位置，需要更改时通过下标调整堆结构 #define _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS 1 #include<iostream> #include<vector> #include<hash_map> #include<string> using namespace std; //堆中存储数据使用自定义类
GoLang之标准库container/heap包
weixin_52690231的博客
04-18 1036
GoLang之标准库container/heap包
链表详解（动画，源码，详解）
Only Sun
07-22 964
用最简单的逻辑，最少的代码实现链表的基本功能 本文使用图文结合的方式用50行代码，写出了链表的头插法，尾差法，修改，删除，返回链表长度，判断链表是否为空一系列功能。
数据结构之堆
热门推荐
morris
07-01 1万+
思考 假如需要设计一种数据结构，用来存放整数，要求提供3个接口： 添加元素 获取最大值 删除最大值 如果使用动态数组、双向链表和二叉树实现这个数据结构对应的时间复杂度如下表所示： 添加元素 获取最大值 删除最大值 说明 动态数组\双向链表 O(1) O(n) O(n) 有序动态数组\双向链表 O(n) O(1) O(1) 全排序有点浪费 平衡二叉搜索树 O(logn) O(logn) O(logn) 杀鸡焉用牛刀 有没有更优的数据结构？使用堆，可以使得获取最大值的时间复杂
堆
qq_64585761的博客
02-06 693
二叉堆与自定义优先队列实现删除任意元素
qq_46118239的博客
08-31 1947
二叉堆与自定义优先队列实现删除任意元素
【algorithm】算法学习----堆
明璐花生牛奶的博客
09-03 779
堆涉及到的五个问题：插入一个数求集合中的最小值删除最小值插入任意一个元素删除任意一个元素对于堆，这里需要使用树来存储。这里以小根堆来举例：什么是小根堆，小根堆就是父节点比其两个孩子节点都要小。由此我们可以想到根节点就是当前堆的最小值。堆其实是一个完全二叉树。什么是完全二叉树？就是除了最后一层，其余层都是满度（都是2），并且最后一层的是从左到右排列但是如果使用节点point+value比较麻烦并且不适用于算法题里面。
堆（堆排序）
m0_62593364的博客
02-09 585
堆的基本操作（以小根堆为例）： 1.插入一个数：在堆的最后位置插入一个x，并不断往上移 heap[ ++ size] = x; up[size]; 2.求集合当中的最小值 heap[1]; 3.删除最小值：用堆的最后一个元素覆盖堆顶元素，删除最后一个元素，再down heap[1] = heap[size]; size--; down(1); 4.删除任意一个元素 heap[k] = heap[size]; size--; down(k); up(k); 5.修改任意一个元素
11、堆的删除操作(中篇)
沿海奔跑的少年
03-30 2413
一、堆得删除操作的简单思路 1、首先我们判断堆是不是为空，然后获取我们的堆顶元素，和我们的最后一个元素，进行交换。 2、我们删除我们的最后一个元素，删除的元素，就是我们的堆顶元素，如果是最大堆，是最大元素，如果最小堆，就是最下元素。 3、我们对第一个元素，进行shift'Down操作。因为堆得定义，比如最大堆，就是堆中的任意节点都会下于等于它的父亲节点。我们第一个元素，必须进行和它的孩子节点...
用c语言写出堆的建立和插入、删除操作
最新发布
06-08
以下是用 C 语言实现堆的建立、插入和删除操作的示例代码： ``` #include #include #define MAX_HEAP_SIZE 100 // 堆结构体 typedef struct { int size; // 堆的大小 int *elements; // 存储堆元素的数组指针...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值