备案控制台
探索云世界
开发者社区 云计算 文章 正文

数据结构--栈和队列

2024-03-15 34
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 数据结构--栈和队列


栈的概念和结构

栈是一种常见的数据结构，它遵循后进先出LIFO（Last In First Out）的原则。进行数据插入和操作的一端称为栈顶，另一端称为栈底。

压栈：栈的插入操作被称为压栈/进栈/入栈，入数据在栈顶。

出栈：栈的删除操作。出数据也在栈顶；

栈的实现

栈可以用数组或者是链表来实现；这里将使用数组来实现，因为数组在插入删除时消耗代价较小；对于链表，由于Top放在尾，删除时还需要由头指针循环遍历找到尾结点前一个；

栈的数据结构

typedef int STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;

a为存储数据的数组，top表示栈顶，capacity表示当前数组的存储容量；

栈的初始化和销毁

void STInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->top = 0;
  ps->capacity = 0;
}
void STDestory(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->capacity = 0;
  ps->top = 0;
}

assert（ps）验证的是传过来的地址，地址为NULL那就无法进行操作；

free完ps->a记得置空；

出栈和入栈

void STPush(ST* ps, STDataType x)
{
  assert(ps);
  //满扩容
  if (ps->top == ps->capacity)
  {
    int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newcapacity);
    if (tmp == NULL)
    {
      perror("Stack fail");
      exit(-1);
    }
    ps->a =tmp;
    ps->capacity = newcapacity;
  }
  ps->a[ps->top] = x;
  ps->top++;
}
void STPop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  ps->top--;
}

这里的Top是放在最后一位元素之后的；

当出栈时，不用管那个位置的内容和空间是否被删除，当下次入栈到这个位置，内容会被顶替；而如果用free掉这一块空间，会造成只释放部分空间的错误；

获取栈顶、大小，判空

STDataType STTop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
bool STEmpty(ST* ps)
{
  assert(ps);
  return ps->top==0;
}

对于数据结构来说，即使是简单的操作也要用函数进行封装；这样做的原因能够找出一些错误的操作，能够方便别人的操作；

例如你在主函数创建的栈为空，然后给到别人使用，别人不知道栈为空，别人没有用函数判断栈的大小，出来的栈的大小无法辨别是对的还是错误的；而创建函数就能够避免一些极端问题；

接下来我们简单的验证一下：

void Test1()
{
  ST st;
  STInit(&st);
  STPush(&st, 1);
  STPush(&st, 2);
  STPush(&st, 3);
  STPush(&st, 4);
  
  while (!STEmpty(&st))
  {
    printf("%d ", STTop(&st));
    STPop(&st);
  }
  printf("\n");
  STDestory(&st);
}
int main()
{
  Test1();
  return 0;
}

队列的概念和结构

队列只允许在一端进行插入操作，在另一端删除数据操作的特殊线性表，具有先进先出FIFO(First In First Out) ；

入队列：在队尾进行插入的操作

出队列：在队头进行删除的操作

队列的实现

队列的实现可以用数组和链表来实现；这里将使用链表来实现；因为如果使用数组的结构，在数组头进行删除出数据，效率比较低；

队列的数据结构

typedef int QDataType;
typedef struct QueneNode
{
  struct QueneNode* next;
  QDataType data;
}QNode;
typedef struct Quene
{
  QNode* head;
  QNode* tail;
  int size;
}Quene;

这里先用一个结构体将一个结点的类型进行封装；然后再用一个结构体进行队列的封装；因为这里我们将会使用队头和队尾，如果使用这两个进行传参，将会用到二级指针，比较麻烦，所以就使用一个结构体进行封装，用结构体进行传参，用到队头和队尾只需调用结构体的成员；

队列的初始化和销毁

void QueneInit(Quene* pq)
{
  assert(pq);
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QueneDestory(Quene* pq)
{
  assert(pq);
  QNode* cur = pq ->head;
  while (cur)
  {
    QNode* next = cur->next;
    free(cur);
    cur = next;
  }
  pq->head = pq->tail = NULL;
  pq->size = 0;
}

初始化将head和tail都置空；size统计多少个结点；

销毁用循环遍历逐渐将结点释放；最后将指针置空；

队列的插入

void QuenePush(Quene* pq, QDataType x)
{
  assert(pq);
  //扩容
  QNode* newnode = (QNode*)malloc(sizeof(QNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  newnode->data = x;
  newnode->next = NULL;
  //第一个插入
  if (pq->head == NULL)
  {
    pq->head = pq->tail = newnode;
  }
  else
  {
    pq->tail->next = newnode;
    pq->tail = newnode;
  }
  pq->size++;
}

首先是每插入一次就扩容一个结点；接着是判断是否为第一个结点的插入，如果是需要将head和tail都等于新节点；最后将size加加；

队列的删除

void QuenePop(Quene* pq)
{
  assert(pq);
  //判断是否没有数据
  assert(!QueneEmpty(pq));
  QNode* next = pq->head->next;
  //只有一个数据
  if (pq->head->next == NULL)
  {
    free(pq->head);
    pq->head = pq->tail = next;
  }
  else
  {
    free(pq->head);
    pq->head = next;
  }
  pq->size--;
}

我们需要判断有没有结点可以删除；然后记住头结点的下一个结点，删除头结点后将头结点指针等于下一个结点；如果只有一个结点可以删除，那么还要将tail置空；

获取队头和队尾的数据

QDataType QueneFront(Quene* pq)
{
  assert(pq);
  assert(!QueneEmpty(pq));
  return pq->head->data;
}
QDataType QueneBack(Quene* pq)
{
  assert(pq);
  assert(!QueneEmpty(pq));
  return pq->tail->data;
}

获取队列长度和判空

int QueneSize(Quene* pq)
{
  assert(pq);
  return pq->size;
}
bool QueneEmpty(Quene* pq)
{
  assert(pq);
  return pq->head == NULL;
}

最后做一下简单的验证

void Test1()
{
  Quene q;
  QueneInit(&q);
  QuenePush(&q, 1);
  QuenePush(&q, 2);
  QuenePush(&q, 3);
  QuenePop(&q);
  while (QueneSize(&q)>0)
  {
    printf("%d ", QueneBack(&q));
    QuenePop(&q);
  }
  QueneDestory(&q);
}
int main()
{
  Test1();
  return 0;
}

栈和队列的一些题目

1.有效的括号

思路：这道题可以采用栈这种结构来解决问题，满足后进先出的原理；

我们可以这么做，分为左括号和右括号；遇到左括号就放入栈中，一旦遇到右括号，我们可以将栈顶取出，进行判断；这是我们的大体思路；

这道题我们还需要考虑一些极端情况：

第一种：字符串中只有右括号或者说一开始就是右括号，那么这种就相当于栈为空；当遇到右括号时，需要先进行判断；

第二种：字符串只有左括号，那么表明栈中的元素没有进行匹配出栈，栈不为空；

所以把特殊情况弄好后，就可以进行操作了，我们可以把我们写的栈结构复制到程序中，然后创建一个栈来进行操作；最后记得释放空间，避免内存泄漏；

代码：

#define  _CRT_SECURE_NO_WARNINGS 1
typedef char STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;
void STInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->top = 0;
  ps->capacity = 0;
}
void STDestory(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->capacity = 0;
  ps->top = 0;
}
void STPush(ST* ps, STDataType x)
{
  assert(ps);
  if (ps->top == ps->capacity)
  {
    int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newcapacity);
    if (tmp == NULL)
    {
      perror("Stack fail");
      exit(-1);
    }
    ps->a =tmp;
    ps->capacity = newcapacity;
  }
  ps->a[ps->top] = x;
  ps->top++;
}
void STPop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  ps->top--;
}
STDataType STTop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
bool STEmpty(ST* ps)
{
  assert(ps);
  return ps->top==0;
}
bool isValid(char * s){
    ST st;
    //栈初始化
    STInit(&st);
    while(*s)
    {
        //左括号就入栈
        if(*s=='('||*s=='['||*s=='{')
        {
            STPush(&st,*s);
        }
        //右括号就出栈，判断
        else
        {
            栈空，表明没有左括号
            if(STEmpty(&st))
            {
                STDestory(&st);
                    return false;
            }
            char val=STTop(&st);
            STPop(&st);
            //不符合
            if((*s==')'&&val!='(')
            ||(*s==']'&&val!='[')
            ||(*s=='}'&&val!='{'))
            {
                return false;
            }
               
        }
        s++;
    }
    if(!STEmpty(&st))
    {
        return false;
    }
    STDestory(&st);
    return true;
}

2.用队列实现栈

思路：我们可以在纸上模拟一下入栈和出栈的操作；

由于入栈的时候和队列的性质一样，都在尾插入，所以不需要执行什么操作；出栈时，总需要进行转移，才能删除最后一个元素；那么可以先判断那个队列空与不为空，然后将不为空的进行转移到空的队列；那么就可以完成出栈；同时，由于这样的操作，入栈时如果有一个队列不为空需要将元素插入不为空的后面，方便出栈的操作；

代码：

#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueneNode
{
  struct QueneNode* next;
  QDataType data;
}QNode;
typedef struct Quene
{
  QNode* head;
  QNode* tail;
  int size;
}Quene;
void QueneInit(Quene* pq)
{
  assert(pq);
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QueneDestory(Quene* pq)
{
  assert(pq);
  QNode* cur = pq ->head;
  while (cur)
  {
    QNode* next = cur->next;
    free(cur);
    cur = next;
  }
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QuenePush(Quene* pq, QDataType x)
{
  assert(pq);
  //扩容
  QNode* newnode = (QNode*)malloc(sizeof(QNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    exit(-1);
  }
  newnode->data = x;
  newnode->next = NULL;
  //第一个插入
  if (pq->head == NULL)
  {
    pq->head = pq->tail = newnode;
  }
  else
  {
    pq->tail->next = newnode;
    pq->tail = newnode;
  }
  pq->size++;
}
bool QueneEmpty(Quene* pq)
{
  assert(pq);
  return pq->head==NULL;
}
int QueneSize(Quene* pq)
{
  assert(pq);
  return pq->size;
}
void QuenePop(Quene* pq)
{
  assert(pq);
  //判断是否没有数据
  assert(!QueneEmpty(pq));
  
  
  //只有一个数据
  if (pq->head->next == NULL)
  {
    free(pq->head);
    pq->head = pq->tail = NULL;
  }
  else
  {
      QNode* next = pq->head->next;
    free(pq->head);
    pq->head = next;
  }
  pq->size--;
}
QDataType QueneFront(Quene* pq)
{
  assert(pq);
  assert(!QueneEmpty(pq));
    return pq->head->data;
}
QDataType QueneBack(Quene* pq)
{
  assert(pq);
  assert(!QueneEmpty(pq));
  return pq->tail->data;
}
typedef struct {
    Quene q1;
    Quene q2;
} MyStack;
//创建一个自己的栈
//用一个结构体进行包装
MyStack* myStackCreate() {
    MyStack* obj=malloc(sizeof(MyStack));
    QueneInit(&obj->q1);
    QueneInit(&obj->q2);
    return obj;
}
//插入判断哪个队列不为空
void myStackPush(MyStack* obj, int x) {
    if(!QueneEmpty(&obj->q2))
    {
        QuenePush(&obj->q2,x);
    }
    else
    {
        QuenePush(&obj->q1,x);
    }
}
//将队列分为空队列和不空队列
int myStackPop(MyStack* obj) {
    Quene* empty=&obj->q1;
    Quene* nonempty=&obj->q2;
    if(!QueneEmpty(&obj->q1))
    {
         empty=&obj->q2;
         nonempty=&obj->q1;
    }
  //数据转移
    while(QueneSize(nonempty)>1)
    {
        QuenePush(empty,QueneFront(nonempty));
        QuenePop(nonempty);
    }
   //删除数据，并返回
    int Top=QueneFront(nonempty);
    QuenePop(nonempty);
    return Top;
}
int myStackTop(MyStack* obj) {
    if(!QueneEmpty(&obj->q2))
    {
        return QueneBack(&obj->q2);
    }
    else
    {
        return QueneBack(&obj->q1);
    }
}
bool myStackEmpty(MyStack* obj) {
    return QueneEmpty(&obj->q1)&&QueneEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) {
    QueneDestory(&obj->q1);
    QueneDestory(&obj->q2);
    free(obj);
}
/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

3.用栈实现队列

思路：一样的我们先在纸上模拟

如果再继续删除，那么可以删除到栈2为空，然后就将栈1的内容全部转移到栈2；如果栈2没空，再插入栈1会发现没有任何影响；

所以我们总结得出：将栈1表示为插入的栈，栈2表示为删除的栈，如果要删除栈2为空就将栈1的内容转移到栈2；

代码：

typedef int STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;
void STInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->top = 0;
  ps->capacity = 0;
}
void STDestory(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->capacity = 0;
  ps->top = 0;
}
void STPush(ST* ps, STDataType x)
{
  assert(ps);
  if (ps->top == ps->capacity)
  {
    int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newcapacity);
    if (tmp == NULL)
    {
      perror("Stack fail");
      exit(-1);
    }
    ps->a =tmp;
    ps->capacity = newcapacity;
  }
  ps->a[ps->top] = x;
  ps->top++;
}
void STPop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  ps->top--;
}
STDataType STTop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
bool STEmpty(ST* ps)
{
  assert(ps);
  return ps->top==0;
}
//栈分为插入栈和输出栈
typedef struct {
    ST instack;
    ST outstack;
} MyQueue;
MyQueue* myQueueCreate() {
    MyQueue* obj=malloc(sizeof(MyQueue));
    STInit(&obj->instack);
    STInit(&obj->outstack);
    return obj;
}
void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->instack,x);
}
int myQueuePop(MyQueue* obj) {
  //先判断输出栈是否为空
    if(STEmpty(&obj->outstack))
    {
        while(STSize(&obj->instack))
        {
            STPush(&obj->outstack,STTop(&obj->instack));
            STPop(&obj->instack);
        }
    }
    int head=STTop(&obj->outstack);
    STPop(&obj->outstack);
    return head;
}
int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->outstack))
    {
        while(STSize(&obj->instack))
        {
            STPush(&obj->outstack,STTop(&obj->instack));
            STPop(&obj->instack);
        }
    }
    return STTop(&obj->outstack);
}
bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->instack)&&STEmpty(&obj->outstack);
}
void myQueueFree(MyQueue* obj) {
    STDestory(&obj->instack);
    STDestory(&obj->outstack);
    free(obj);
}
/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

4.设计循环队列

我们先根据题意确定我们将选择数组来存储（固定长度）；然后考虑怎么让这个数组能够循环着走？我们可以设置两个指针来判断（由于是数组，可以利用下标来进行代表指针），分别为头和尾；假设队列长度为k，一开始，头和尾下标都为0，表示这个队列为空；

那么当插入一个元素后尾向后走一步

删除一个元素头向后走一步，

当数组填满后，会发现头尾又重叠在一起，与一开始队列为空情况是一样的，这样就无法判断空与满了；

所以我们可以再增加一个多出来的空间

当尾走到最后一个多出来的空间时就表示满；

循环的尾走到最后时我们用取模来进行返回到下标为0的位置；这样子就能完成我们循环的目的。

代码：

typedef struct {
    int* a;
    int head;
    int rear;
    int k;
    
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=malloc(sizeof(MyCircularQueue));
    obj->a=malloc(sizeof(int)*(k+1));
    obj->head=obj->rear=0;
    obj->k=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head==obj->rear;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //当rear超过k+1时，归0
    return (obj->rear+1)%(obj->k+1)==obj->head;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear]=value;
    obj->rear++;
    //限制在0-k
    obj->rear%=(obj->k+1);
    return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->head++;
    //限制在0-k
    obj->head%=(obj->k+1);
    return true;
}
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->head];
}
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    //考虑rear-1等于-1的情况
    return obj->a[(obj->rear+obj->k)%(obj->k+1)];
}
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}
/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

这里需要注意的就是取模的问题，需要记住尾和头是不断增加的，是由于取模k+1才限制在0-k的下标中；

第一个就是在删除和插入数据的时候，当头尾超出范围时，需要进行取模k+1的操作，返回到第一个元素；

第二个是判断满时，尾+1相当于返回到头，当尾刚好处于最后下标时，需要进行取模；

最后一个是取尾的问题，当尾刚好处于第一个下标时，由于尾需要进行-1的操作才能得到尾元素，所欲在第一个下标-1会导致下标变为-1，所以可以多加一轮K+1进行取模的操作避免这个问题；

文章标签：
存储
关键词：
数据结构队列
数据结构栈
数据结构栈和队列
数据结构栈队列
诡异森林。
目录
相关文章
Kevin_17
|
19天前
|
消息中间件 存储 搜索推荐
深入理解栈和队列（二）：队列
深入理解栈和队列（二）：队列
Kevin_17
33 0
阿森要自信
|
20天前
|
存储 算法 索引
【算法与数据结构】队列的实现详解
【算法与数据结构】队列的实现详解
阿森要自信
41 0
shark-chili
|
1天前
|
算法 索引
数据结构与算法-三种队列基础入门
数据结构与算法-三种队列基础入门
shark-chili
5 0
yma16
|
2天前
|
C语言
数据结构中顺序栈的进栈和出栈用C语言表示
数据结构中顺序栈的进栈和出栈用C语言表示
yma16
11 1
时雨h
|
12天前
|
存储 算法 调度
数据结构期末复习（3）栈和队列
数据结构期末复习（3）栈和队列
时雨h
18 0
阿森要自信
|
23天前
|
算法 C语言
【算法与数据结构】 C语言实现单链表队列详解2
【算法与数据结构】 C语言实现单链表队列详解
阿森要自信
12 1
阿森要自信
|
23天前
|
存储 算法 C语言
【算法与数据结构】 C语言实现单链表队列详解1
【算法与数据结构】 C语言实现单链表队列详解
阿森要自信
22 0
阿森要自信
|
24天前
|
存储 缓存 算法
【算法与数据结构】栈的实现详解
【算法与数据结构】栈的实现详解
阿森要自信
19 0
游客i66wb7w7cg4tk
|
24天前
|
存储 算法 编译器
【数据结构】栈算法（算法原理+源码）
【数据结构】栈算法（算法原理+源码）
游客i66wb7w7cg4tk
14 0
【数据结构】栈算法（算法原理+源码）
修修修也
|
28天前
|
存储
【数据结构】什么是栈?
【数据结构】什么是栈?
修修修也
28 0
【数据结构】什么是栈?

热门文章

最新文章

  • 1
    数据结构期末复习（fengkao课堂）
  • 2
    【C/C++ 数据结构 】从零开始实现哈希表：C++实践指南
  • 3
    Java数据结构与算法-java数据结构与算法（二）
  • 4
    【数据结构】【版本2.0】【树形深渊】——二叉树入侵
  • 5
    【C/C++ 数据结构 树】探索C/C++中的二叉树：从理论到实践
  • 6
    【C/C++ 数据结构 线性表】深入理解与实现栈：从基础到应用的全面探索
  • 7
    数据结构-概念版（七）
  • 8
    Java数据结构与算法-java数据结构与算法（五）
  • 9
    【C/C++ 数据结构】深入探索数据结构中算法复杂度：从C++和数学的视角
  • 10
    python学习-函数模块，数据结构，字符串和列表（下）
  • 1
    【手撕数据结构】二分查找(好多细节)
    16
  • 2
    【数据结构与算法】—— 手撕红黑树
    37
  • 3
    【排序算法】数据结构排序详解
    42
  • 4
    【链式二叉树】数据结构链式二叉树的（万字详解）
    42
  • 5
    【堆】数据结构堆的实现（万字详解）
    52
  • 6
    【树和二叉树】数据结构二叉树和树的概念认识
    25
  • 7
    【双向链表】数据结构双向链表的实现
    21
  • 8
    数据结构——单链表的基本操作
    11
  • 9
    数据结构——排序算法之快速排序
    34
  • 10
    数据结构——二叉树的链式结构
    36

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 低代码开发师（初级）实战教程
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）