AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

万字精讲——数据结构栈与队列必会OJ练习

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

在之前的博客中，我们学习了栈与队列的基本内容，并且实现了栈与队列。今天我们进行刷题训练，走进栈与队列的世界中去感受一番！！！

括号匹配问题

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

3d54fab2e6cb434a8bcc664b388b2ba5.png

OJ链接 【leetcode 20.有效的括号】


这道题我们先做分析：满足的三大条件总结：类型匹配、顺序匹配、数量匹配。要满足这三个条件才可以返回true，反之则返回false。


最左边的括号要与最右边的括号进行匹配，这里我们就可以使用栈先进后出的特性来完成。当我们遇到一个左括号时，让其进栈进行储存。反之遇到右括号时，让栈中元素进行出栈进行匹配。  

cbd9bc24e49d47dab21ebbcd5e477cc7.png

e6c86d918d1448e5844d58cac1c00734.png

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef char STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;
void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);
STDataType STTop(ST* ps);
void STInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->capacity = 0;
  ps->top = 0;
}
void STDestroy(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->top = ps->capacity = 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 = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
    if (tmp == NULL)
    {
      perror("realloc");
      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;
}
int STSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
bool STEmpty(ST* ps)
{
  assert(ps);
  return ps->top == 0;
}
STDataType STTop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  return ps->a[ps->top - 1];
}
bool isValid(char * s){
    ST st;
    STInit(&st);
    char topval;
    while(*s)
    {
        if(*s == '('||*s == '['||*s == '{')
        {
           STPush(&st,  *s);
        }
        else
        {
            if(STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }
            topval = STTop(&st);
            STPop(&st);
            if((*s == ']' && topval != '[')
            || (*s == ')' && topval != '(')
            || (*s == '}' && topval != '{'))
            {
              STDestroy(&st);
              return false;
            }
        }
        s++;
    }
    bool ret = STEmpty(&st);
    STDestroy(&st);
    return ret;
}

leetcode这道题中，对C语言非常不友好，如果想使用栈数据结构就必须自己写接口，我们可以使用博主之前博客中实现栈的接口复制粘贴上即可完成。


bool ret = STEmpty(&st);
    STDestroy(&st);
    return ret;


最后三句代码，是为了验证括号数量匹配的问题，如果循环完成后栈中还有括号元素，证明示例中左右括号不匹配数量有问题，必须返回false。

使用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。


实现 MyStack 类：


  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。


注意：

  • 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

c8826b3c461b48238aad3ae2c111fc9d.png

OJ链接 【leetcode255.用队列实现栈】

分析：

edd611aade2d42f98cc4b467cea707e5.png

错误想法：假设第一个队列中有四个数据1、2、3、4，队列的特点是先进先出。我们一般的想法为把内容反转一下，再先进先出即可。但是这个想法是错误的，当我们反转后取出4后假设再push加入5和6两个数据。前面的数据会如同栈一样后进先出，但是到5和6时又会成为队列出5和6。所以这个方法是不可行的。


正确想法：

36311b2de45f473cae949a9898a16337.png

当我们如果pop释放完4后继续想再次push录入数据，我们应该录入到哪里？

我们应该录入到不为空的队列中，然后继续进行上面的操作即可完成使用队列实现栈的特性

3324763c90614b08825a7b64184746a4.png

总结：不为空的队列进行存入数据，为空的队列进行导入数据！！！

实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
  struct QueueNode* next;
  QDataType data;
}QNode;
typedef struct Queue
{
  QNode* head;
  QNode* tail;
  int size;
}Que;
void QueueInit(Que* pq);
void QueueDestroy(Que* pq);
void QueuePush(Que* pq, QDataType x);
void QueuePop(Que* pq);
QDataType QueueFront(Que* pq);
QDataType QueueBack(Que* pq);
bool QueueEmpty(Que* pq);
int QueueSize(Que* pq);
void QueueInit(Que* pq)
{
  pq->head = pq->tail = NULL;
  pq->size = 0;
}
void QueueDestroy(Que* 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;
}
int QueueSize(Que* pq)
{
  assert(pq);
  return pq->size;
}
void QueuePush(Que* pq, QDataType x)
{
  assert(pq);
  QNode* newnode = (QNode*)malloc(sizeof(QNode));
  if (newnode == NULL)
  {
    perror("malloc");
    exit(-1);
  }
  newnode->data = x;
  newnode->next = NULL;
  if (pq->tail == NULL)
  {
    pq->head = pq->tail = newnode;
  }
  else
  {
    pq->tail->next = newnode;
    pq->tail = newnode;
  }
  pq->size++;
}
void QueuePop(Que* pq)
{
  assert(pq);
  assert(!QueueEmpty(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 QueueFront(Que* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  return pq->head->data;
}
QDataType QueueBack(Que* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  return pq->tail->data;
}
bool QueueEmpty(Que* pq)
{
  assert(pq);
  return pq->tail == NULL;
}
typedef struct {
    Que q1;
    Que q2;
} MyStack;
MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}
void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}
int myStackPop(MyStack* obj) {
    Que* empty = &obj->q1;
    Que* noempty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        noempty = &obj->q1;
        empty = &obj->q2;
    }
    //前size-1个空队列
    while(QueueSize(noempty)>1)
    {
        QueuePush(empty,QueueFront(noempty));
        QueuePop(noempty);
    }
    int top = QueueFront(noempty);
    QueuePop(noempty);
    return top;
}
int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
      return QueueBack(&obj->q1);
    }
    else
    {
      return QueueBack(&obj->q2);
    }
}
bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&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);
*/

这道题C语言也没有任何链表接口，我们得去写完整。但是这些类型的题目都是低耦合的，只要接口不变，内容怎么改变都无所谓，我们继续复制粘贴队列的实现。

但是这这题需要两个队列，所以嵌套关系比较复杂，下面提供一张关系图片进行参考：

78972565f5d34b199d57dc525f41c5aa.png

用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（、、、）：

pushpoppeekempty

实现 类：MyQueue

  • void push(int x)将元素 x 推到队列的末尾
  • int pop()从队列的开头移除并返回元素
  • int peek()返回队列开头的元素
  • boolean empty()如果队列为空，返回 ；否则，返回truefalse


说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 , , , 和  操作是合法的。push to toppeek/pop from topsizeis empty
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

474dd03934f54a589043988f8af4a205.png

OJ链接【leetcode232.用栈实现队列】

分析：用两个栈实现队列先进先出的特点。

与用队列实现栈相似，但有所不同的是将push添加的数据从一个栈中转入另一个栈（遵循后进先出原则）就成为逆序，所以当想要pop时，只需将存入数据的栈中元素转入到空栈中去，进行依次释放即可。

当未释放完却想要继续pop添加元素时，我们添加到最开始增加元素的栈中去等待另一个栈中元素全部pop完后继续进行上述方法，将添加新元素的栈中元素按照栈先进后出原则转入另一个栈进行释放即可。

4923e593799f4d3ea3a465d593791712.png

总结：将两个栈分别看作pushst（添加栈）popst（释放栈）。如果想要添加元素就放入pushst中去，想要释放元素先要将pushst中的元素放入popst中去，再进行释放。


注意：如果中途有push添加元素，只有将popst中的元素释放为空后才可以继续从pushst中给予元素给popst继续释放！！！

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;
void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);
STDataType STTop(ST* ps);
void STInit(ST* ps)
{
  assert(ps);
  ps->a = NULL;
  ps->capacity = 0;
  ps->top = 0;
}
void STDestroy(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->a = NULL;
  ps->top = ps->capacity = 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 = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
    if (tmp == NULL)
    {
      perror("realloc");
      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;
}
int STSize(ST* ps)
{
  assert(ps);
  return ps->top;
}
bool STEmpty(ST* ps)
{
  assert(ps);
  return ps->top == 0;
}
STDataType STTop(ST* ps)
{
  assert(ps);
  assert(ps->top > 0);
  return ps->a[ps->top - 1];
}
typedef struct {
    ST pushst;
    ST popst;
} MyQueue;
MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->pushst);
     STInit(&obj->popst);
     return obj;
}
void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->pushst, x);
}
int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst, STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}
int myQueuePop(MyQueue* obj) {
    int front = myQueuePeek(obj);
    STPop(&obj->popst);
    return front;
}
bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->pushst) && STEmpty(&obj->popst);
}
void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);
    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);
*/

此题依旧没有接口，需要我们自己添加完成，但是相同的方法我们就不再过多强调，题不是很难，但是层层嵌套还是比较绕的。

设计循环队列

设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为"环形缓冲器"。


循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。


你的实现应该支持如下操作：

  • MyCircularQueue(k)： 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

8f44ea0f26884092afaa49df1ec84eff.png

提示：

  • 所有的值都在 0 至 1000 的范围内；
  • 操作数将在 1 至 1000 的范围内；
  • 请不要使用内置的队列库。


OJ链表【leetcode 622.设计循环队列】

39bb54f848b24fb78b1f33157a2d8d76.png

那我们用数组还是用链表来实现循环队列好呢？


无论使用链表还是数组，当内容为空时两个指针指向的位置都在最开始，而每增加一个数据Rear都往后走一个位置（Rear指向的是最后一个内容的下一个节点处），所以当我们取对尾数据时，假设使用链表就非常的不好寻找（除非使用双向链表或者别的方法进行标记），但是数组却非常好寻找队尾的元素内容。所以我们使用数组来实现循环列表。（但是链表非常好进行循环找头）各有利弊！！！

491af5c9dc814ff58317eff3246663b3.png

第二个问题：当循环队列为空和全满时，Rear指针与Front指针全部指向同一个位置，我们应该如何区分？

解法一：我们可以设置一个size来记录数据个数。

解法二：我们可以在设置数组大小时多开一个空间不去使用 front == Rear 就是空，Rear的下一个为Front即为满。

3d776d8fdb084e93a90fb0450cb6b833.png

使用数组时，我们需要注意当rear指向最后一个时，在循环队列前面还有空余的情况下，如何让rear指针回到最初呢？


方法一：我们可以使用if判断，如果rear指向最后时，我们可以让其直接等于0.


方法二：比较巧妙，我们可以用 obj->rear %= (obj->k+1);进行操作。


同理front方法一样。

typedef struct {
    int* a;
    int front;
    int rear;
    int k;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->front = obj->rear = 0;
    obj->k = k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->rear;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear + 1) % (obj->k + 1) == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear] = value;
    obj->rear++;
    obj->rear %= (obj->k+1);
    return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    obj->front %= (obj->k+1);
    return true;
}
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->front];
    }
}
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        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);
*/

在函数myCircularQueueRear中，我们需要得到rear前一个的数组内容。一般情况都非常好表示，但有一种情况需要我们取斟酌。

c7ba66d4838c492fb2692b02804829cf.png

当rear已经指向第一个时，怎样才能返回元素4呢？


方法一：当rear为0时，我们直接可以让其返回k下标的内容。（比较低级）


方法二： return obj->a[(obj->rear + obj->k) % (obj->k + 1)];我们可以使用算数巧妙地表示最后末尾地元素。


这道题的特殊情况比较多情况比较复杂，写代码时我们应该将问题考虑周全！！！

以上是本次OJ题目分享全部内容，感谢大家观看，一键三连是对博主最大的支持！！！谢谢❤️

文章标签：
C语言
存储
关键词：
数据结构栈
数据结构队列
数据结构栈队列
数据结构oj
数据结构栈与队列
W...Y
目录
相关文章
ephemerals__
|
16天前
|
C语言
【数据结构】栈和队列（c语言实现）（附源码）
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表，遵循“先进后出”原则；队列则在一端插入、另一端删除，遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现，并提供了完整的代码示例。栈和队列在实际应用中非常广泛，如二叉树的层序遍历和快速排序的非递归实现等。
ephemerals__
91 9
那年春天
|
7天前
|
存储 算法
非递归实现后序遍历时，如何避免栈溢出？
后序遍历的递归实现和非递归实现各有优缺点，在实际应用中需要根据具体的问题需求、二叉树的特点以及性能和空间的限制等因素来选择合适的实现方式。
那年春天
16 1
德国都芳最好
|
10天前
|
存储 算法 Java
数据结构的栈
栈作为一种简单而高效的数据结构，在计算机科学和软件开发中有着广泛的应用。通过合理地使用栈，可以有效地解决许多与数据存储和操作相关的问题。
德国都芳最好
50 21
html的七十二变
|
13天前
|
存储 JavaScript 前端开发
执行上下文和执行栈
执行上下文是JavaScript运行代码时的环境，每个执行上下文都有自己的变量对象、作用域链和this值。执行栈用于管理函数调用，每当调用一个函数，就会在栈中添加一个新的执行上下文。
html的七十二变
27 2
dufadayang
|
15天前
|
存储
系统调用处理程序在内核栈中保存了哪些上下文信息？
【10月更文挑战第29天】系统调用处理程序在内核栈中保存的这些上下文信息对于保证系统调用的正确执行和用户程序的正常恢复至关重要。通过准确地保存和恢复这些信息，操作系统能够实现用户模式和内核模式之间的无缝切换，为用户程序提供稳定、可靠的系统服务。
dufadayang
42 4
肾透侧视攻城狮
|
19天前
|
算法 安全 NoSQL
2024重生之回溯数据结构与算法系列学习之栈和队列精题汇总（10）【无论是王道考研人还是IKUN都能包会的；不然别给我家鸽鸽丢脸好嘛？】
数据结构王道第3章之IKUN和I原达人之数据结构与算法系列学习栈与队列精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子；这都学不会；能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛？！！！
肾透侧视攻城狮
17 1
java冯坚持
|
1月前
|
算法 程序员 索引
数据结构与算法学习七：栈、数组模拟栈、单链表模拟栈、栈应用实例 实现 综合计算器
栈的基本概念、应用场景以及如何使用数组和单链表模拟栈，并展示了如何利用栈和中缀表达式实现一个综合计算器。
java冯坚持
30 1
数据结构与算法学习七：栈、数组模拟栈、单链表模拟栈、栈应用实例 实现 综合计算器
禁默
|
1月前
初步认识栈和队列
初步认识栈和队列
禁默
59 10
星霜旅人
|
1月前
数据结构（栈与列队）
数据结构（栈与列队）
星霜旅人
17 1
java冯坚持
|
1月前
|
算法
数据结构与算法二：栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式
这篇文章讲解了栈的基本概念及其应用，并详细介绍了中缀表达式转换为后缀表达式的算法和实现步骤。
java冯坚持
46 3

热门文章

最新文章

  • 1
    【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
  • 2
    数据结构学习笔记【持续更新】
  • 3
    我花了一夜用数据结构给女朋友写个H5走迷宫游戏
  • 4
    基于OHCI的USB主机 —— OHCI（自定义数据结构）
  • 5
    【数据结构7】查找
  • 6
    算法导论第十四章 数据结构的扩张
  • 7
    学数据结构，只需要基本的编程体验
  • 8
    数据结构（2）：栈的原理和实现
  • 9
    R语言学习笔记（一）数据结构
  • 10
    基于OHCI的USB主机 —— UFI数据结构2
  • 1
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    98
  • 2
    数据结构（五）----特殊矩阵的压缩存储
    243
  • 3
    数据结构（九）---并查集
    72
  • 4
    【数据结构与算法 11，高并发系统基础篇
    41
  • 5
    JavaScript 中实现常见数据结构：栈、队列与树
    78
  • 6
    数据结构链表详解(不仅顺序表可以，我链表也可以)
    41
  • 7
    顺序表的实现（迈入数据结构的大门）（2）
    39
  • 8
    顺序表的实现（迈入数据结构的大门）（1）
    32
  • 9
    每个程序员都必须掌握的8种数据结构，retrofit教程
    35
  • 10
    scala中常见数据结构的用法
    45

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • 天池leetcode编程基础课
  • Python网络爬虫实战

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 超全算法笔试-模拟题精解合集
    • 下一篇
    阿里云OSS设置跨域访问