• LeetCode栈和队列练习

    文章目录

    前言

    之前的博客介绍的栈和队列的实现，本文将会对栈和队列的使用进行相关介绍。要学会灵活运用所学知识进行相关练习，这样对相关知识的理解和认识将会更加深刻。

    1.力扣20. 有效的括号

    1.题目分析

    题目链接直接点击

    在这里插入图片描述

    这道题就可以运用栈这种结构来做，我们看到这个字符串中这个括号匹配方式是从里到外的，那么可以先将字符串的左括号给压入栈中，当字符串是右括号的时候就从栈中弹出数据进行匹配判断。

    在这里插入图片描述

    在这里插入图片描述
    不管括号是成对出现，还是先出现左括号后出现右括号，栈都能进行相关的匹配。这一切都源于栈先进后出的存储特性，刚好和匹配判断的方式相契合。

    2.代码示现

    因为c语言中是不提供栈结构的，所以需要我们自己造一个栈出来。栈的实现还是比较简单的，之前就在博客中就介绍了栈的实现。

    代码示例

    typedef char STDataType;
typedef struct Stack
{
	STDataType* data;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
void StackInit(Stack* ps)//初始化
{
	assert(ps);
	ps->data = (STDataType*)malloc(sizeof(STDataType)*4);
	ps->top = 0;
	ps->capacity=4;
	return;
}

void StackPush(Stack* ps, STDataType x)//入栈
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
STDataType* tem = 
(STDataType*)realloc
(ps->data,ps->capacity*2*sizeof(STDataType));
		if (tem == NULL)
		{
			perror("StackPush:");
			exit(-1);
		}
        ps->data=tem;
		ps->capacity *= 2;
	}

	ps->data[ps->top] = x;
	ps->top++;
	return;
}


void StackPop(Stack* ps)//出栈
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(Stack* ps)//获取栈顶元素
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->data[ps->top - 1];
}

int StackEmpty(Stack* ps)//栈判空
{
	return ps->top == 0;
}

void StackDestroy(Stack* ps)//销毁栈
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->top = 0;
	ps->capacity = 0;
	return;
}
bool isValid(char * s){
    Stack st;
    StackInit(&st);
    while(*s)
    {
        if(*s=='('||*s=='['||*s=='{')
        {
            StackPush(&st,*s);
            s++;
        }
        else if(StackEmpty(&st))
             {   
                 StackDestroy(&st);
                 return false;
             }
        else 
         {      char c =StackTop(&st);
                 StackPop(&st);
                 if(*s==']'&&c!='[')
                 { StackDestroy(&st);
                     return false;
                 }
                 else if(*s=='}'&&c!='{')
                 {  StackDestroy(&st);
                     return false;
                 }
                 else if(*s==')'&&c!='(')
                 {   StackDestroy(&st);
                     return false;
                 }
                s++;
         }
    }
    bool ret=(bool)StackEmpty(&st);
    StackDestroy(&st);
  return ret;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104

    有了栈就挨个遍历字符串，如果是字符是左括号的一种就压入栈，如果不是就将栈中数据弹出，进行匹配，注意要现获得栈顶元素匹配判断，然后再Pop。如果再字符串还没遍历完栈就空了，这说明这个字符串肯定不是符合要求的，因为出现这样的情况大致有两个可能，第一就是第一元素不是左括号，上来就是右括号，这样肯定是不符合要求的，还有一种可能，左括号比右括号少或者，或者括号位置不是按正确的位置出现的，这样都是不符合要求的，直接返回false.在返回之前一定记得调用销毁函数，不然就是内存泄漏。在else的语句中，是可以将else if合成一条语句判断的，我嫌看起来太挤了，就每种括号单独判断了。同时如果每个括号都能正确匹配上，最后栈遍历完字符串后栈一定是空的，如果栈为空就是符合要求的字符串，如果没有栈为空判断的话，还有可能字符串的左括号比右括号多的这种现象，所以要加上栈为空的判断，每次返回时一定记得提前进行栈销毁。

    2.力扣225. 用队列实现栈

    1.题目分析

    题目链接直接点击

    在这里插入图片描述

    这道题是用队列实现栈，其实主要的重点在于用队列模拟实现栈出数据的方式。我们首先要搞清队列和栈的进出数据的方式。队列的是先进先出的，栈的先进后出的。所以我们可以用两个队列来回倒腾数据。先用一个队列来存储数据，要出数据时，将这个队列的前n-1个数据倒入空队列中，这样原队列只剩一个数据了，这个就当于栈中的栈顶元素。将这个数据弹出，就实现了数据出栈，这两个队列来回倒腾就可以了。

    在这里插入图片描述

    利用队列出数据的方式，来回倒腾就模拟了栈出数据的方式

    2.代码实现

    既然是用队列实现栈，所以就得有队列，所以先写好队列，然后就是调用队列的相关接口来实现栈。

    代码示例

    typedef int QDataType;
//定义队列节点
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QueueNode;
//定义队列
typedef struct Queue
{
	QueueNode* head;//维护队头
	QueueNode* tail;//维护队尾
	int sz;//记录队列元素个数
}Queue;
void QueueInit(Queue* q)//初始化队列
{
	assert(q);
	q->head = NULL;
	q->tail = NULL;
	q->sz = 0;
	return;
}

void QueuePush(Queue* q, QDataType data)//队尾入列
{
	    assert(q);
		QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
		if (newnode==NULL)
		{
			perror("QueuePush:");
			exit(-1);
		}
		newnode->data = data;
		newnode->next = NULL;
		if (q->head == NULL)
		{
			q->head = q->tail = newnode;
			
		}
		else  
		{   
			q->tail->next = newnode;
			q->tail = newnode;
			
		}
		q->sz++;
		return;
}
void QueuePop(Queue* q)//队头元素出列
{
	assert(q);
	assert(!QueueEmpty(q));
	if (q->head->next == NULL)//队列只有一个节点
	{
		free(q->head);
		q->head = NULL;
	}
	else
	{
		QueueNode* del = q->head;
		q->head = q->head->next;
		free(del);
	}
	q->sz--;
	return;
}


QDataType QueueFront(Queue* q)//获取队列队头元素
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}

QDataType QueueBack(Queue* q)//获取队列队尾元素
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->data;
}


int QueueSize(Queue* q)//获取队列元素个数
{   
	assert(q);
	return q->sz;
}

int QueueEmpty(Queue* q)// 检测队列是否为空
{
	assert(q);
	return q->sz==0 ;
}

void QueueDestroy(Queue* q)// 销毁队列
{
	assert(q);
	QueueNode* cur = q->head;
	while (cur)
	{
		QueueNode* Next = cur->next;
		free(cur);
		cur = Next;
	}
	q->head = NULL;
	q->tail = NULL;
	q->sz = 0;
	return;
}


typedef struct {
    Queue q1;
    Queue q2;

} MyStack;


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

}

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

}

int myStackPop(MyStack* obj) {
    Queue* empty=&obj->q1;
    Queue* Noempty=&obj->q2;
    if(QueueEmpty(&obj->q2))
    {
        empty=&obj->q2;
        Noempty=&obj->q1;
    }
     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->q2);
    }
    else
    {
        return QueueBack(&obj->q1);
    }

}

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

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

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180

    队列有获取队头的元素的接口，所以每次倒腾到其中某个队列只有一个数据时就获取这个队头元素，相当于得到了栈顶元素，然后pop队列相当于将这个队列又重新置为空。如果队列1不是空，就往里面插入数据，如果队列1为空，就往队列2插入数据。同时队列有获取队尾元素的接口，如果想获取栈顶元素，直接通过这个接口获取不为空的队列的尾元素即可。如果两个队列都是空的，栈就为空。在实现栈pop时，可以先假设队列1为空，队列2不为空，如果不是两者交换即可。这是一个小的处理技巧之前链表题也用到过。销毁栈时，直接调用相关的接口销毁队列和表示栈的变量即可。

    队列实现栈，一定要保证其中一个队列是空的，用来倒腾数据，数据时到底是哪个队列出数据，一定要搞清楚。队列实现栈，就是通过队列的接口函数来实现操作这个栈，不能直接去访问这个队列的内部。

    3.力扣232. 用栈实现队列

    1.题目分析

    题目链接直接点击
    在这里插入图片描述

    这道题是用两个栈来实现队列。主要的难点也是出数据。还是先前的方式倒腾一下数据，但是倒腾的方式和之前就有所区别了。我们画图分析一下。

    在这里插入图片描述

    通过图我们可以看到当栈转移一部分数据到另一个栈中时，数据出栈的顺序就和队列一样了，这都源于栈先进后出的特性。所以我用一个栈来存储数据，另一个栈用来专门出数据，出数据时只用将存储数据的栈中的数据导入这个出数据的栈中即可。这个出数据的栈直接出数据，和队列出数据的顺序一样。

    2.代码实现

    用栈实现队列，也得先建栈。有了栈就直接调用相关的接口来实现即可。

    代码示例

    typedef int STDataType;
typedef struct Stack
{
	STDataType* data;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
int StackEmpty(Stack* ps);
void StackInit(Stack* ps)//初始化
{
	assert(ps);
	ps->data = (STDataType*)malloc(sizeof(STDataType)*4);
	ps->top = 0;
	ps->capacity=4;
	return;
}

void StackPush(Stack* ps, STDataType x)//入栈
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tem = 
		(STDataType*)realloc
		(ps->data, ps->capacity*2*sizeof(STDataType));
		if (tem == NULL)
		{
			perror("StackPush:");
			exit(-1);
		}
		ps->data = tem;
		ps->capacity *= 2;
	}

	ps->data[ps->top] = x;
	ps->top++;
	return;
}


void StackPop(Stack* ps)//出栈
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(Stack* ps)//获取栈顶元素
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->data[ps->top - 1];
}

int StackEmpty(Stack* ps)//栈判空
{
	return ps->top == 0;
}

int StackSize(Stack* ps)//获取栈中有效元素个数
{  
	assert(ps);
	return ps->top;
}
void StackDestroy(Stack* ps)//销毁栈
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->top = 0;
	ps->capacity = 0;
	return;
}


typedef struct {
    Stack stpop;
    Stack stpush;
} MyQueue;
bool myQueueEmpty(MyQueue* obj);
int myQueuePeek(MyQueue* obj);

MyQueue* myQueueCreate() {
    MyQueue* q=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->stpop);
    StackInit(&q->stpush);
    return q;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    StackPush(&obj->stpush,x);

}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));
    int peek= myQueuePeek(obj);
    StackPop(&obj->stpop);
    return peek;
}

int myQueuePeek(MyQueue* obj) {
 assert(obj);
 assert(!myQueueEmpty(obj));
 if(StackEmpty(&obj->stpop))
 {
     while(!StackEmpty(&obj->stpush))
     {
         StackPush(&obj->stpop,StackTop(&obj->stpush));
         StackPop(&obj->stpush);
     }
 }
 
 return StackTop(&obj->stpop);
}

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
   return StackEmpty(&obj->stpop)&&StackEmpty(&obj->stpush);

}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestroy(&obj->stpop);
    StackDestroy(&obj->stpush);
    free(obj);

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132

    在入数据时，直接将数据插入stpush栈中，出数据时将stpush栈顶元素依次插入stpop栈中，每次插入后，stpush栈都栈pop一下，这样导完数据后，stpush栈也会被清空。出数据时，只用将stpop栈的栈顶数据弹出，每次弹出数据时，都要栈pop一下。这个获得队头元素的接口函数，就是获得stpop栈中的栈顶元素，因为在实现这个这个函数时，已经实现了栈数据的倒入，所以我们在实现队列pop接口时，再次复用这个接口即可。但是一定要将这个接口声明定义写在队列pop函数之前，不然就会出现使用未定义符号的错误。队列判空很好判断，就是两个栈同时为空时。free接口就是调用栈销毁接口，再将malloc的队列变量给free即可。

    在导入数据时一定要保证出数据的栈是空的。每次出数据的栈出完栈中所有数据后，再要出数据时，接着将数据导入出数据的栈。每次出数据就从这个栈出，这一步就是这道题的关键。

    4.力扣622. 设计循环队列

    1.题目分析

    题目链接直接点击
    在这里插入图片描述

    这道题我们先搞清楚循环队列的是什么，再来分析题目。

    在这里插入图片描述
    在这里插入图片描述

    以上图为例当队列4个空间满了后，如果队列要出数据，假如1和2从队列出去了，这个时候队列4个位置就空出来了，此时想将插入数据 5，6，这个时候再4的后面插入5即可，接着插入6。这个时候其实3相当于队头，6相当于队尾了，循环队列可以重复利用队列的空间，同时队头和队尾是在随时动态变化的，这就是一个简单的循环队列。

    循环队列的实现有和普通队列的实现方式一样，都有两种方式，分别是链式实现和数组实现。这里我采用数组实现，因为这个循环队列其实不会涉及元素的挪动，队头和队尾的位置是动态变换的，只用设计两个变量记录队首和队尾的位置即可，在插入数据和删除数据时实时更新队头和队尾的位置即可。这就利用了数组可以进行随机访问的特点。但是如果使用链表的话，就略显麻烦一点。

    确定了循环队列的实现方式，就先定义循环队列的结构吧。循环队列的成员大致有4个：一个是循环队列的存储空间也就是数组，还有一个整数是表示循环队列的大小，也就是可以存储多少个数据，剩余两个成员就是分别记录队尾位置和队头位置。

    队列结构有了，这个队列怎么循环起来呢？我们画图分析一下吧

    在这里插入图片描述

    在这里插入图片描述
    循环队列满了就无法插入数据，只有队列中在未满的情况下才能插入数据。虽然它的物理结构是数组，但是它的逻辑结构类似于一个环。

    2.代码实现

    代码示例

    typedef struct {
    int *a;
    int front;
    int tail;
    int k;

} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));//多开一个空间，用于判满
    obj->k=k;
    obj->front=0;
    obj->tail=0;
    return obj;

}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail++]=value;
    obj->tail%=(obj->k+1);
    return true;

}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    obj->front%=(obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
   return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
   assert(obj);
   if(myCircularQueueIsEmpty(obj))
   {
       return -1;
   }
  return obj->a[(obj->tail+obj->k)%(obj->k+1)];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
   assert(obj);
   return obj->tail==obj->front;

}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail+1)%(obj->k+1)==obj->front;

}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75

    在代码实现时还有很多的小细节需要注意，在插入数据时，每次往前走，但是需要进行操作tail=tail%(obj->k+1)，这是为了避免tail在往前走的过程中造成数组越界。有了这个取余操作，tail就可以像在圆中走一样，不断循环往复。获取队头元素就是获取front指向的数据。但是获取队尾元素还需要取余操作（tail+k)%(k+1），这是因为front指向就是队头元素，但是tail的后一个才是队尾元素，如果在队尾变更的过程中，tail指向下标0，如果不余直接就是tail-1，这明显就是不符合逻辑的，此时的队尾的下标应该是在k-1的位置处。所以需要格外注意，判空就是front==tail,判满就是（tail+1)%(k+1)==front。

    5.总结

    • 本文总结了部分栈和队列的题目，在用代码实现之前一定要自己先画图梳理清楚逻辑，这些数据结构存储数据的特点一定要清楚。
    • 为了更好的熟练运用相关知识还是要对栈和队列的相关习题进行练习。
    • 以上内容如有问题，欢迎指正！
  • 相关阅读:
    Leecode 108:将有序数组转换成二叉搜索树，传指针或引用对程序的影响
    Unity脚本的基础语法(6)-特定文件夹
    C语言-流程控制
    Rasa 3.x 学习系列-非常荣幸成为 Rasa contributors 源码贡献者，和全世界的Rasa源码贡献者共建共享Rasa社区！
    Spring Cloud应用- Eureka原理、搭建
    新版TCGA表达矩阵1行代码提取2.0版
    python pandas.DataFrame 直接写入Clickhouse
    HTML5中自定义数据属性data-*属性(3)jq如何操作data-*
    记录 ubuntu 硬盘分区跟格式化（fdisk命令）
    浅述mesh广播中的1827与1828
  • 原文地址：https://blog.csdn.net/m0_61894055/article/details/127903373