数据结构初阶之栈和队列(C语言版)


数据结构初阶之栈和队列(C语言版)

  • ✍栈
    • ♈栈的结构设计
    • ♈栈的各个接口的实现
      • StackInit(初始化)
      • push(入栈)
      • pop(出栈)
      • 获取栈顶元素
      • 获取栈中有效元素的个数
      • 判断栈是否为空
      • 销毁栈
  • ✍队列
    • 队列的结构的设计
    • 队列的各个接口实现
      • Init(初始化队列)
      • 队尾入队列
      • 队头出队列
      • 获取队列队头元素
      • 获取队列队尾元素
      • 判断队列是否为空
      • 获取队列的有效元素个数
      • 销毁队列
  • ✍OJ题之用两个队列实现栈
  • ✍OJ题之用两个栈实现队列
  • ⭕总结

✍栈

栈是数据结构的一种,一个栈可以用来对数据进行增删查改,但是它遵循一个原则,就是数据必须是后入先出,什么意思呢?就是先入栈的数据后出栈,后入栈的数据先出栈。我们可以使用链表和动态数组来实现栈。

我们使用动态数组来实现栈,为了实现后入先出,我们可以将栈看作只有尾插和尾删功能(也就是没有头插头删)的动态顺序表,其它都很相似。

♈栈的结构设计

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

各个接口:

// 初始化栈 
void StackInit(Stack* ps);

// 入栈 
void StackPush(Stack* ps, STDataType data);

// 出栈 
void StackPop(Stack* ps);

// 获取栈顶元素 
STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数 
int StackSize(Stack* ps);

// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
bool StackEmpty(Stack* ps);

// 销毁栈 
void StackDestroy(Stack* ps);

♈栈的各个接口的实现

这里我们使用动态增长的数组来实现栈尾插和尾删对应我们的入栈和出栈,利用链表实现也可以,但是动态数组操作起来更加简单,也不需要挪动数据,出栈更是只需要简单的_top--就可以完成,何乐而不为呢。

StackInit(初始化)

栈对象在主程序已经创建好了,传结构体指针可以修改结构体里面的成员,初始化栈只需要把动态数组、栈的元素个数、栈的空间大小初始化就可以了。

// 初始化栈 
void StackInit(Stack* ps)
{
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

push(入栈)

入栈其实就是动态顺序表里的尾插,如果小伙伴有疑惑,可以看数据结构初阶之顺序表(C语言实现)

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	
	if (ps->_top == ps->_capacity)//判断是否需要扩容
	{
		STDataType* tmp = ps->_capacity == 0 ? (STDataType*)realloc(ps->_a, sizeof(STDataType) * 4) : (STDataType*)realloc(ps->_a, sizeof(STDataType)* (ps->_capacity * 2));
		if (tmp == NULL)
		{
			perror("realloc Failed");
			exit(-1);
		}
		ps->_a = tmp;
		ps->_capacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
	}
	
	ps->_a[ps->_top++] = data;//尾插新的元素,_top++
}

上述代码用到了三目操作符,如果不知道这个操作符的话可能就看不懂代码,这里博主来简单的说一下。它的构成是这样的:

表达式1?语句1: 语句二;
如果表达式1成立则执行语句1,否则执行语句二。

pop(出栈)

出栈操作就更不用说了,由于入栈是尾插由于要满足栈后进先出的原则,我们直接把最后一个入栈的删除就可以了,等价于元素个数_top--

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	ps->_top--;
}

获取栈顶元素

栈的元素个数减一就是栈顶元素的下标位置,返回该下标位置的值就可以了。

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	
	return ps->_a[ps->_top-1];
}

获取栈中有效元素的个数

直接返回栈的元素个数。

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}

判断栈是否为空

直接看栈的元素个数是否为0,为空返回true,反之返回false。

// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0;
}

销毁栈

这里栈对象是在外面就创建了,不一定是动态开辟的,所以我们只释放栈里面动态数组的空间就可以。

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

✍队列

队列也是数据结构的一种,它和栈很像,区别就是队列数据必须是先进先出,什么意思呢?就是先入队列的数据先出队列,后入队列的数据后出队列。我们可以使用链表和动态数组来实现栈。

这里我们使用链表来实现队列,为了实现队列先入先出的功能,我们可以将我们实现的队列看成出数据只能头删、入数据只能尾插的单链表。

可能有小伙伴说,那我将最后面的数据视作队头,最前面的数据视作队尾,利用单链表的头插和尾删也可以实现队列呀,这也是可行的,只要保证先入先出的原则就可以,下面的图是两者的区别。

数据结构初阶之栈和队列(C语言版)_第1张图片

无论怎么样,要保证先入先出,队头始终是先进队列的。这里可能就有小伙伴突发奇想了,既然队列可以这样,栈可不可以把栈顶放在动态数组的左边去,使用头插和头删来维护栈呢?由于动态顺序表的头删和头插都需要挪动数据,时间开销太大,我们一般不这样做。

队列的结构的设计

typedef  int QDataType;//typedef重命名数据类型,下次改数据类型时改这个地方就可以了。
// 链式结构:表示队列 
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue;

队列和栈的区别就体现出来了:即出队列的是队头,最后入队列的会变成队尾。最后入栈的会变成栈顶,出栈的也是栈顶。

由于我们使用链表实现队列,出对队头对应头删,入队尾对应尾插,所以为了避免重复的遍历找队尾,我们干脆在设计队列结构的时候,定义尾节点和头节点,在入队列和出队列的时候不断维护。

这里使用链表实现队列会比使用动态数组实现队列更优,因为动态数组头删和头插都需要挪动数据。

各个接口:

// 初始化队列 
void QueueInit(Queue* q);

// 队尾入队列 
void QueuePush(Queue* q, QDataType data);

// 队头出队列 
void QueuePop(Queue* q);

// 获取队列头部元素 
QDataType QueueFront(Queue* q);

// 获取队列队尾元素 
QDataType QueueBack(Queue* q);

// 获取队列中有效元素个数 
int QueueSize(Queue* q);

// 检测队列是否为空,如果为空返回非零结果,如果非空返回0 
bool QueueEmpty(Queue* q);

// 销毁队列 
n'/void QueueDestroy(Queue* q);

队列的各个接口实现

队列用到了很多基础的链表的知识,如果你不太懂链表,请看这篇博客。

Init(初始化队列)

初始化,将头节点指针和尾节点置空就可以了。

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	
	q->_front = NULL;
	q->_rear = NULL;
}

队尾入队列

和单链表里的尾插的区别是,这里我们已经维护了尾节点,不用循环遍历去找尾节点了,没有数据的情况需要特殊判断一下。

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc Failed\n");
		exit(-1);
	}
	newnode->_data = data;
	newnode->_next = NULL;

	if (q->_rear == NULL)//没有节点的情况
	{
		q->_front = q->_rear = newnode;
	}
	else//一般情况
	{
		q->_rear->_next = newnode;
		q->_rear = newnode;
	}
}

队头出队列

等价于链表中的头删,但是需要特判一下只有一个数据的情况。

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->_front);
	
	QNode* new_front = q->_front->_next;
	free(q->_front);
	q->_front = new_front;
	if (q->_front == NULL)//特判一下一个节点的情况
		q->_rear = NULL;
}

获取队列队头元素

直接返回头节点的节点值。

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->_front);
	
	return q->_front->_data;
}

获取队列队尾元素

直接返回尾节点的节点值。

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->_rear);
	
	return q->_rear->_data;
}

判断队列是否为空

等价于判断头节点或者尾节点是否为空。

// 检测队列是否为空,如果为空返回非零结果,如果非空返回0 
bool QueueEmpty(Queue* q)
{
	assert(q);
	
	return q->_front == NULL;
}

获取队列的有效元素个数

循环遍历累加到临时变量中去,然后返回。

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	int size = 0;
	QNode* cur = q->_front;
	while (cur)
	{
		size++;
		cur = cur->_next;
	}
	return size;
}

注意:这里计算队列的大小不能使用指针减指针,因为链表每一个节点都是随机开的空间,而不是像动态数组一样连续的空间。

销毁队列

由于链表的节点的空间是一个一个开的,所以需要一个一个依次销毁,最后不要忘了将队列的两个指针置空。

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	assert(q->_front);//如果队列已经为空,就不用销毁了

	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;

下面我们用两道力扣上的简单题来熟悉一下栈和队列:

✍OJ题之用两个队列实现栈

数据结构初阶之栈和队列(C语言版)_第2张图片
这是题目链接
先贴C语言ak代码:

typedef  int QDataType;  // 定义队列中数据类型为整数

// 链式结构:表示队列节点
typedef struct QListNode {
    struct QListNode* _next;  // 指向下一个节点的指针
    QDataType _data;          // 节点存储的数据
} QNode;

// 队列的结构
typedef struct Queue {
    QNode* _front;  // 指向队列头部节点的指针
    QNode* _rear;   // 指向队列尾部节点的指针
} Queue;

// 初始化队列
void QueueInit(Queue* q) {
    assert(q);  // 确保指针不为空
    q->_front = NULL;  // 将队列头部指针置空
    q->_rear = NULL;   // 将队列尾部指针置空
}

// 队尾入队列
void QueuePush(Queue* q, QDataType data) {
    assert(q);  // 确保指针不为空

    // 创建新的节点并分配内存空间
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL) {
        perror("malloc Failed\n");
        exit(-1);
    }
    newnode->_data = data;  // 存储数据到新节点中
    newnode->_next = NULL;  // 新节点的下一个节点置空

    // 如果队列为空,则新节点即为队列的唯一节点
    if (q->_rear == NULL) {
        q->_front = q->_rear = newnode;
    } else {  // 否则将新节点接入队列尾部,并更新队列尾部指针
        q->_rear->_next = newnode;
        q->_rear = newnode;
    }
}

// 队头出队列
void QueuePop(Queue* q) {
    assert(q);        // 确保指针不为空
    assert(q->_front); // 确保队列不为空

    // 移动队列头部指针至下一个节点,并释放原头部节点的内存空间
    QNode* new_front = q->_front->_next;
    free(q->_front);
    q->_front = new_front;

    // 如果队列为空,则同时更新队列尾部指针为空
    if (q->_front == NULL)
        q->_rear = NULL;
}

// 获取队列头部元素
QDataType QueueFront(Queue* q) {
    assert(q);        // 确保指针不为空
    assert(q->_front); // 确保队列不为空
    return q->_front->_data;  // 返回队列头部节点存储的数据
}

// 获取队列队尾元素
QDataType QueueBack(Queue* q) {
    assert(q);        // 确保指针不为空
    assert(q->_rear); // 确保队列不为空
    return q->_rear->_data;  // 返回队列尾部节点存储的数据
}

// 获取队列中有效元素个数
int QueueSize(Queue* q) {
    assert(q);  // 确保指针不为空
    int size = 0;
    QNode* cur = q->_front;
    while (cur) {  // 遍历队列节点计算节点数目
        size++;
        cur = cur->_next;
    }
    return size;
}

// 检测队列是否为空,如果为空返回非零结果,如果非空返回0
bool QueueEmpty(Queue* q) {
    assert(q);  // 确保指针不为空
    return q->_front == NULL;  // 判断队列是否为空
}

// 销毁队列
void QueueDestroy(Queue* q) {
    assert(q);  // 确保指针不为空

    // 释放队列中所有节点的内存空间,并将队列头部和尾部指针置空
    QNode* cur = q->_front;
    while (cur) {
        QNode* next = cur->_next;
        free(cur);
        cur = next;
    }
    q->_front = q->_rear = NULL;
}

// 定义一个栈结构,使用两个队列实现
typedef struct {
    Queue* q1;  // 第一个队列
    Queue* q2;  // 第二个队列
} MyStack;

// 创建一个新的栈结构
MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));  // 分配栈结构内存空间
    obj->q1 = (Queue*)malloc(sizeof(Queue));  // 初始化第一个队列
    QueueInit(obj->q1);
    obj->q2 = (Queue*)malloc(sizeof(Queue));  // 初始化第二个队列
    QueueInit(obj->q2);
    return obj;
}

// 元素入栈
void myStackPush(MyStack* obj, int x) {
    Queue* noempty = obj->q1;  // 初始化非空队列指针为q1
    if (QueueEmpty(noempty))  // 如果q1为空,则指向q2
        noempty = obj->q2;
    QueuePush(noempty, x);  // 将元素入队到非空队列中
}

// 元素出栈
int myStackPop(MyStack* obj) {
    Queue* noempty = obj->q1;  // 初始化非空队列指针为q1
    Queue* empty = obj->q2;    // 初始化空队列指针为q2
    if (QueueEmpty(noempty)) {  // 如果q1为空,则交换指针
        noempty = obj->q2;
        empty = obj->q1;
    }

    // 将非空队列中的数据放入空队列中,并留下最后一个数据
    while (QueueSize(noempty) > 1) {
        QueuePush(empty, QueueFront(noempty));
        QueuePop(noempty);
    }
    int top = QueueFront(noempty);  // 获取栈顶元素
    QueuePop(noempty);  // 将栈顶元素出队
    return top;
}

// 获取栈顶元素
int myStackTop(MyStack* obj) {
    int top = myStackPop(obj);  // 获取栈顶元素
    Queue* noempty = obj->q1;   // 初始化非空队列指针为q1
    if (QueueEmpty(noempty))    // 如果q1为空,则指向q2
        noempty = obj->q2;
    QueuePush(noempty, top);    // 将栈顶元素重新入栈
    return top;
}

// 检测栈是否为空
bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(obj->q1) && QueueEmpty(obj->q2);  // 判断两个队列是否均为空
}

// 释放栈结构内存空间
void myStackFree(MyStack* obj) {
    QueueDestroy(obj->q1);  // 销毁队列1
    QueueDestroy(obj->q2);  // 销毁队列2
    free(obj->q1);  // 释放队列1的内存空间
    obj->q1 = NULL;
    free(obj->q2);  // 释放队列2的内存空间
    obj->q2 = NULL;
    free(obj);      // 释放栈结构的内存空间
}

ak截图:

数据结构初阶之栈和队列(C语言版)_第3张图片

这里由于C语言没有现成的轮子(也就是写好的队列)给我们用,所以只能自己手撕一个队列上去,所以代码比较长,不过小伙伴如果刚开始接触编程不用担心,等以后学了C++/java,上面那段代码可以减少很多,下面是C++代码示例:

#include 

class MyStack {
private:
    std::queue<int>* q1;  // 第一个队列指针
    std::queue<int>* q2;  // 第二个队列指针

public:
    // 构造函数初始化两个队列
    MyStack() {
        q1 = new std::queue<int>;
        q2 = new std::queue<int>;
    }
    
    // 元素入栈
    void push(int x) {
        std::queue<int>* noempty = q1;  // 初始化非空队列指针为q1
        if (q1->empty())  // 如果q1为空,则指向q2
            noempty = q2;
        noempty->push(x);  // 将元素入队到非空队列中
    }
    
    // 元素出栈
    int pop() {
        std::queue<int>* noempty = q1;  // 初始化非空队列指针为q1
        std::queue<int>* empty = q2;    // 初始化空队列指针为q2
        if (q1->empty()) {  // 如果q1为空,则交换指针
            noempty = q2;
            empty = q1;
        }
     
        // 将非空队列中的数据放入空队列中,并留下最后一个数据
        while (noempty->size() > 1) {
            empty->push(noempty->front());
            noempty->pop();
        }
        int top = noempty->front();  // 获取栈顶元素
        noempty->pop();  // 将栈顶元素出队
        return top;
    }
    
    // 获取栈顶元素
    int top() {
        int top = pop();  // 获取栈顶元素
        std::queue<int>* noempty = q1;  // 初始化非空队列指针为q1
        if (q1->empty())  // 如果q1为空,则指向q2
            noempty = q2;
        noempty->push(top);  // 将栈顶元素重新入栈
        return top;
    }
    
    // 检测栈是否为空
    bool empty() {
        return q1->empty() && q2->empty();  // 判断两个队列是否均为空
    }
    
    // 析构函数释放队列内存空间
    ~MyStack() {
        delete q1;
        delete q2;
    }
};

ak截图:

数据结构初阶之栈和队列(C语言版)_第4张图片

C++的代码看不懂不要紧,关键我们要把这题的思路学会:

数据结构初阶之栈和队列(C语言版)_第5张图片

相信如果小伙伴了解了本题的思路,再去看代码就很简单了。
这里就C语言代码的几个关键点作一下说明:

  1. myStackCreate()函数部分,这个函数是用来初始化栈的,返回值是指针(地址),所以我们必须使用动态开辟函数在堆上申请空间,否则出了这个函数,那片地址就会被回收,另外栈的两个指针成员也要初始化,同样需要在其它函数中使用,需要动态开辟申请空间,如果不初始化他们就是野指针了。
  2. 在pop、push栈函数部分我们都使用到了noempty或者是empty,这样做就不用考虑谁是空,谁不是空了,不容易出错,这也是我们设计栈的成员的时候使用指针的原因,如果这里empty、noempty不是指针就无法改变原队列的数据,就需要去具体的考虑谁是空,谁不是空了。
  3. myStackFree()释放内存函数部分,由于我们给两个队列的节点和队列对象q1、q2、栈对象都在堆上申请了空间,需要把他们一一释放,注意顺序即可。

✍OJ题之用两个栈实现队列

这是题目:

数据结构初阶之栈和队列(C语言版)_第6张图片

原题点这里

这里我们也是先贴ak代码:

// 定义栈结构
typedef int STDataType; // 定义栈中数据类型为整数
typedef struct Stack {
    STDataType* _a; // 存储栈元素的数组指针
    int _top;       // 栈顶位置索引
    int _capacity;  // 栈的容量
} Stack;

// 初始化栈
void StackInit(Stack* ps) {
    ps->_a = NULL;
    ps->_top = ps->_capacity = 0;
}

// 入栈
void StackPush(Stack* ps, STDataType data) {
    assert(ps); // 确保栈指针不为空
    if (ps->_top == ps->_capacity) { // 当栈满时扩容
        STDataType* tmp = ps->_capacity == 0 ? (STDataType*)realloc(ps->_a, sizeof(STDataType) * 4) : (STDataType*)realloc(ps->_a, sizeof(STDataType) * (ps->_capacity * 2));
        if (tmp == NULL) {
            perror("realloc Failed");
            exit(-1);
        }
        ps->_a = tmp;
        ps->_capacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
    }
    ps->_a[ps->_top++] = data; // 将元素入栈并更新栈顶位置
}

// 出栈
void StackPop(Stack* ps) {
    assert(ps); // 确保栈指针不为空
    assert(ps->_top > 0); // 确保栈不为空
    ps->_top--; // 出栈操作,栈顶位置减一
}

// 获取栈顶元素
STDataType StackTop(Stack* ps) {
    assert(ps); // 确保栈指针不为空
    return ps->_a[ps->_top - 1]; // 返回栈顶元素
}

// 获取栈中有效元素个数
int StackSize(Stack* ps) {
    assert(ps); // 确保栈指针不为空
    return ps->_top; // 返回栈中元素个数即栈顶位置索引
}

// 检测栈是否为空
bool StackEmpty(Stack* ps) {
    assert(ps); // 确保栈指针不为空
    return ps->_top == 0; // 返回栈是否为空
}

// 销毁栈
void StackDestroy(Stack* ps) {
    assert(ps); // 确保栈指针不为空
    free(ps->_a); // 释放栈数组内存空间
    ps->_a = NULL;
    ps->_capacity = 0;
    ps->_top = 0;
}

// 定义一个队列结构,使用两个栈实现
typedef struct {
    Stack* st1; // 入队列栈
    Stack* st2; // 出队列栈
} MyQueue;

// 创建一个新的队列结构
MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue)); // 分配队列结构内存空间
    obj->st1 = (Stack*)malloc(sizeof(Stack)); // 初始化入队列栈
    StackInit(obj->st1);
    obj->st2 = (Stack*)malloc(sizeof(Stack)); // 初始化出队列栈
    StackInit(obj->st2);
    return obj;
}

// 元素入队
void myQueuePush(MyQueue* obj, int x) {
    while (!StackEmpty(obj->st2)) { // 将出队列栈中的元素全部转移到入队列栈中
        StackPush(obj->st1, StackTop(obj->st2));
        StackPop(obj->st2);
    }
    StackPush(obj->st1, x); // 将新元素入栈到入队列栈中
}

// 元素出队
int myQueuePop(MyQueue* obj) {
    while (!StackEmpty(obj->st1)) { // 将入队列栈中的元素全部转移到出队列栈中
        StackPush(obj->st2, StackTop(obj->st1));
        StackPop(obj->st1);
    }
    int peek = StackTop(obj->st2); // 获取队头元素
    StackPop(obj->st2); // 出队操作
    return peek;
}

// 获取队头元素
int myQueuePeek(MyQueue* obj) {
    int peek = myQueuePop(obj); // 获取队头元素
    StackPush(obj->st2, peek); // 将队头元素重新入队
    return peek;
}

// 检测队列是否为空
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(obj->st1) && StackEmpty(obj->st2); // 判断两个栈是否均为空
}

// 释放队列结构内存空间
void myQueueFree(MyQueue* obj) {
    StackDestroy(obj->st1); // 销毁入队列栈
    StackDestroy(obj->st2); // 销毁出队列栈
    free(obj->st1); // 释放入队列栈的内存空间
    obj->st1 = NULL;
    free(obj->st2); // 释放出队列栈的内存空间
    obj->st2 = NULL;
    free(obj); // 释放队列结构的内存空间
}

这道题队列的成员可以不用Stack指针(这样的话在使用Stack函数时就需要取地址了),因为没有涉及到使用其它变量更改原栈变量的情况。

ak截图:

数据结构初阶之栈和队列(C语言版)_第7张图片


关键思路:

数据结构初阶之栈和队列(C语言版)_第8张图片

代码部分很多都和第一道题相似这里我们不再做过多的叙述。

⭕总结

本篇博客主要讲到了数据结构中栈和队列的一些知识,并给出了他们的C语言模拟实现,最后以两道OJ题强化了对后入先出、先入先出特性的了解,欢迎小伙伴指出不足和提出宝贵的建议,下面给出本篇博客思维导图,希望本篇博客对你有所帮助。

数据结构初阶之栈和队列(C语言版)_第9张图片

你可能感兴趣的:(数据结构与算法,数据结构,c语言,开发语言,开源,经验分享)