栈与队列（OJ）

最新推荐文章于 2024-11-08 23:41:22 发布
最新推荐文章于 2024-11-08 23:41:22 发布
阅读量1.3k 收藏 6
点赞数 7
分类专栏： 数据结构与算法 C语言的学习 文章标签： 数据结构 c++ 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuzhu_yt/article/details/129723831
版权

有效的括号（力扣）：

→→→→→→→→→→→→→→→→→哆啦A梦的任意门←←←←←←←←←←←←←←←←←←←

那么我们来看一下这道OJ题的具体要求叭！

如果我还没学习栈的时候，我可能基本思路就是去数左右括号的总个数了，这样肯定做不出题目的。当然今时不同往日了，我已经学会了栈这种数据结构，我们可以通过栈去实现这些括号的闭合匹配了

分析：

我们来分析一下如何运用栈：

由于第一个括号必须是左括号，所以我们就让左括号入栈，等遇到右括号，再进行出栈操作，进行匹配即可

我们再来分析一下括号不匹配的相关情况：

  1. 多出来了若干个左括号，无法完全匹配

  1. 不会多出多余的括号，但是左右括号不匹配

  1. 多出来了若干个右括号，无法完全匹配

那么以上三种情况，如何在代码中体现呢？

  1. 遍历一遍字符串，如果栈到最后还存在数据，那么说明有若干个左括号没有相对应的右括号进行匹配

  1. 遍历字符串的过程中，存在右括号与栈顶的左括号不匹配的状况

  1. 遍历字符串的过程中，遇到右括号时，我们的栈为空。

那么通过以上的分析，我们就很容易去实现我们括号的匹配了。

代码的步步实现：

由于我们用C语言去写这道题，我们就需要手搓一个栈。

上一篇文章我们已经手搓过一个栈了，那么我们就传送一下叭！

→→→→→→→→→→→→→→→→→哆啦A梦的任意门←←←←←←←←←←←←←←←←←←←

相信我们都拿到了手搓的栈了，那么我们就开始进行下一步操作！

我们先创建出一个栈，并对它进行初始化。

stack stack;
StackInit(&stack);

我们去遍历整个字符串，遇到左括号，就入栈

if(*(s + i) == '(' 
        || *(s + i) == '[' 
        || *(s + i) == '{')
            StackPush(&stack, *(s + i));

遇到右括号的时候就需要考虑一下了，如果我们的栈为空，那么不用说，肯定时匹配不上了，直接返回false，如果我们的栈不为空，我们就需要从栈顶出栈顶的一个左括号来和这个右括号进行匹配，如果匹配成功了就继续循环，如果匹配不上，我们就直接返回false

else
        {
            if(StackEmpty(&stack))
            {
                StackDestroy(&stack);
                return false;
            }
            char tmp = StackTop(&stack);
            StackPop(&stack);
            if((tmp == '(' && *(s + i) == ')') 
            || (tmp == '[' && *(s + i) == ']')
            || (tmp == '{' && *(s + i) == '}'))
            {
                continue;
            }
            else
            {
                StackDestroy(&stack);
                return false;
            }
        }

那么就到了最后一步了，我们遍历完整个字符串，发现过程中没有发现任何的不匹配问题，也就是我们上面分析的三种情况的二、三种情况，那么我们还需要判断我们分析的第一种情况，第一种情况只需要检查一下我们的栈是否为空即可，如果我们的栈不是空的，那么就完美了，我们直接返回true，如果不是，我们就返回false

  if(StackEmpty(&stack))
    {
        StackDestroy(&stack);
        return true;
    }
    StackDestroy(&stack);
    return false;

我们可能有同学也看出来了，每次返回值的时候，我们都会对栈进行销毁，这是个好习惯，有效的防止了我们的内存泄漏。

那么我们来看一下完整的代码叭：

bool isValid(char * s)
{
    stack stack;
    StackInit(&stack);

    for(int i = 0; *(s + i) != '\0'; i++)
    {
        if(*(s + i) == '(' 
        || *(s + i) == '[' 
        || *(s + i) == '{')
            StackPush(&stack, *(s + i));
        else
        {
            if(StackEmpty(&stack))
            {
                StackDestroy(&stack);
                return false;
            }
            char tmp = StackTop(&stack);
            StackPop(&stack);
            if((tmp == '(' && *(s + i) == ')') 
            || (tmp == '[' && *(s + i) == ']')
            || (tmp == '{' && *(s + i) == '}'))
            {
                continue;
            }
            else
            {
                StackDestroy(&stack);
                return false;
            }
        }
    }
    if(StackEmpty(&stack))
    {
        StackDestroy(&stack);
        return true;
    }
    StackDestroy(&stack);
    return false;
}

那么我们来进行下一道OJ题

用栈实现队列（力扣）：

→→→→→→→→→→→→→→→→→哆啦A梦的任意门←←←←←←←←←←←←←←←←←←←

老样子，我们还是先来看一下我们题目的要求叭！

分析：

我们栈的数据是先进后出，后进先出，而我们队列是先进先出，后进后出。

假设我们的栈里面一次入栈了1-7的数字，我们需要一样按顺序去出栈，那么我们第一个数字就必须输出1，那么我们就必须如下图，先把1以上的其他数字入另一个栈。

那么我们就可以得到第一个数，之后我们可以发现，另一个栈所呈现数据的顺序就是我们需要的顺序，那么我们就遍历出栈即可。

代码的步步实现：

我们还是需要手搓一个栈，我相信很多小伙伴都不想往上翻或退出去再找一次，那么，上任意门

→→→→→→→→→→→→→→→→→哆啦A梦的任意门←←←←←←←←←←←←←←←←←←←

因为我们需要创建两个栈，所以我是不是可以用一个结构体来表示我的两个栈？

typedef struct {
    int stackInTop, stackOutTop;
    int stackIn[100], stackOut[100];
} MyQueue;

该结构体存放了我们输出以及输入的两个栈，还有两个栈的栈顶。

当然，我们的栈还是需要初始化的

MyQueue* myQueueCreate() 
{
    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));
    if(queue == NULL)
    {
        perror("malloc fail");
        return;
    }
    queue->stackInTop = 0;
    queue->stackOutTop = 0;
    return queue;
}

一定要记得把两个栈顶置为0.

void myQueuePush(MyQueue* obj, int x) 
{
    obj->stackIn[(obj->stackInTop)++] = x;
}

先把元素压入第一个栈，然后让我们的栈顶+1

出栈！！！

int myQueuePop(MyQueue* obj) {
    int stackInTop = obj->stackInTop;
    int stackOutTop = obj->stackOutTop;
    //若输出栈为空
    if(stackOutTop == 0) {
        while(stackInTop > 0) {
            obj->stackOut[stackOutTop++] = obj->stackIn[--stackInTop];
        }
    }
    int top = obj->stackOut[--stackOutTop];
    while(stackOutTop > 0) {
        obj->stackIn[stackInTop++] = obj->stackOut[--stackOutTop];
    }
    obj->stackInTop = stackInTop;
    obj->stackOutTop = stackOutTop;
    return top;
}

如果输出栈为空，而且第一个栈有元素，我们就需要将第一个栈的元素倒腾到第二个栈当中，

还要把栈顶元素进行保存。

返回栈底元素

int myQueuePeek(MyQueue* obj) {
    return obj->stackIn[0];
}

判断队列是否为空

bool myQueueEmpty(MyQueue* obj) {
    return obj->stackInTop == 0 && obj->stackOutTop == 0;
}

只需要判断两个栈顶是否为0就ok啦

将栈顶指针置为0

void myQueueFree(MyQueue* obj) {
    obj->stackInTop = 0;
    obj->stackOutTop = 0;
}

那么我们来看一下完整的代码叭：

typedef struct {
    int stackInTop, stackOutTop;
    int stackIn[100], stackOut[100];
} MyQueue;

MyQueue* myQueueCreate() 
{
    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));
    if(queue == NULL)
    {
        perror("malloc fail");
        return;
    }
    queue->stackInTop = 0;
    queue->stackOutTop = 0;
    return queue;
}

void myQueuePush(MyQueue* obj, int x) 
{
    obj->stackIn[(obj->stackInTop)++] = x;
}

int myQueuePop(MyQueue* obj) {
    int stackInTop = obj->stackInTop;
    int stackOutTop = obj->stackOutTop;
    //若输出栈为空
    if(stackOutTop == 0) {
        while(stackInTop > 0) {
            obj->stackOut[stackOutTop++] = obj->stackIn[--stackInTop];
        }
    }
    int top = obj->stackOut[--stackOutTop];
    while(stackOutTop > 0) {
        obj->stackIn[stackInTop++] = obj->stackOut[--stackOutTop];
    }
    obj->stackInTop = stackInTop;
    obj->stackOutTop = stackOutTop;
    return top;
}

int myQueuePeek(MyQueue* obj) {
    return obj->stackIn[0];
}

bool myQueueEmpty(MyQueue* obj) {
    return obj->stackInTop == 0 && obj->stackOutTop == 0;
}

void myQueueFree(MyQueue* obj) {
    obj->stackInTop = 0;
    obj->stackOutTop = 0;
}

用队列实现栈（力扣）：

→→→→→→→→→→→→→→→→→哆啦A梦的任意门←←←←←←←←←←←←←←←←←←←

还是先来看一下题目的要求叭！

分析：

还是先从我们两种数据结构的性质进行分析，栈是先进后出，后进先出，而队列是先进先出，后进后出。

根据以上性质，还有上一道用栈实现队列的思路，我们也大概能分析出来。

还是一样的思路，一个队列用于输出我们的元素，一个元素用来备份我们的元素。

来看下面的一组图：

我们发现了，这个思路虽然和我们上面的那题虽然像，但是，好像并没有那么简单，我们刚做完的那道题，只需要倒腾一次，这元素的排列就符合我们的预期了，但是这道题就不一样，我们需要倒腾一次才能输出一次，但是这并不影响我们的做题。

那么就马上到我们的代码实现叭！

代码的步步实现：

当然，还是先把两个队列封装进一个结构体当中

typedef struct 
{
    Queue q1;
    Queue q2;
} MyStack;

我们栈的创建，因为这个栈的创建是通过初始化两个队列，所以我们可以看到对两个队列进行初始化

MyStack* myStackCreate() 
{
    MyStack* mystack = (MyStack*)malloc(sizeof(MyStack));
    assert(mystack);
    QueueInit(&mystack->q1);
    QueueInit(&mystack->q2);
    return mystack;
}

那么来到元素的压栈

void myStackPush(MyStack* obj, int x) 
{
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

我们也能分析的出，一个队列是用来备份我们的数据的，另一个用来对元素进行输出。

所以我们只对一个有数据的队列进行压栈。

到出栈啦！

int myStackPop(MyStack* obj) 
{
    assert(obj);
    Queue* EmptyQueue = &obj->q1;
    Queue* NonEmptyQueue = &obj->q2;
    if(!QueueEmpty(EmptyQueue))
    {
        EmptyQueue = &obj->q2;
        NonEmptyQueue = &obj->q1;
    }
    while(QueueSize(NonEmptyQueue) > 1)
    {
        QueuePush(EmptyQueue, QueueTop(NonEmptyQueue));
        QueuePop(NonEmptyQueue);
    }
    int top = QueueTop(NonEmptyQueue);
    QueuePop(NonEmptyQueue);
    return top;
}

我们默认第一个队列是空的嘛，那么如果不是空的，那么另一个就是空的咯~

所以我们要找到那个空的队列，也就是上一次的输出队列，让它来当一次存储数据的队列，然后上一次用来存储数据的队列对最后一个元素进行输出即可！

获取我们的栈顶元素数据

int myStackTop(MyStack* obj) 
{
    assert(obj);
    assert(!myStackEmpty(obj));
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

当然，还是要先找到哪个不是空的队列

检查栈是否为空

bool myStackEmpty(MyStack* obj) 
{
    assert(obj);
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

如果栈是空的，那么两个队列都是空的。

将该栈进行销毁

void myStackFree(MyStack* obj) 
{
    assert(obj);
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

养成编程的好习惯，先从释放内存做起，记得一定要先释放那两个队列，再去释放这个栈，如果先释放这个栈，我们再去释放那两个队列的时候是找不到那两个队列的

那么我们来看一下完整的代码叭：

typedef struct QNode//队列节点
{
    int data;
    struct QNode* next;
}QNode;
typedef struct Queue//队列
{
    QNode* front;
    QNode* tail;
}Queue;
//栈是否为空
bool myStackEmpty(MyStack* obj);
//初始化
void QueueInit(Queue* queue);
//队列是否为空
bool QueueEmpty(Queue* queue);
//进队
void QueuePush(Queue* queue, int x);
//出队
void QueuePop(Queue* queue);
//队列头部元素
int QueueTop(Queue* queue);
//队列尾部元素
int QueueBack(Queue* queue);
//队列有效元素个数
int QueueSize(Queue* queue);
//销毁队列
void QueueDestroy(Queue* queue);

void QueueInit(Queue* queue)//初始化
{
    assert(queue);
    queue->front = NULL;
    queue->tail = NULL;
}
//队列是否为空
bool QueueEmpty(Queue* queue)
{
    assert(queue);
    return queue->tail == NULL;
}
//进队
void QueuePush(Queue* queue, int x)
{
    assert(queue);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    assert(newnode);
    newnode->data = x;
    newnode->next = NULL;
    if(queue->tail == NULL)
    {
        queue->front = queue->tail = newnode;
    }
    else
    {
        queue->tail->next = newnode;
        queue->tail = newnode;
    }
}
//出队
void QueuePop(Queue* queue)
{
    assert(queue);
    QNode* next = queue->front->next;
    free(queue->front);
    queue->front = next;
    if(queue->front == NULL)
    {
        queue->tail = NULL;
    }
}
//队列头部元素
int QueueTop(Queue* queue)
{
    assert(queue);
    assert(queue->front);
    return queue->front->data;
}
//队列尾部元素
int QueueBack(Queue* queue)
{
    assert(queue);
    assert(queue->tail);
    return queue->tail->data;
}
//队列有效元素个数
int QueueSize(Queue* queue)
{
    assert(queue);
    int size = 0;
    QNode* cur = queue->front;
    while(cur != NULL)
    {
        ++size;
        cur = cur->next;
    }
    return size;
}
//销毁队列
void QueueDestroy(Queue* queue)
{
    assert(queue);
    QNode* next = queue->front;
    while(next != NULL)
    {
        next = queue->front->next;
        free(queue->front);
        queue->front = next;
    }
    queue->tail = NULL;
}

typedef struct 
{
    Queue q1;
    Queue q2;
} MyStack;
//创建栈
MyStack* myStackCreate() 
{
    MyStack* mystack = (MyStack*)malloc(sizeof(MyStack));
    assert(mystack);
    QueueInit(&mystack->q1);
    QueueInit(&mystack->q2);
    return mystack;
}
//压栈
void myStackPush(MyStack* obj, int x) 
{
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}
//出栈
int myStackPop(MyStack* obj) 
{
    assert(obj);
    Queue* EmptyQueue = &obj->q1;
    Queue* NonEmptyQueue = &obj->q2;
    if(!QueueEmpty(EmptyQueue))
    {
        EmptyQueue = &obj->q2;
        NonEmptyQueue = &obj->q1;
    }
    while(QueueSize(NonEmptyQueue) > 1)
    {
        QueuePush(EmptyQueue, QueueTop(NonEmptyQueue));
        QueuePop(NonEmptyQueue);
    }
    int top = QueueTop(NonEmptyQueue);
    QueuePop(NonEmptyQueue);
    return top;
}
//栈顶元素
int myStackTop(MyStack* obj) 
{
    assert(obj);
    assert(!myStackEmpty(obj));
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}
//栈是否为空
bool myStackEmpty(MyStack* obj) 
{
    assert(obj);
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
//销毁栈
void myStackFree(MyStack* obj) 
{
    assert(obj);
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

写bug的小屁孩
关注
专栏目录
【数据结构】队列详解 && 栈和队列OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
StackFrame
11-16 1144
队列的概念和结构讲解、C语言实现队列、OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
数据结构---栈和队列OJ习题
qq_35297945的博客
01-19 434
1 括号匹配问题 1.1 题目介绍 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足：     左括号必须用相同类型的右括号闭合。     左括号必须以正确的顺序闭合。 注意:空字符串可被认为是有效字符串。 示例 1: 输入: “([])” 输出: true 示例 3: 输入: “(][)” 输出: false 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/valid-paren
栈与队列OJ题
Odfogy的博客
08-21 228
1、栈与队列的实现 //队列 ListNode*BuyListNode(LTDataType x) { ListNode *node = (ListNode*)malloc(sizeof(ListNode)); node->data = x; node->next = NULL; node->prev = NULL; return node; } ListNode*ListCreate() { ListNode*head = (ListNode*)malloc(sizeof(
栈与队列OJ题2
qq_53822523的博客
07-22 274
LeetCode刷题之用栈实现队列、用队列实现栈
数据结构：栈与队列OJ题
2401_86551514的博客
08-08 1491
前面讲了栈和队列的基础知识，今天来巩固一下加深理解，这里说明一下，因为现在都是在用C语言写，这些OJ题里都要用到前面实现栈和队列的代码，每道题我都会加上前面的链接方便查看。
【数据结构】栈与队列OJ题（用队列实现栈）（用栈实现队列）
wheeldown的博客
09-07 1292
这里要定义两个栈，我们分别命名为pop和push队列ST pushST;ST popST;}MyQU;return pst;
【数据结构-Java描述】栈与队列OJ题
qq_36148709的博客
07-28 670
思路准备两个栈，一个栈存放压入的元素，另一个栈存放最小的元素，压栈时，只有当第二个栈为空，或压栈的元素小于第二个栈的栈顶元素时，才往第二个栈里放元素，检索最小元素直接看第二个栈栈顶即可，另外，当出栈时出的元素和第二个栈栈顶元素相同，则要同时出栈，思路准备一个栈，如果是数字，压栈，遇到符号，出栈两个元素，首先出栈的元素放在符号右边，后面出栈的元素放在符号右边，形成一个表达式，计算表达式结果，将值压栈，遍历完成后栈里只剩下一个元素，该元素即为所求值。思路准备两个对，入队操作时，直接入队即可。...
栈和队列OJ
qq_41420788的博客
11-18 95
栈和队列OJ最小栈栈的压入、弹出序列 最小栈 题目链接 题目描述： 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop() —— 删除栈顶的元素。 top() —— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 思路： 如果我们只定义一个栈，再定义一个最小值，入栈时有比它小的就替换，但是出栈的时候由于删除了元素，要获取最小值就要重新遍历一遍 显然，这里我们选择空间换时间的做法，定义两个栈存储，其中
oj2132 数据结构实验之栈与队列二：一般算术表达式转换成后缀式
qq_45666654的博客
05-09 265
数据结构实验之栈与队列二：一般算术表达式转换成后缀式 Description 对于一个基于二元运算符的算术表达式，转换为对应的后缀式，并输出之。 Input 输入一个算术表达式，以‘#’字符作为结束标志。 Output 输出该表达式转换所得到的后缀式。 Sample Input a*b+(c-d/e)*f# Output abcde/-f+ #include <stdio.h> #include <stdlib.h> int main() { int s[101];
栈队列OJ题分享及讲解
m0_69888254的博客
08-07 668
从今天开始后面的OJ题，我一致用C++来带大家实现，这需要大家先去了解C++STL里面的容器，以及相关的接口。 ## 1、有效的括号 ![在这里插入图片描述](https://img-blog.csdnimg.cn/24f0768e6bc348d7a19e9bb92750f371.png#pic_center) 这题是比较典型的用栈实现的题目，给了我们一个字符串s，让我们去判断里面的括号是否一一匹配。 **解题思路：** ```cpp class Solution { public: bool i
数据结构---详解单链表
weixin_63997543的博客
11-08 225
详解单链表
【新人系列】Python 入门（八）：数据结构 - 上
Newin2020的博客
11-08 906
创建列表使用 [ ] 直接创建列表其中，listname 表示变量名，element1 ~ elementn 表示列表元素。使用 list( ) 函数创建列表除了使用 [ ] 创建列表外，Python 还提供了一个内置的函数 list( )，使用它可以将其它数据类型转换为列表类型。# 将字符串转换成列表# 将元组转换成列表。
数据结构之——堆
m0_71974552的博客
11-08 441
堆可以被看作是一棵树的数组对象。在存储结构上，堆与普通树有一些区别。普通树的存储方式可以有多种，如链式存储、数组存储等。而堆通常采用数组来存储完全二叉树，这样可以利用数组的索引关系快速定位节点的父子关系。孩子兄弟表示法是一种表示树结构的方式。在这种表示法中，每个节点有两个指针，分别指向其第一个孩子节点和下一个兄弟节点。相比之下，堆采用数组存储时，通过特定的索引计算可以快速找到节点的父子关系。
python之数据结构与算法（数据结构篇）-- 队列
2301_81807150的博客
11-05 235
【代码】python之数据结构与算法（数据结构篇）-- 队列。
数据结构[2015]
mufengzhiyu666的博客
11-05 720
八、设有一组关键字{19,01,23,14,55,20,84,27,68,11,10,77},采用哈希函数：H(Key)=Key MOD 13采用开放地址法的二次探测再散列方法解决冲突，试在0～18的散列地址空间中对该关键字序列构造哈希表。七、给出一组关键字(12,2,16,30,28,10,16,20,6,18),分别写出按下列各种排序方法进行排序时的变化过程： (15分)十二、有数组A[4][4],把1到16个整数分别按顺序放入A[0][0],…,A[0][3],A[1][0],…
数据结构OJ题
最新发布
2401_88035751的博客
11-08 508
left指向的时数组当前的位置，在它之前的数据都是有效的，因为下表是从0开始，所以数据个数就是最后一个数据的下表加一，推理得left值就是有效数据个数。注意这里得题目要求，它的第一个数组的大小是第一个数组数据个数与第二个数组的数据个数之和，也就是它的大小可以刚好容纳两个数组的全部数据。---------------------------------------------------分割符。1.定义两个变量left与right，一个指向下表0的位置，一个指向下表1的位置。
数据结构：直接插入排序
versatile_zpc的博客
11-07 173
创建一个end变量让其指向数组中下标为0的元素，也就是第一个元素，再让tmp被赋值为指end+1下标的元素，也就是第二个元素，然后进入while循环，如果tmp < arr[end]，就让end指向的元素走向end+1处，将其覆盖，并且end--，持续遍历，如果end越界了（end<0）,直接跳出，将tmp覆盖掉end+1指向的下标元素，也就是下标为0的元素处。我们将每一张新摸到的牌都插入到自己的牌里，使其形成从大到小的排列。下面我们用代码来实现一下，不同的是将一个乱序的数组排列成一个有序的。
9 ＞ 数据结构与算法 排序
qq_55902573的博客
11-08 674
数据结构 多种排序算法
C语言实现数据结构之堆
0xFFFFFFFF
11-08 882
在这篇文章，我们使用C语言实现了一个物理存储结构为动态顺序表，逻辑结构为二叉树的堆，并实现了堆排序——一种比较快的排序
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值