实现堆的各种操作

最新推荐文章于 2020-06-15 18:41:46 发布
最新推荐文章于 2020-06-15 18:41:46 发布
阅读量852 收藏
点赞数
分类专栏： C 数据结构--堆 文章标签： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuxinliulei/article/details/12255297
版权 
#include<stdio.h>
//实现堆的各种操作 加入数据 删除数据  调整堆 获取数据
//为方便编程 数组从1开始 小顶堆
int a[100];
int size = 0;
int c,b;

void swap(int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void addAdjust(int a[],int size)
{
    int id = size;
    while(id/2!=0&&a[id]<a[id/2])//向上调整直至堆顶
    {
        swap(&a[id],&a[id/2]);
        id = id/2;//id  向上前进
    }
}

void deleteAdjust(int a[])
{
    a[1] = a[size--];
    int id = 1;
    int child = id*2;
    for(;id*2<size;id = child)//保证其至少有左儿子
    {
        child = id*2;
        if(child+1<=size&&a[child]>a[child+1])//在有右儿子的前提下判断谁最小
        {
            child +=1;
        }
        if(a[id]>a[child])//若俩儿子中最小值比父节点值小  交换
        {
            swap(&a[id],&a[child]);
        }
        else
        {
            break;
        }
    }
    //id  = child  这一步很巧妙的
}
int main()
{
    char s[3];
    printf("请输入相关命令和数据：\n-a   添加数据\n-d   删除堆顶   \n-g   获取堆顶元素\n-p   打印堆\n-0   退出\n");
    while(1)
    {
        fflush(stdin);
        scanf("%s",s);
        if(s[1]=='a')
        {
            scanf("%d",&a[++size]);
            addAdjust(a,size);
                            //printf("-a\n");
        }
        else if(s[1]=='d')
        {
            deleteAdjust(a);
            printf("堆顶元素已经删除成功！");
                            //printf("-d\n");
        }
        else if(s[1]=='g')
        {
            printf("目前堆顶元素（即最小元素）为:%d\n",a[1]);
                            //printf("-g\n");
        }
        else if(s[1]=='p')
        {
            int i;
            for(i=1;i<=size;i++)
                printf("%d  ",a[i]);
            printf("\n");
                            //printf("-p\n");
        }
        else if(s[1]=='0')
        {
            break;
        }
        else
        {
            printf("命令错误\n");
            printf("请输入相关命令和数据：\n-a   添加数据\n-d   删除堆顶   \n-g   获取堆顶元素\n-p   打印堆\n-0   退出\n");
        }
    }
    printf("操作完成\n");
    return 0;
}

#include<stdio.h>
//实现堆的各种操作 加入数据 删除数据  调整堆 获取数据
//为方便编程 数组从1开始 小顶堆
int a[100];
int size = 0;
int c,b;

void swap(int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void addAdjust(int a[],int size)
{
    int id = size;
    while(id/2!=0&&a[id]<a[id/2])//向上调整直至堆顶
    {
        swap(&a[id],&a[id/2]);
        id = id/2;//id  向上前进
    }
}

int max(int a,int b)
{
   return a=a>b?a:b;
}

void heapAdjust(int *a,int i,int size)
{
    int lchild = 2*i;
    int rchild = 2*i+1;
    int max = i;
    if(lchild<=size&&a[max]>a[lchild])
    {
        max = lchild;
    }
    if(rchild<=size&&a[max]>a[rchild])
    {
        max = rchild;
    }
    if(max!=i)
    {
        swap(&a[max],&a[i]);
        heapAdjust(a,max,size);
    }
    else
    return;
}

void deleteAdjust(int a[])
{
    a[1] = a[size--];
    int id = 1;
    int child = id*2;
    for(;id*2<size;id = child)//保证其至少有左儿子
    {
        child = id*2;
        if(child+1<=size&&a[child]>a[child+1])//在有右儿子的前提下判断谁最小
        {
            child +=1;
        }
        if(a[id]>a[child])//若俩儿子中最小值比父节点值小  交换
        {
            swap(&a[id],&a[child]);
        }
        else
        {
            break;
        }
    }
    //id  = child  这一步很巧妙的
}
int main()
{
    char s[3];
    printf("请输入相关命令和数据：\n-a   添加数据\n-d   删除堆顶   \n-g   获取堆顶元素\n-p   打印堆\n-0   退出\n");
    while(1)
    {
        fflush(stdin);
        scanf("%s",s);
        if(s[1]=='a')
        {
            scanf("%d",&a[++size]);
            addAdjust(a,size);
                            //printf("-a\n");
        }
        else if(s[1]=='d')
        {
            /*deleteAdjust(a);
            printf("堆顶元素已经删除成功！");
                            //printf("-d\n");*/
            ///*
            a[1] = a[size--];
            heapAdjust(a,1,size);
            //*/
        }
        else if(s[1]=='g')
        {
            printf("目前堆顶元素（即最小元素）为:%d\n",a[1]);
                            //printf("-g\n");
        }
        else if(s[1]=='p')
        {
            int i;
            for(i=1;i<=size;i++)
                printf("%d  ",a[i]);
            printf("\n");
                            //printf("-p\n");
        }
        else if(s[1]=='0')
        {
            break;
        }
        else
        {
            printf("命令错误\n");
            printf("请输入相关命令和数据：\n-a   添加数据\n-d   删除堆顶   \n-g   获取堆顶元素\n-p   打印堆\n-0   退出\n");
        }
    }
    printf("操作完成\n");
    return 0;
}


 

 

#include<stdio.h>
//实现堆的各种操作 加入数据 删除数据  调整堆 获取数据
//为方便编程 数组从1开始 小顶堆
int a[100];
int size = 0;
int c,b;

void swap(int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void addAdjust(int a[],int size)
{
    int id = size;
    while(id/2!=0&&a[id]<a[id/2])//向上调整直至堆顶
    {
        swap(&a[id],&a[id/2]);
        id = id/2;//id  向上前进
    }
}

int max(int a,int b)
{
   return a=a>b?a:b;
}

void heapAdjust(int *a,int i,int size)
{
    int lchild = 2*i;
    int rchild = 2*i+1;
    int max = i;
    if(lchild<=size&&a[max]>a[lchild])
    {
        max = lchild;
    }
    if(rchild<=size&&a[max]>a[rchild])
    {
        max = rchild;
    }
    if(max!=i)
    {
        swap(&a[max],&a[i]);
        heapAdjust(a,max,size);
    }
    else
    return;
}

void deleteAdjust(int a[])
{
    a[1] = a[size--];
    int id = 1;
    int child = id*2;
    for(;id*2<size;id = child)//保证其至少有左儿子
    {
        child = id*2;
        if(child+1<=size&&a[child]>a[child+1])//在有右儿子的前提下判断谁最小
        {
            child +=1;
        }
        if(a[id]>a[child])//若俩儿子中最小值比父节点值小  交换
        {
            swap(&a[id],&a[child]);
        }
        else
        {
            break;
        }
    }
    //id  = child  这一步很巧妙的
}


void minDelete(int a[])
{
    int id=1;
    while(id*2<=size)
    {

        if(id*2+1<=size&&a[id*2]>a[id*2+1])
        {
            a[id] = a[id*2+1];
            id = id*2+1;
        }
        else
        {
            a[id] = a[id*2];
            id = id*2;
        }
    }
    if(id!=size)
    {
        a[id] = a[size];
        while(id>=1)
        {
            if(a[id/2]>a[id])
            {
                swap(&a[id/2],&a[id]);
                id = id/2;
            }
            else
            {
                return;
            }
        }
    }
}
int main()
{
    char s[3];
    printf("请输入相关命令和数据：\n-a   添加数据\n-d   删除堆顶   \n-g   获取堆顶元素\n-p   打印堆\n-0   退出\n");
    while(1)
    {
        fflush(stdin);
        scanf("%s",s);
        if(s[1]=='a')
        {
            scanf("%d",&a[++size]);
            addAdjust(a,size);
                            //printf("-a\n");
        }
        else if(s[1]=='d')
        {
            /*deleteAdjust(a);
            printf("堆顶元素已经删除成功！");
                            //printf("-d\n");*/
            /*
            a[1] = a[size--];
            heapAdjust(a,1,size);
            */
            minDelete(a);
            size--;

        }
        else if(s[1]=='g')
        {
            printf("目前堆顶元素（即最小元素）为:%d\n",a[1]);
                            //printf("-g\n");
        }
        else if(s[1]=='p')
        {
            int i;
            for(i=1;i<=size;i++)
                printf("%d  ",a[i]);
            printf("\n");
                            //printf("-p\n");
        }
        else if(s[1]=='0')
        {
            break;
        }
        else
        {
            printf("命令错误\n");
            printf("请输入相关命令和数据：\n-a   添加数据\n-d   删除堆顶   \n-g   获取堆顶元素\n-p   打印堆\n-0   退出\n");
        }
    }
    printf("操作完成\n");
    return 0;
}


 

本次试验提供了三个进行堆删除操作的函数  分别利用了不同的方法

前两种都是通过将a[size] 与a[1] 交换或者说覆盖然后自上而下的进行调整，一个采用for循环，一个采用递归方式。

最后一种直接将堆顶默认为空 然后通过比较子树 选择堆顶  然后向下依次延伸  最后跳出循环之后判断 空出来的位置是不是a[size]

如果不是 将a[id] = a[size]  然后再向上进行调整，当然这样的话复杂度是前两种的两倍。

注意此时size是没有减小的


无心流泪
关注
专栏目录
C语言实现堆的基本操作
weixin_44915226的博客
08-22 1861
文章目录前言基本的操作一、头文件及定义堆二、创建最大堆三、判断堆满/空四、插入操作五、删除操作完整代码 前言 本文用C语言实现了堆的基本操作，包括：创建堆、判断堆满/空、插入、删除。虽然在C++的STL中已经分装好了堆数据结构，但是在不少的场合会用到自己写的堆。   基本的操作 堆分为最大堆和最小堆，本文对最大堆进行了说明，最小堆可模仿写出。   一、头文件及定义堆 代码： #include <stdio.h> #include <stdlib.h> #de
堆的一些基本操作实现
weixin_45342551的博客
03-22 184
//关于建堆和对其的一些操作 #include <iostream> #include <algorithm> using namespace std; const int maxn=100; int heap[maxn],n=10;//将第一个结点储存在数组的一号位 //函数功能：对heap数组在low到high的范围内向下调整 void downAdjust(i...
堆及其相关操作
The Laughing Uncle的博客
10-17 238
文章目录堆向下调整堆的创建大堆小堆堆的初始化堆顶元素堆的插入堆的删除向上调整TopK 堆 堆，也叫做二叉堆。 目的：在堆中找到最值（最大值、最小值）       堆顶存放的不是最大值就是最小值 堆是已数组的形式存储的，但在逻辑上是完全二叉树 例如： int arr[] = { 53, 17, 78, 9, 45, 65, 87, 23, 31 }; 对应的堆为： 注：上述堆还未进行调整 ty...
初夏小谈：堆的基本操作（完整版）
Scissors_初夏的博客
12-14 452
堆的建堆，插入、删除、操作 堆本身就是一个完全二叉树，在这里采用数组进行存储。因为可以通过下标快速找到它的孩子。堆的最大作用就是：返回一组的数据的最值。 建堆： 在建堆的过程中,需要几个基本操作：首先先建立一个数组用来存储堆数据，其次就要开始对这组数据进行建堆的过程，需要将数据进行比较、搬移。这里面需要进行向上调整将数据搬到合适的位置上。注意边界问题：在向上调整的过程中需要判断是否已经...
堆的基本概念及其操作
weixin_30655219的博客
04-05 146
转：https://www.cnblogs.com/JVxie/p/4859889.html 堆是利用完全二叉树的结构来维护一组数据，然后进行相关操作，一般的操作进行一次的时间复杂度在　　O(1) ~ O(logn) 之间。 若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。我们知道二...
堆的基本概念及常用操作
JohnSon
02-17 6455
堆 完全二叉树：若设二叉树的深度为nnn，除第nnn层外，其它各层 (111～n−1n−1n-1) 的结点数都达到最大个数，第nnn层所有的结点都连续集中在最左边，这就是完全二叉树 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为nnn，且结点总数是2n−12n−12^n - 1 ，则它就是满二叉树 堆(heap)又被为优先队列...
java实现堆的操作方法(建堆,插入,删除)
08-28
在Java中实现堆的操作，主要包括建堆、插入和删除三大功能。下面将详细阐述这三个操作的原理以及如何用Java代码实现它们。 ### 建堆（Heapify） 建堆的操作目的是将一个无序的数组调整成一个堆结构。建堆可以分为...
Verilog寄存器堆的实现代码
12-19
在寄存器堆的实现中，这涉及到如何协调读写操作和时钟边沿的处理。 8. **仿真和综合（Simulation and Synthesis）**: 完成寄存器堆的Verilog代码后，需要进行仿真验证其功能是否正确。然后，通过综合工具将Verilog...
串的基本操作实现-堆存储结构的实现
11-21
编写一个程序，实现求串长length_str、串连接、串比较、求子串、串插入、串删除操作。
最小堆的实现和操作
12-03
利用数组实现了最小堆的创建、插入和删除等操作
堆的概念及基本操作实现
多反思，多回顾，要坚持。
03-25 1万+
1.堆的基本概念： 严格来讲，堆有不同的种类，但是我们在算法学习中，主要用的还是二叉堆，而二叉堆有最大堆和最小堆之分。 最大（最小）堆是一棵每一个节点的键值都不小于（大于）其孩子（如果存在）的键值的树。大顶堆是一棵完全二叉树，同时也是一棵最大树。小顶堆是一棵完全完全二叉树，同时也是一棵最小树。 需要注意的问题是：堆中的任一子树也还是堆，即大顶堆的子树也都是大顶堆，小顶堆同样。
[数据结构]堆的基本概念及其操作
Uniontake
03-29 492
　　　　基本数据结构――堆的基本概念及其操作          转载自: http://www.cnblogs.com/JVxie/p/4859889.html　　　　　　在我刚听到堆这个名词的时候，我认为它是一堆东西的集合．．．              但其实吧它是利用完全二叉树的结构来维护一组数据，然后进行相关操作，一般的操作进行一次的时间复杂度在                      ...
堆（概念，数据结构中堆与内存堆区的区别 ，堆的基本操作）
LXY的博客
04-12 2万+
堆的特性： 必须是完全二叉树 用数组实现 任一结点的值是其子树所有结点的最大值或最小值 最大值时，称为“最大堆”，也称大根堆； 最小值时，称为“最小堆”，也称小根堆。 大根堆 小根堆 可以看到，对于**堆（Heap）**这种数据结构，从根节点到任意结点路径上所有的结点都是有序的。 数据结构中堆与内存堆区的区别 一、数据结构中的堆和栈 堆和栈在数据结构中是两种不同的数据结构。 两者都是数据...
STL之heap相关操作算法
JXH_123的专栏
06-26 2393
堆（heap）是一种非常重要的数据结构（这里我们讨论的是二叉堆），它是一棵满足特定条件的完全二叉树，堆的定义如下： 堆是一棵树完全二叉树，对于该完全二叉树中的每一个结点x，其关键字大于等于(或小于等于）其左右孩子结点，而其左右子树均为一个二叉堆。
堆的原理实现详解以及堆的应用
Lessen的博客
06-15 1265
文章目录堆是什么堆的存储方式插入结点删除结点堆排序代码实现 堆是什么   堆（heap）本质上就是一棵完全二叉树，只不过这棵完全二叉树有点特别，能够被称为堆的二叉树，除了它必须要是一棵完全二叉树外，它的每一个结点都必须大于或者小于其子节点。 解释一下就是对于树中的所有的结点都至少有一棵子树，对于这个结点的子树上所有的结点都必须要大于或者小于其父节点。因此，堆也是个递归的定义，通常，我们将结点都大于或者等于子树所有结点的堆称为最大堆 ；将结点都小于或者等于子树所有结点的堆称为最小堆 。如下图所示：
C语言面试题
热门推荐
JIWilliams
08-01 5万+
1 预处理 问题1：什么是预编译？何时需要预编译？ 答： 预编译又称预处理，是整个编译过程最先做的工作，即程序执行前的一些预处理工作。主要处理#开头的指令。如拷贝#include包含的文件代码、替换#define定义的宏、条件编译#if等。. 何时需要预编译： 1、总是使用不经常改动的大型代码体。 2、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，...
堆的基本操作实现
cyd_csdn的博客
05-15 685
一、堆的概念        堆数据结构是一种数据对象，它可以被视为一棵完全二叉树结构。        堆的二叉树存储是：                最大堆：每个父节点都大于其孩子结点；                最小堆：每个父节点都小于其孩子结点。二、堆的实现1.堆的结构体typedef struct Heap { HeapType data[HeapMaxSize]; ...
堆的操作（priority_queue容器的介绍）
liuguuangsheng的博客
07-22 408
堆的介绍 堆是一颗完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。其中，如果父亲结点的值大于或等于孩子结点的值，那么称这样的堆为大顶堆。如果父亲结点的值小于或等于孩子结点的值，那么称这样的堆为小顶堆。 堆的常用操作代码实现： #include<iostream> #include<algorithm> using namespace std; const ...
堆的操作
LightInDarkness的博客
02-26 2519
编写代码，实现最小堆（Min-Heap）的操作。 输入格式: 第一行是两个不大于1000的正整数N和K，用空格间隔。其中N是堆的容量，需创建一个容量为N的堆。 接下来K行，是对这个堆的依次的K项插入或删除操作：用1 x表示插入元素x；用-1表示删除堆顶。 接下来一行是一个不大于1000的正整数M， 接下来一行是M个整数（在整型范围内），用空格间隔， 要求将这M个整数组成的列表调...
堆串操作：创建、删除、插入与合并代码实现
在实际的堆串实现中，还需要包含堆操作相关的函数，如`Max`（找到最大元素）、`Heapify`（调整堆的结构）等。此外，这段代码使用了`malloc.h`库进行动态内存分配，而在C++中，通常推荐使用`new`运算符和`delete`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值