堆的相关操作

最新推荐文章于 2024-09-18 12:56:12 发布
最新推荐文章于 2024-09-18 12:56:12 发布
阅读量480 收藏
点赞数
文章标签： 数据结构 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43655213/article/details/104767000
版权

堆

堆的定义

堆（Heap）是一种数据结构，堆通常是可以被看做一棵完全二叉树的数组对象。

  • 堆的特性
  1. 结构性：用数组表示的完全二叉树
  2. 有序性：任一节点的关键字是其子树所有节点的最大值(或最小值)

堆的类型

最大堆(MaxHeap)：也称“大顶堆”，有序性表示为根节点存储的值为子树所有节点的最大值
最小堆(MinHeap)：也称“小顶堆”，有序性表示为根节点存储的值为子树所有节点的最小值

堆结构的创建

//定义堆结构
typedef struct HNode{
    int* Data;	//存储数据的数组
    int Size;	//当前堆中的元素个数
    int capacity;	//最大容量
    HNode()	//构造函数进行初始化
    {
        Data = new int[100];
        Size = 0;
        Data[0] = 1000;//   哨兵
        capacity = 100;//  可存入100个数据
    }
}HNode,*Heap;

大顶堆的操作

插入操作

  • 在进行插入时，首先判断堆是否已满，堆满则不进行插入，堆未满，进行插入；
  • 先将元素存入堆尾（Size + 1）的位置，再进行向上比较，如果大于其父节点，则向上替换，直到替换至根节点
//大顶堆插入操作
void Insert_MaxHeap(Heap H,int x)
{
    if(H->Size == H->capacity)  //检查堆是否已满
        return;
    ++H->Size;  //  插入元素，首先插入到堆尾
    int position = H->Size;
    for(;H->Data[position / 2] < x;position /= 2)
        H->Data[position] = H->Data[position / 2];
    H->Data[position] = x;
}

删除操作

  • 在进行删除时，首先检查堆是否为空，为空，则不进行删除，不为空，执行删除操作
  • 将堆尾元素保存至堆的第一个元素，从上而下，判断该元素是否大于其孩子节点的值，如果大于，则直接返回，小于，则进行替换，直到最后一个元素
//大顶堆删除堆顶元素
void Delete_MaxHeap(Heap H)
{
    int tmp = H->Data[H->Size]; //先存储堆中最后一个元素
    H->Size--;
    int parent = 1;
    int child = 0;
    for(;parent * 2 <= H->Size;)
    {
        child = parent * 2;
        if(child < H->Size && H->Data[child] < H->Data[child + 1])	//在孩子节点中寻找最大的
            child++;
        if(tmp > H->Data[child])
            break;
        else
            H->Data[parent] = H->Data[child];
        parent = child;
    }
    H->Data[parent] = tmp;
}

创建大顶堆

创建一个大顶堆有两种思路：

  1. 进行一组循环插入，把所有元素进行插入操作，完成创建，但是这种方式，效率较低，时间复杂度为O(n logn)
  2. 将要创建的数据无序插入堆中，然后对堆中的元素进行调整，从最后的一棵树开始，使得每棵树都是一个大顶堆
    方法一
//创建大顶堆：方法一(O(N logN))
void Build_MaxHeap_1(Heap H,vector<int> data)
{
    for(int i = 0;i < data.size();i++)
        Insert_MaxHeap(H,data[i]);
}

方法二

//创建大顶堆：方法二(O(N))
void Build_MaxHeap_2(Heap H,vector<int> data)
{
    for(int i = 0;i < data.size();i++)	//无序存入堆中
        H->Data[i + 1] = data[i];
    H->Size = data.size();
    int judge = H->Size / 2;
    for(;judge > 0;judge--)	//从最后一棵右孩子节点的树开始调整
    {
        int tmp = H->Data[judge];
        int parent = judge;
        int child = judge;
        while(parent*2 <= H->Size)	//进行调整
        {
            child = parent * 2;
            if(child < H->Size && H->Data[child] < H->Data[child + 1])
                child++;
            if(tmp > H->Data[child])
                break;
            else
                H->Data[parent] = H->Data[child];
            parent = child;
        }
        H->Data[parent] = tmp;
    }
}

取堆顶元素

//大顶堆取堆顶元素
int Top_MaxHeap(Heap H)
{
    if(H->Size == 0)	//判断堆是否为空
	return -1;
    return H->Data[1];
}

小顶堆的操作

插入操作

  • 在进行插入时，首先判断堆是否已满，堆满则不进行插入，堆未满，进行插入；
  • 先将元素存入堆尾（Size + 1）的位置，再进行向上比较，如果小于其父节点，则向上替换，直到替换至根节点
//小顶堆插入操作
void Insert_MinHeap(Heap H,int x)
{
    if(H->Size == H->capacity)  //检查堆是否已满
        return;
    H->Data[0] = -999;  //哨兵
    ++H->Size;
    int position = H->Size;
    for(;H->Data[position / 2] > x;position /= 2)
        H->Data[position] = H->Data[position/2];
    H->Data[position] = x;
}

删除操作

  • 在进行删除时，首先检查堆是否为空，为空，则不进行删除，不为空，执行删除操作
  • 将堆尾元素保存至堆的第一个元素，从上而下，判断该元素是否小于其孩子节点的值，如果小于，则直接返回，大于于，则进行替换，直到最后一个元素
//小顶堆删除堆顶元素
void Delete_MinHeap(Heap H)
{
    if(H->Size == 0)    //检查堆是否为空
        return;
    int tmp = H->Data[H->Size];
    H->Size--;
    int parent = 1;
    int child = 0;
    while(parent*2 <= H->Size)
    {
        child = parent*2;
        if(child < H->Size && H->Data[child] > H->Data[child + 1])
            child++;
        if(tmp > H->Data[child])
            H->Data[parent] = H->Data[child];
        else
            break;
        parent = child;
    }
    H->Data[parent] = tmp;
}

创建小顶堆

创建一个小顶堆有两种思路：

  1. 进行一组循环插入，把所有元素进行插入操作，完成创建，但是这种方式，效率较低，时间复杂度为O(n logn)
  2. 将要创建的数据无序插入堆中，然后对堆中的元素进行调整，从最后的一棵树开始，使得每棵树都是一个小顶堆
    方法一
//创建小顶堆：方法一(O(N logN))
void Build_MinHeap_1(Heap H,vector<int> data)
{
    for(int i = 0;i < data.size();i++)
        Insert_MinHeap(H,data[i]);
}

方法二

//创建小顶堆：方法二(O(N))
void Build_MinHeap_2(Heap H,vector<int> data)
{
    for(int i = 0;i < data.size();i++)
        H->Data[i + 1] = data[i];
    H->Size = data.size();
    int judge = H->Size / 2;
    for(;judge > 0;judge--)
    {
        int tmp = H->Data[judge];
        int parent = judge;
        int child = 0;
        while(parent*2 <= H->Size)
        {
            child = parent*2;
            if(child < H->Size && H->Data[child] > H->Data[child + 1])
                child++;
            if(tmp > H->Data[child])
                H->Data[parent] = H->Data[child];
            else
                break;
            parent = child;
        }
        H->Data[parent] = tmp;
    }
}

取堆顶元素

//小顶堆取堆顶元素
int Top_MinHeap(Heap H)
{
    if(H->Size == 0)
        return -1;
    return H->Data[1];
}

打印堆

//打印堆
void Print(Heap H)
{
    for(int i = 1;i < H->Size + 1;i++)
        cout << H->Data[i] << " ";
    cout << endl;
}

堆排序

这里给出了4中排序方式：
方式一：将最大堆堆顶元素依次出堆，存入一个数组中，最后返回数组，这样实现了元素从大到小的排序，但是会额外消耗O(n)的空间
方式二：将最小堆堆顶元素依次出堆，存入一个数组中，最后返回数组，这样实现了元素从小到大的排序，但是会额外消耗O(n)的空间
方式三：将最大堆堆顶元素与堆尾元素进行替换，再调整最大堆，重复n次，即可实现升序排序
方式四：将最小堆堆顶元素与堆尾元素进行替换，再调整最大堆，重复n次，即可实现降序排序
方式一：

//堆排序1:从大到小，借助额外空间,利用大顶堆
vector<int> HeapSort_1(Heap H)
{
    vector<int> Sort;
    int Size = H->Size;
    for(int i = 0;i < Size;i++)
    {
        Sort.push_back(Top_MaxHeap(H));
        Delete_MaxHeap(H);
    }
    return Sort;
}

方式二：

//堆排序2:从小到大，借助额外空间,利用小顶堆
vector<int> HeapSort_2(Heap H)
{
    vector<int> Sort;
    int Size = H->Size;
    for(int i = 0;i < Size;i++)
    {
        Sort.push_back(Top_MinHeap(H));
        Delete_MinHeap(H);
    }
    return Sort;
}

方式三：

//堆排序3:从小到大，不借助额外空间,利用大顶堆
void HeapSort_3(Heap H)
{
    int Rear = H->Size;
    for(;Rear > 1;)
    {
        int tmp = H->Data[Rear];	//保存堆尾元素，与删除操作类似
        H->Data[Rear] = H->Data[1];
        Rear--;
        int parent = 1;
        int child = 0;
        while(parent * 2 <= Rear)
        {
            child = parent * 2;
            if(child < Rear && H->Data[child] < H->Data[child + 1])
                child++;
            if(tmp > H->Data[child])
                break;
            else
                H->Data[parent] = H->Data[child];
            parent = child;
        }
        H->Data[parent] = tmp;
    }
}

方式四：

//堆排序4:从大到小，不借助额外空间,利用小顶堆
void HeapSort_4(Heap H)
{
    int Rear = H->Size;
    for(;Rear > 1;)
    {
        int tmp = H->Data[Rear];
        H->Data[Rear] = H->Data[1];
        Rear--;
        int parent = 1;
        int child = 0;
        while(parent*2 <= Rear)
        {
            child = parent * 2;
            if(child < Rear && H->Data[child] > H->Data[child + 1])
                child++;
            if(tmp > H->Data[child])
                H->Data[parent] = H->Data[child];
            else
                break;
            parent = child;
        }
        H->Data[parent] = tmp;
    }
}

测试数据

生成给定长度的一组不重复的随机数

//测试数据
vector<int> randVector(int num) {
    vector<int> result;
    result.clear();
    result.reserve(num);
    srand((int)time(0));
    for (int i = 0; i < num; i++)
    {
        result.push_back(i);
    }
    int p1;
    int p2;
    int temp;
    while (--num)
    {
        p1 = num;
        p2 = rand() % num;
        temp = result[p1];
        result[p1] = result[p2];
        result[p2] = temp;
    }
    return result;
}

完整程序

#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>
using namespace std;

//定义堆结构
typedef struct HNode{
    int* Data;
    int Size;
    int capacity;
    HNode()
    {
        Data = new int[100];
        Size = 0;
        Data[0] = 1000;//   哨兵
        capacity = 1000;//  可存入1000个数据
    }
}HNode,*Heap;

//大顶堆插入操作
void Insert_MaxHeap(Heap H,int x)
{
    if(H->Size == H->capacity)  //检查堆是否已满
        return;
    ++H->Size;  //  插入元素，首先插入到堆尾
    int position = H->Size;
    for(;H->Data[position / 2] < x;position /= 2)
        H->Data[position] = H->Data[position / 2];
    H->Data[position] = x;
}

//小顶堆插入操作
void Insert_MinHeap(Heap H,int x)
{
    if(H->Size == H->capacity)  //检查堆是否已满
        return;
    H->Data[0] = -999;  //哨兵
    ++H->Size;
    int position = H->Size;
    for(;H->Data[position / 2] > x;position /= 2)
        H->Data[position] = H->Data[position/2];
    H->Data[position] = x;
}

//大顶堆取堆顶元素
int Top_MaxHeap(Heap H)
{
    return H->Data[1];
}

//小顶堆取堆顶元素
int Top_MinHeap(Heap H)
{
    if(H->Size == 0)
        return -1;
    return H->Data[1];
}

//大顶堆删除堆顶元素
void Delete_MaxHeap(Heap H)
{
    int tmp = H->Data[H->Size]; //先存储堆中最后一个元素
    H->Size--;
    int parent = 1;
    int child = 0;
    for(;parent * 2 <= H->Size;)
    {
        child = parent * 2;
        if(child < H->Size && H->Data[child] < H->Data[child + 1])
            child++;
        if(tmp > H->Data[child])
            break;
        else
            H->Data[parent] = H->Data[child];
        parent = child;
    }
    H->Data[parent] = tmp;
}

//小顶堆删除堆顶元素
void Delete_MinHeap(Heap H)
{
    if(H->Size == 0)    //检查堆是否为空
        return;
    int tmp = H->Data[H->Size];
    H->Size--;
    int parent = 1;
    int child = 0;
    while(parent*2 <= H->Size)
    {
        child = parent*2;
        if(child < H->Size && H->Data[child] > H->Data[child + 1])
            child++;
        if(tmp > H->Data[child])
            H->Data[parent] = H->Data[child];
        else
            break;
        parent = child;
    }
    H->Data[parent] = tmp;
}

//创建大顶堆：方法一(O(N logN))
void Build_MaxHeap_1(Heap H,vector<int> data)
{
    for(int i = 0;i < data.size();i++)
        Insert_MaxHeap(H,data[i]);
}

//创建小顶堆：方法一(O(N logN))
void Build_MinHeap_1(Heap H,vector<int> data)
{
    for(int i = 0;i < data.size();i++)
        Insert_MinHeap(H,data[i]);
}

//创建大顶堆：方法二(O(N))
void Build_MaxHeap_2(Heap H,vector<int> data)
{
    for(int i = 0;i < data.size();i++)
        H->Data[i + 1] = data[i];
    H->Size = data.size();
    int judge = H->Size / 2;
    for(;judge > 0;judge--)
    {
        int tmp = H->Data[judge];
        int parent = judge;
        int child = judge;
        while(parent*2 <= H->Size)
        {
            child = parent * 2;
            if(child < H->Size && H->Data[child] < H->Data[child + 1])
                child++;
            if(tmp > H->Data[child])
                break;
            else
                H->Data[parent] = H->Data[child];
            parent = child;
        }
        H->Data[parent] = tmp;
    }
}

//创建小顶堆：方法二(O(N))
void Build_MinHeap_2(Heap H,vector<int> data)
{
    for(int i = 0;i < data.size();i++)
        H->Data[i + 1] = data[i];
    H->Size = data.size();
    int judge = H->Size / 2;
    for(;judge > 0;judge--)
    {
        int tmp = H->Data[judge];
        int parent = judge;
        int child = 0;
        while(parent*2 <= H->Size)
        {
            child = parent*2;
            if(child < H->Size && H->Data[child] > H->Data[child + 1])
                child++;
            if(tmp > H->Data[child])
                H->Data[parent] = H->Data[child];
            else
                break;
            parent = child;
        }
        H->Data[parent] = tmp;
    }
}

//打印堆
void Print(Heap H)
{
    for(int i = 1;i < H->Size + 1;i++)
        cout << H->Data[i] << " ";
    cout << endl;
}

//堆排序1:从大到小，借助额外空间,利用大顶堆
vector<int> HeapSort_1(Heap H)
{
    vector<int> Sort;
    int Size = H->Size;
    for(int i = 0;i < Size;i++)
    {
        Sort.push_back(Top_MaxHeap(H));
        Delete_MaxHeap(H);
    }
    return Sort;
}

//堆排序2:从小到大，借助额外空间,利用小顶堆
vector<int> HeapSort_2(Heap H)
{
    vector<int> Sort;
    int Size = H->Size;
    for(int i = 0;i < Size;i++)
    {
        Sort.push_back(Top_MinHeap(H));
        Delete_MinHeap(H);
    }
    return Sort;
}

//堆排序3:从小到大，不借助额外空间,利用大顶堆
void HeapSort_3(Heap H)
{
    int Rear = H->Size;
    for(;Rear > 1;)
    {
        int tmp = H->Data[Rear];
        H->Data[Rear] = H->Data[1];
        Rear--;
        int parent = 1;
        int child = 0;
        while(parent * 2 <= Rear)
        {
            child = parent * 2;
            if(child < Rear && H->Data[child] < H->Data[child + 1])
                child++;
            if(tmp > H->Data[child])
                break;
            else
                H->Data[parent] = H->Data[child];
            parent = child;
        }
        H->Data[parent] = tmp;
    }
}

//堆排序4:从大到小，不借助额外空间,利用小顶堆
void HeapSort_4(Heap H)
{
    int Rear = H->Size;
    for(;Rear > 1;)
    {
        int tmp = H->Data[Rear];
        H->Data[Rear] = H->Data[1];
        Rear--;
        int parent = 1;
        int child = 0;
        while(parent*2 <= Rear)
        {
            child = parent * 2;
            if(child < Rear && H->Data[child] > H->Data[child + 1])
                child++;
            if(tmp > H->Data[child])
                H->Data[parent] = H->Data[child];
            else
                break;
            parent = child;
        }
        H->Data[parent] = tmp;
    }
}

//打印排序数组
void Print_Vector(vector<int> num)
{
    for(int i = 0;i < num.size();i++)
        cout << num[i] << " ";
    cout << endl;
}

//测试数据
vector<int> randVector(int num) {
    vector<int> result;
    result.clear();
    result.reserve(num);
    srand((int)time(0));
    for (int i = 0; i < num; i++)
    {
        result.push_back(i);
    }
    int p1;
    int p2;
    int temp;
    while (--num)
    {
        p1 = num;
        p2 = rand() % num;
        temp = result[p1];
        result[p1] = result[p2];
        result[p2] = temp;
    }
    return result;
}

int main()
{
    vector<int> test = randVector(20);
    vector<int> Sort1;
    vector<int> Sort2;
    //vector<>
    Heap H1 = new HNode();
    Heap H2 = new HNode();
    Heap H3 = new HNode();
    Heap H4 = new HNode();
    cout << "----堆的相关操作----" << endl;
    Build_MaxHeap_1(H1,test);
    cout << endl << "方式一创建的大顶堆：" << endl;
    Print(H1);
    Build_MaxHeap_2(H2,test);
    cout << endl << "方式二创建的大顶堆：" << endl;
    Print(H2);
    Build_MinHeap_1(H3,test);
    cout << endl << "方式一创建的小顶堆：" << endl;
    Print(H3);
    Build_MinHeap_2(H4,test);
    cout << endl << "方式二创建的小顶堆：" << endl;
    Print(H4);
    Sort1 = HeapSort_1(H1);
    cout << endl << "堆排序1:从大到小，借助额外空间,利用大顶堆" << endl;
    Print_Vector(Sort1);
    Sort2 = HeapSort_2(H3);
    cout << endl << "堆排序2:从小到大，借助额外空间,利用小顶堆" << endl;
    Print_Vector(Sort2);
    HeapSort_3(H2);
    cout << endl << "堆排序3:从小到大，不借助额外空间,利用大顶堆" << endl;
    Print(H2);
    HeapSort_4(H4);
    cout << endl << "堆排序4:从大到小，不借助额外空间,利用小顶堆" << endl;
    Print(H4);
    return 0;
}

程序运行结果

堆

慢慢``
关注
java实现堆的操作方法(建堆,插入,删除)
08-28
在计算机科学中，堆是一种特殊的完全二叉树，满足任意节点的值都大于或等于其子节点的值（大顶堆），或者小于或等于其子节点的值...掌握堆的操作对于学习和理解各种排序和优先级管理相关的算法和数据结构非常有帮助。
堆的基本概念及常用操作
JohnSon
02-17 6420
堆 完全二叉树：若设二叉树的深度为nnn，除第nnn层外，其它各层 (111～n−1n−1n-1) 的结点数都达到最大个数，第nnn层所有的结点都连续集中在最左边，这就是完全二叉树 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为nnn，且结点总数是2n−12n−12^n - 1 ，则它就是满二叉树 堆(heap)又被为优先队列...
数据结构：浅谈“堆”的相关操作
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
04-15 254
写在前面：          这几天花了一些时间将“数据结构—堆”的相关操作和逻辑原理捋了捋。今天简明扼要的做一下小结。          在正式看“堆”之前，大家先读一下我在百度截取的关于堆的定义。 那么，我截取这句...
【算法】堆，最大堆（大顶堆）及最小堆（小顶堆）的实现
热门推荐
一名普通码农的菜地
09-13 9万+
此坑待埋。 点击打开漫谈经典排序算法:一、从简单选择排序到堆排序的深度解析链接 白话经典算法系列之七 堆与堆排序 二叉排序树与二叉堆 下面来说一说具体算法。
【数据结构：堆】——堆及堆的相关操作（C语言）
紫阳战君的博客
07-29 310
1、什么是堆？ 堆： 如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根...
PTA 堆的操作
qq_43778565的博客
12-14 3294
7-15 堆的操作 (20分) 编写代码，实现最小堆（Min-Heap）的操作。 输入格式: 第一行是两个不大于1000的正整数N和K，用空格间隔。其中N是堆的容量，需创建一个容量为N的堆。 接下来K行，是对这个堆的依次的K项插入或删除操作：用 1 x 表示插入元素x；用 -1 表示删除堆顶。 接下来一行是一个不大于1000的正整数M， 接下来一行是M个整数（在整型范围内），用空格间隔， 要求将这...
最大堆的相关操作
12-10
封装了最大堆的相关操作 包括插入删除等操作
数据结构 堆串基本操作代码
05-17
根据给定的信息，本文将详细解释“数据结构堆串基本操作代码”中涉及的关键知识点，包括堆串的创建、删除、插入、清空以及判空等操作。 ### 一、堆串简介 ...希望本文能够帮助您更好地理解和应用堆串相关的知识。
操作系统相关题目总结
01-20
　*进程虚拟地址空间包括：代码段、堆栈段(临时数据：如函数参数、返回地址和局部变量)、数据段(包括全局变量)、堆(动态分配的内存)等等。 　3.线程运行在进程的上下文中，所有运行在一个进程内的线程共享该进程...
Leetcode刷题笔记-堆
08-19
### Leetcode刷题笔记——堆相关题型解析 在算法学习和面试准备的过程中，Leetcode是一个不可或缺的资源库。本文将深入探讨堆相关的基础知识及其在Leetcode中的具体应用，特别是针对“Top K”问题的经典解决方案。 ...
堆的基本操作详解
weixin_52122624的博客
05-30 984
堆的性质 1，堆中某节点的值总是不大于或不小于其父节点的值。 2，堆是一颗完全二叉树。 1，堆分为两种，大根堆和小根堆。 2，我们用数组来存储堆，所以我们想象出来的是一颗完全二叉树，实际上操纵的是数组。如图： 3，现在我们来实现堆的基本操作。 （1）首先，我们来创建一个结构体来表示堆。 typedef struct Heap { HPDataType* _a;//使用动态的数组，方便扩容。 int _size;//堆的有效数字的个数 int _capacity..
数据结构| |对于堆的基本操作(总概括)
凯的博客
08-22 224
堆：就是完全二叉树，所以对于堆的存储可以用顺序存储来储存堆。这样便于对堆的便利与操作。 对于具有n个结点的完全二叉树，如果按照从上至下，从左至右的顺序对所有节点从0开始编号，则对于序号为i的节点有： 若i &amp;gt; 0，双亲序号：(i - 1) / 2; i = 0, i为根节点编号，无双亲结点 若2i + 1 &amp;lt; n,左孩子序号：2i + 1,否则无左孩子结点 若...
堆的相关操作（创建堆、插入、删除、堆排序、top-k问题）
weixin_62042704的博客
12-08 3141
一、什么是堆 堆得满足两个特性：1、首先得是一个完全二叉树 2、每个节点比其孩子节点都大（小），则其是大（小）堆。 堆是将其元素存储在一维数组中的。 二、堆的创建 1、首先了解堆向下调整算法： 向下调整算法有一个前提：左右子树必须得是一个堆。如图所示，只有根节点不满足堆的特性。 现在就来向下调整根节点，使其整体成为一个小堆。具体做法是让父节点和它较小的子节点交换（前提是左右节点都存在），然后再让父节点等于子节点；重复此操作...
王道408考研数据结构-线性表-第二章
qq_55882840的博客
09-17 1270
2.1 线性表的定义2.1.1 线性表的定义线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列，其中n为表长，当n=0 时线性表是一个空表。若用L命名线性表，则其一般表示为式中，a1是唯一的“第一个”数据元素，又称表头元素；an是唯一的“最后一个”数据元素，又 称表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继(“直接前驱”和“前驱”、“直接后继”和“后继”通常被视为同义词)。
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 624
数据结构之字典和哈希表
数据结构————栈的讲解(超详细！！！)
braveact的博客
09-11 1035
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出（先进后出）原则。特性与栈的结构有关。
python-简单的数据结构
最新发布
2401_83954530的博客
09-18 867
当执行 6 操作时，第一行先输出当前的个数，然后从头到尾按顺序输出，每两个元素之间用一个空格隔开，末尾不能有空格。3，删除：remove(),del 语句,pop(),filter(),clear(),切片操作，列表推导式。2，添加：insert(),append(),extend(),索引添加。只有一组数据，第一行 n,m 代表最大数据数目和操作次数。对于 100% 的数据，保证 1≤n,m,a≤105。一开始该容器为空，有以下七种操作。列表的操作：素引，添加，删除，替换。1，索引：正索引，负索引。
数据结构day2
m0_74933801的博客
09-17 641
D选项正确地使用了点操作符（）来访问结构体stud中的 name 成员。由于 name 是一个字符数组，它可以被printf函数的 %s格式说明符直接用作字符串输出，这正是题目所要求的。①输入学生信息②输出学生信息③计算学生的成绩总分、平均分④按照学生的分数进行排序⑤输出排序后的数组#define Stu_num 5 // 定义学生数量为5//定义学生结构体int id;//学号//姓名//分数}Stu;//输入函数//输出函数//排序函数// 计算总分// 计算平均分。
C语言实现堆操作：创建、调整与排序
堆是一种特殊的树形数据结构，其主要特点是父节点的键值总是大于或等于其所有子节点的键值，满足最大堆（Max-...理解这些代码可以帮助开发者在需要优先级队列、最值问题或其他与堆相关的算法时，高效地设计和优化代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值