栈和队列经典题

最新推荐文章于 2025-07-08 19:52:11 发布
最新推荐文章于 2025-07-08 19:52:11 发布
阅读量2.2k 收藏 5
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40192867/article/details/80310488

实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1)

这道题出栈和入栈都比较好求，关键在于这个返回最小值的时间复杂度，一般来说，要遍历一遍，但是这样时间复杂度就是O（n）,和题意不符，这道题的做法是创建一个结构体，这个结构体中保存着入栈元素的大小，也包含着这个栈中最小的元素，然后再创建一个结构体，这个结构体是栈，入栈的时候直接压入结构体，情况如下所示：





test.c

#include"StackAndQueuelnterview.h"
#include<Windows.h>
int main()
{
	Stack s;
	InitStack(&s);
	StackPush(&s, 5);
	StackPush(&s, 5);
	StackPush(&s, 6);
	StackPush(&s, 2);
	StackPop(&s);
	StackPush(&s, 8);
	StackPush(&s, 10);
	StackPush(&s, 50);
	//最小值应该是5
	printf("Minddata is %d", StackMindata(&s));
	system("pause");
	return 0;
}

Stacklnterview.h

#pragma once
#include<stdio.h>
#include<assert.h>
#define MAX_SIZE 100
//封装结构体，最大100个
typedef struct NewData
{
	int data;
	int Mindata;
}Newdata;

typedef struct Stack
{
	Newdata _arr[MAX_SIZE];//栈里放封装好的结构体
	int _size;
}Stack,*PStack;

//初始化
void InitStack(PStack s);
//栈顶插入元素
void StackPush(PStack s, int data);
//出栈
void StackPop(PStack s);
//返回最小元素
int  StackMindata(PStack s);


Stacklnterview.c

#include"StackAndQueuelnterview.h"
//初始化
void InitStack(PStack s)
{
	assert(s);
	s->_size = 0;
}
//栈顶插入元素
void StackPush(PStack s, int data)
{
	assert(s);
	int size = s->_size;
	if (size == MAX_SIZE)
	{
		printf("栈满了");
			return;
	}
	//如果栈是空的，最小的等于第一个元素的值
	if (size == 0)
	{
		s->_arr->data = data;
		s->_arr->Mindata = s->_arr->data;
		
		s->_size++;
		return;
	}
	if ((s->_arr + size -1)->Mindata > data)
	{
		(s->_arr + size)->Mindata = (s->_arr + size)->data = data;
		s->_size++;
		return;
	}
	//压入的元素大于上一个元素的Minddata
	else
	{
		(s->_arr + size)->Mindata = (s->_arr + size-1)->Mindata;
		(s->_arr + size)->data = data;
		 s->_size++;

	}

}
//出栈
void StackPop(PStack s)
{
	assert(s);
	if (s->_size == 0)
	{
		printf("栈为空");
		return;
	}
	s->_size--;
}
//返回最小元素
int  StackMindata(PStack s)
{
	assert(s);
	if (s->_size == 0)
	{
		printf("没有元素");
		return;
	}
	return (s->_arr + (s->_size - 1))->Mindata;
}

///////////////////////////////////////////////////////////队列/////////////////////////////////////////////////////////////////////

使用两个栈实现一个队列

思路：栈是先进后出，队列是先进先出，用两个栈来实现，先把队列的元素加到其中一个栈里，如果满了，就搬移到另外一个栈，这样栈顶元素就是队列的开始位置，以后再往进加队列元素时，先看看栈1满了没，如果没有，放到栈1中，等满了再倒入栈2，下面看图



test.c

#include"StackAndQueuelnterview.h"
//初始化队列
void QueueInit(PQueue q)
{
	assert(q);
	q->S1._size = 0;
	q->S2._size = 0;
}
//入栈
void StackPush(Stack* s, DataType data)
{
	assert(s);
	if (s->_size == MAX_SIZE)
	{
		printf("栈满了");
		return;
	}
	s->_arr[s->_size] = data;
	s->_size++;
	
}
//入队列,入到栈s1
void QueuePush(PQueue q, DataType data)
{
	assert(q);
	if (q->S1._size == MAX_SIZE)
	{
		//搬移必须保证第二个队列为空
		if (q->S2._size == 0)
		{
			while (q->S1._size != 0)
			{
				DataType data = StackTop(&(q->S1));
				StackPop(&(q->S1));
				StackPush(&(q->S2), data);
			}
		}
		else
		{
			printf("s2队列不为空");
		}
	}
	//在s1中加元素
	StackPush(&(q->S1), data);
}
//返回栈顶元素
DataType StackTop(Stack* s)
{
	assert(s);
	if (s->_size == 0)
	{
		printf("栈空了");
		return;
	}
	return s->_arr[s->_size - 1];
}
//出栈
void StackPop(Stack* s)
{
	assert(s);

	if (s->_size == 0)
	{
		printf("栈为空，操作失败!!!\n");
		return;
	}

	s->_size--;
}
//出队列
void QueuePop(PQueue q)
{
	assert(q);
	//s2不为空，直接出，顶为队列头
	if (q->S2._size > 0)
	{
		StackPop(&(q->S2));
		return;
	}
	else
	{
		//如果s1也为空，队列为空
		if (q->S1._size == 0)
		{
			printf("队为空");
			return;
		}

		//s1不为空，将s1倒过来
		else
		{
			while (q->S1._size != 0)
			{
				DataType data = StackTop(&(q->S1));
				StackPop(&(q->S1));
				StackPush(&(q->S2), data);
			}
		}
		//s2的栈顶为队头
		StackPop(&(q->S2));
	}

}
//获取队头元素
DataType QueueFront(PQueue q)
{
	assert(q);
	//s1 and s2 all empty
	if (q->S1._size == 0 && q->S2._size == 0)
	{
		printf("the queue is null");
		return 0;
	}
	if (q->S2._size != 0)
	{
		return StackTop(&(q->S2));
	}
	else
		return q->S1._arr[0];
}
//获取队尾元素
DataType QueueBack(PQueue q)
{
	assert(q);
	//如果s1,s2都是空的，说明队列是空的
	if (q->S1._size == 0 && q->S2._size == 0)
	{
		printf("the queue is null");
		return 0;
	}
	//如果s1不为空，那么队尾就是s1的栈顶，否则，就是s2的栈底
	if (q->S1._size != 0)
		return StackTop(&(q->S1));
	else
		return q->S2._arr[0];

}

StackAndQueueInterview.h

#pragma
#include<stdio.h>
#include<assert.h>

#define MAX_SIZE 9
typedef int DataType;
typedef struct Stack
{
	DataType _arr[MAX_SIZE];
	int _size;
}Stack;

typedef struct Queue
{
	Stack S1;
	Stack S2;

}Queue,*PQueue;

//初始化队列
void QueueInit(PQueue q);
//入栈
void StackPush(Stack* s, DataType data);
//入队列,入到栈s1
void QueuePush(PQueue q, DataType data);
//返回栈顶元素
DataType StackTop(Stack* s);
//出栈
void StackPop(Stack* s);
//出队列
void QueuePop(PQueue q);
//获取队头元素
DataType QueueFront(PQueue q);
//获取队尾元素
DataType QueueBack(PQueue q);

StackAndQueueInterview.c

#include"StackAndQueuelnterview.h"
//初始化队列
void QueueInit(PQueue q)
{
	assert(q);
	q->S1._size = 0;
	q->S2._size = 0;
}
//入栈
void StackPush(Stack* s, DataType data)
{
	assert(s);
	if (s->_size == MAX_SIZE)
	{
		printf("栈满了");
		return;
	}
	s->_arr[s->_size] = data;
	s->_size++;
	
}
//入队列,入到栈s1
void QueuePush(PQueue q, DataType data)
{
	assert(q);
	if (q->S1._size == MAX_SIZE)
	{
		//搬移必须保证第二个队列为空
		if (q->S2._size == 0)
		{
			while (q->S1._size != 0)
			{
				DataType data = StackTop(&(q->S1));
				StackPop(&(q->S1));
				StackPush(&(q->S2), data);
			}
		}
		else
		{
			printf("s2队列不为空");
		}
	}
	//在s1中加元素
	StackPush(&(q->S1), data);
}
//返回栈顶元素
DataType StackTop(Stack* s)
{
	assert(s);
	if (s->_size == 0)
	{
		printf("栈空了");
		return;
	}
	return s->_arr[s->_size - 1];
}
//出栈
void StackPop(Stack* s)
{
	assert(s);

	if (s->_size == 0)
	{
		printf("栈为空，操作失败!!!\n");
		return;
	}

	s->_size--;
}
//出队列
void QueuePop(PQueue q)
{
	assert(q);
	//s2不为空，直接出，顶为队列头
	if (q->S2._size > 0)
	{
		StackPop(&(q->S2));
		return;
	}
	else
	{
		//如果s1也为空，队列为空
		if (q->S1._size == 0)
		{
			printf("队为空");
			return;
		}

		//s1不为空，将s1倒过来
		else
		{
			while (q->S1._size != 0)
			{
				DataType data = StackTop(&(q->S1));
				StackPop(&(q->S1));
				StackPush(&(q->S2), data);
			}
		}
		//s2的栈顶为队头
		StackPop(&(q->S2));
	}

}
//获取队头元素
DataType QueueFront(PQueue q)
{
	assert(q);
	//s1 and s2 all empty
	if (q->S1._size == 0 && q->S2._size == 0)
	{
		printf("the queue is null");
		return 0;
	}
	if (q->S2._size != 0)
	{
		return StackTop(&(q->S2));
	}
	else
		return q->S1._arr[0];
}
//获取队尾元素
DataType QueueBack(PQueue q)
{
	assert(q);
	//如果s1,s2都是空的，说明队列是空的
	if (q->S1._size == 0 && q->S2._size == 0)
	{
		printf("the queue is null");
		return 0;
	}
	//如果s1不为空，那么队尾就是s1的栈顶，否则，就是s2的栈底
	if (q->S1._size != 0)
		return StackTop(&(q->S1));
	else
		return q->S2._arr[0];

}

判断出栈顺序是不是正确

判断的思路：一组是压栈的顺序，另一组是给的出栈的顺序，如果栈是空的，先压栈，然后和给定的出栈顺序第一个比较，如果第一个出栈的字母在栈里没有，就继续按照入栈的顺序往进入，如果有了，然后弹出，比较下一个出栈元素和栈顶是不是相等，如果不是，继续按照给定的顺序压入，以此类推，如果压到头还是没有，就说明出栈顺序是错误的！如果循环能正常结束，就说明是正确的，见图：


test.c

#include"StackAndQueuelnterview.h"

int main()
{
	stack sta;
	StackInit(&sta);
	int a[5] = { 'a','b','c','d','e' };
	int b[5] = { 'c','d','a','b','e' };
	int index = 0;
	int i = 0;
	PrintStack(&sta);
	StackInit(&sta);
	for(i = 0; i < 5; i++ )
	{
		if ((StackEmpty(&sta) != NULL) && (StackTop(&sta) == b[i]))
			StackPop(&sta);
		else  //压入元素
		{
			while (b[i] != a[index])
			{
				StackPush(&sta, a[index]);
				index++;
				if (index == 5)
				{
					printf("失败");
					system("pause");
					return;
				}
			}
			
				index++;
		}
	}
	printf("成功");
	system("pause");
	return 0;
}

StackAndQueuelnterview.h

#pragma once
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
#define T  10
#define MAX 100
typedef char DataType;
typedef struct Stack
{
	DataType arr[MAX];
	//int capacity;
	int size;


}stack, *PStack;






// 栈的初始化 
void StackInit(PStack ps);


// 入栈 
void StackPush(PStack ps, DataType data);


// 出栈 
void StackPop(PStack ps);
//
// 获取栈顶元素 
DataType StackTop(PStack ps);


// 获取栈中元素个数 
int StackSize(PStack ps);


// 检测栈是否为空 
int StackEmpty(PStack ps);


void PrintStack(PStack ps);//打印栈

StackAndQueuelnterview.c

#include"StackAndQueuelnterview.h"
// 栈的初始化 
void StackInit(PStack ps)
{
	assert(ps);
	ps->size = 0;
}


//入栈 
void StackPush(PStack ps, DataType data)
{
	assert(ps);
	ps->arr[ps->size] = data;
	ps->size++;
}


// 出栈 
void StackPop(PStack ps)
{
	assert(ps);
	ps->size--;
}


// 获取栈顶元素 
DataType StackTop(PStack ps)
{
	assert(ps);
	return ps->arr[ps->size - 1];

}


//获取栈中元素个数 
int StackSize(PStack ps)
{
	assert(ps);
	return ps->size;
}


//检测栈是否为空 
int StackEmpty(PStack ps)
{
	if (ps->size)
		return 1;
	else
		return 0;


}
void PrintStack(PStack ps)//打印栈
{
	int i = 0;
	for (; i < ps->size; i++)
	{
		printf("%c", ps->arr[i]);
	}
}





栈和队列经典OJ题
MEANSWER的博客
10-05 651
栈和队列经典OJ题1. LeetCode第225题---用队列实现栈2. LeetCode第232题---用栈实现队列3. LeetCode第20题---有效的括号4. LeetCode第150题---逆波兰表达式5. LeetCode第155题---最小栈6. 牛客网剑指offer21题---栈的压入、弹出序列 1. LeetCode第225题—用队列实现栈 链接: https://leetcode-cn.com/problems/implement-stack-using-queues/ 题解：用队列
栈和队列经典面试题详解
A13569039691的博客
05-15 1410
栈和队列经典面试题详解
Leetcode 刷题笔记(十) —— 栈与队列篇之经典题目
a1241692733的博客
02-07 2405
栈与队列的一些经典题目
栈和队列（数据结构学习笔记）
最新发布
2401_87777360的博客
07-08 902
栈（stack）是一个特殊的线性表，是限定仅在一端（通常是表尾）进行插入和删除的线性表。又称为后进先出（Last In First Out）的线性表,简称LIFO结构。栈是仅在表尾进行插入、删除的线性表。表尾（即an端）称为栈顶Top;表头（即a1端）称为栈底Base。插入元素到栈顶（即表尾）的操作，称为入栈。“入”=压入=PUSH(x)从栈顶（即表尾）删除最后一个元素的操作，称为出栈。“出”=弹出=POP(y)队列（queue）是一种。
《数据结构》-第三章 栈和队列（习题）
热门推荐
大家一起进步叭
07-27 1万+
第三章 栈和队列 栈与队列作为操作受限的线性表，在考试中常以选择题、填空题出现，也会有部分算法题目涉及对栈或队列的知识（如求解阶乘n！、括号匹配等场景）。栈部分相对常考内容为进栈、出栈操作、栈空栈满判断共享栈两端进出栈的操作（考研）；对于队列常以真假溢出判断、循环队列队空（队满）判断方向进行出题。 一、选择题（第1-10题为基础难度，第11-20题难度适合考研） 1.若进栈序列为a,b,c，则通过入出栈操作可能得到的a,b,c的不同排列个数为 A) 4 B) 5...
栈和队列典型习题总结
qq_41185460的博客
12-16 702
1.用队列实现栈 例子： 12 23 34 45 56 67 78 思路分析：需要有两个队列实现，栈是先进后出，后进先出。 入队列时：①两个队列都是空的，入qu1 ②有一个队列不是空的，入队列入非空队列。 出队列时：哪个不为空出哪个队列。出n-1到另一个队列，再把最后一个元素出栈。 import java.util.LinkedList; import java.util.Queue...
【初阶数据结构】栈和队列（附题目）
2401_82610555的博客
05-30 2357
本文全面介绍栈和队列。栈是特殊线性表，只允许在固定一端操作，遵守后进先出原则。实现时一般用数组更优，介绍了栈的结构体及初始化、入栈出栈等操作函数。队列是特殊线性表，允许一端插入一端删除，先进先出。用链表实现更优，介绍了队列结构体及初始化、入队出队等操作。还给出了栈和队列的面试题解法，如括号匹配用栈实现，用队列实现栈和用栈实现队列，设计循环队列对比了数组和链表实现方式。文末附上了栈和队列的源码，包括头文件和源文件，方便理解和使用。
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
栈和队列习题整理
m0_49991895的博客
02-19 825
一、括号匹配问题 题目描述如下： 解题思路：使用栈来解决，扫描字符串，当碰到左括号时直接入栈，当扫描到右括号时，弹出栈顶元素查看是否匹配，不匹配直接false，否者重复上述流程。 两个边界问题： 扫描完字符串，栈不为空时，说明左括号多了，没有相匹配的右括号，直接false。 扫描到第一个右括号时，发现栈为空，说明右括号是该字符串的第一个字符，没有相匹配的左括号，直接false。 代码如下： public class Num20 { public boolean isValid...
数据结构栈和队列练习题答案.doc
04-02
数据结构
栈与队列经典例题详解
06-06
体育课经常排在上午3、4节，一节课下来大家都筋疲力尽、饥肠辘辘。将近下课，体育老师一吹口哨大家立即集合，不过这次集合大家都站成了一排，然后老师说向右看齐，这时每个人只能看到右侧比自己矮的人头，如果突然出现一个高于或等于自己身高的同学，那么这名同学以及其右侧的同学将会被挡住。那么，问题来了，现给定所有同学的身高（假设体育课大家修炼了一种神秘技能，改变了自己的身高，（身高最大值为2*106），要求每个人能往右侧看到的人数之和（建议使用long long存储）。
【栈和队列经典题目】用队列实现栈，用栈实现队列，设计循环队列
weixin_74113106的博客
05-18 216
用队列实现栈，用栈实现队列，设计循环队列
【数据结构】——栈、队列及串的相关习题
小宇y的博客
08-09 3337
入队操作针对Q.rear，入队的代码通过取余运算实现，队尾指针加1，即Q.rear=(Q.rear+1)%MaxSize，不管前面(Q.rear+1)为多少，它与MaxSize（例如，MaxSize=5）取余的结果只可能是0、1、2、3、4，也就是队尾指针Q.rear的每次移动加1。1、设栈S和队列Q的初始状态为空，元素a，b，c，d，e，f依次通过栈S，一个元素出栈后即进队列Q，若6个元素出队的序列是a，c，f，e，d，b，则栈S的容量至少应该是（）。b、c通过栈S后，c首先出栈通过队列，得到出队为。
栈和队列经典习题
weixin_43636782的博客
10-13 425
括号匹配问题 问题描述：给定一个包括 ’ ( ‘,’ ) ‘,’ [ ‘,’ ] ‘,’ { ‘,’ } '的字符串，判断字符串是否有效； 字符串需要满足： (1)左括号必须用相同类型的右括号匹配； (2)左括号要以正确的方式闭合； 注意：空字符串被认为是有效字符串； 解题思路： (1)遍历当前字符串，依次取出每个字符；如果当前字符是左括号，就把当前字符入栈； (2)如果当前字符是右括号，那么就取出栈顶元素，看看栈顶元素和当前元素是否匹配. a)匹配：则将栈顶元素出栈，继续取下一个字符； b)不匹配：直接.
栈和队列的经典例题，LeetCode 括号匹配问题；栈实现队列；队列实现栈；队列带环问题
weixin_70873145的博客
05-25 934
又有很久没有更新文章了，这次带你们手撕几道基础题。
栈和队列练习题
周闖的博客
05-05 577
栈和队列的练习题 1. 有效的括号 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足： 看把你们，快慢左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 1: 输入: “()” 输出: true class Solution: def isValid(self, s:...
关于栈与队列的一些经典例题
m0_74910523的博客
07-21 208
这几天刷了不少栈与队列的题目，之前这一块没怎么学好，结合近几天在力扣上的题目还是有不少收获的，争取在这个暑假把数据结构与算法这一块学好。接下来分享一些刷到的有意思和比较经典的题目。目录前言1 LeetCode 20.有效的括号2.LeetCode 239.滑动窗口最大值。
3.26栈和队列相关练习题
m0_61548909的博客
03-20 1182
1. 括号匹配问题 左括号入栈，右括号出栈 若用C语言，栈的操作相关函数需要在前面单独写出 bool isValid(char * s){ Stack st; StackInit(&st); while(*s) { //左括号入入栈 //右括号找最近的左括号匹配 if(*s == '['||*s == '('||*s == '{') { StackPus..
栈和队列 简答题 论述题
03-22
<think>嗯，用户想了解栈和队列的数据结构概念及其应用场景，可能是为了考试或者写论述题答案。首先，我需要回忆栈和队列的基本定义，确保概念准确。栈是后进先出（LIFO）的结构，队列是先进先出（FIFO）的。然后要比较它们的异同，比如操作上的区别，比如栈的push和pop在顶端，队列的enqueue和dequeue分别在尾和头。 接下来是应用场景，栈的应用比如函数调用堆栈、括号匹配、撤销操作；队列的应用比如任务调度、缓冲处理、广度优先搜索。需要具体例子，比如操作系统中的进程调度用队列，编辑器里的撤销用栈。这部分要结合用户提供的引用，比如引用[2]提到数据存储技术，可能可以关联到实际应用中的实现。 用户提供的引用里，引用[1]提到数据结构题目详解，可能需要注意常见错误，比如栈溢出或者队列空的情况处理。引用[3]讲线程超时，可能和队列在任务调度中的应用有关联，但不确定是否直接相关，可能需要谨慎引用。 还要确保回答结构清晰，分点论述。可能用户需要简答和论述两种形式，所以先给出概念，再比较异同，最后详细的应用场景。代码示例部分，用户给的例子是Python，所以用Python实现栈和队列的基本操作，比如用列表实现，但要注意线程安全或者效率问题，比如用collections.deque实现队列更高效。 需要检查LaTeX格式是否正确，所有行内公式用$...$，独立公式用$$...$$。比如栈的操作复杂度是$O(1)$，队列的也是$O(1)$，但循环队列可能需要数组实现。这部分可能需要数学表达式，但用户示例中没有复杂的公式，保持简洁。 最后生成相关问题，要围绕栈和队列的扩展，比如实现方式、应用实例、复杂度分析等。确保问题有助于用户进一步学习或考试准备。注意引用标识要自然添加，比如在讨论括号匹配时引用[^1]的常见错误，或者在数据存储实现时引用[^2]。 现在整理回答结构，先定义栈和队列，再比较，接着应用场景，代码示例，最后相关问题。确保每个部分都准确，并且引用恰当的地方。</think>### 栈和队列的概念及应用场景 #### 1. **数据结构概念** - **栈（Stack）**： 栈是一种**后进先出（LIFO）**的线性数据结构，仅允许在**同一端（栈顶）**进行插入（`push`）和删除（`pop`）操作。其核心特性为： - 基本操作时间复杂度为$O(1)$； - 典型应用包括函数调用栈、表达式求值、括号匹配等。 - **队列（Queue）**： 队列是一种**先进先出（FIFO）**的线性数据结构，插入操作（`enqueue`）在**队尾**进行，删除操作（`dequeue`）在**队头**进行。其特点为： - 基本操作时间复杂度为$O(1)$； - 应用场景如任务调度、消息队列、广度优先搜索（BFS）等。 #### 2. **栈与队列的对比** | 特性 | 栈 | 队列 | |--------------|------------------------|--------------------------| | 操作端 | 仅栈顶 | 队头（删除）、队尾（插入）| | 数据顺序 | LIFO | FIFO | | 典型问题 | 递归实现、撤销操作 | 多线程任务分发、缓冲处理 | #### 3. **应用场景详解** - **栈的典型应用**： - **函数调用栈**：程序执行时保存函数调用上下文，确保返回地址和局部变量的正确性[^1]； - **括号匹配**：通过栈检测表达式中的括号嵌套合法性，例如`((a+b)*c)`； - **撤销操作（Undo）**：编辑器通过栈记录操作历史，支持反向回退。 - **队列的典型应用**： - **任务调度**：操作系统使用队列管理进程的就绪状态，确保公平性（如轮转调度）[^3]； - **消息队列**：分布式系统中异步处理请求，解耦生产者和消费者； - **广度优先搜索（BFS）**：遍历图或树时，按层级访问节点。 #### 4. **代码示例** **栈的实现（Python）**： ```python class Stack: def __init__(self): self.items = [] def push(self, x): self.items.append(x) def pop(self): return self.items.pop() if self.items else None def is_empty(self): return len(self.items) == 0 ``` **队列的实现（Python）**： ```python from collections import deque class Queue: def __init__(self): self.items = deque() def enqueue(self, x): self.items.append(x) def dequeue(self): return self.items.popleft() if self.items else None ``` #### 5. **关键问题与扩展** - **栈溢出**：递归过深可能导致栈空间耗尽，需注意递归终止条件； - **循环队列**：通过固定长度数组和指针实现队列，避免数据迁移的开销； - **线程安全队列**：多线程环境下需使用锁或原子操作保证一致性。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值