数据结构精录&总结Episode.3 数据结构入门之栈和队列详解（基于Visual C++）

通信作业做了一整个晚上，突然想起自己今天忘记更新博文了。。难顶。。

然而做信息论作业的时候，我突然想起之前和小组成员研究香农编码方法的C语言实现时，正好就用到了队列算法的一点点思想解决编码过程中反复迭代对比的工序，这也许是一种巧合，更多的还是证明了最最基本的数据结构算法在工程上的强大应用潜力。

之前记得看到过一篇IT杂志上的文章，讲的是拥有十年从业经验的顶级高校毕业的软件工程师，面试新公司时被要求说出刚进大学时初学的数据结构知识却哑口无言的故事。这就好比我们虽然拥有了Matlab也要学习数值计算，拥有了仿真软件也要学习中考高考的电路题一样。知识可以被集成而简化使用，但是不会被架空。

---

提到栈与队列，不管是参加期末考试、考研还是应聘面试，不能不熟记这些知识点：

一、定义：

栈（Stack）是一个后进先出（Last in first out,LIFO）的线性表，它要求只在表尾进行删除和插入操作

队列是限定只能在表的一端进行插入，在表的另一端进行删除的特殊的线性表

二、特点：

栈：

1、栈是特殊的线性表（顺序表、链表），它在操作上有一些特殊的要求和限制：栈的元素必须“后进先出”

2、栈的表尾称为栈的栈顶（top），相应的表头称为栈底（bottom）

3、栈的操作只能在这个线性表的表尾进行

队列：

4、队列是先进先出（FIFO, First-In-First-Out）的线性表

5、队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作

三、区别：

栈和队列是两种实现完全不同目的和功能的结构，同时他们的操作本质也不同例如我们在说存储方面“堆栈”肯定不会说成“堆队列”

1、队列只允许新数据在后端进行添加

2、栈先进后出，队列先进后出

 

栈对于学习计算机的人来说，是再熟悉不过的东西了，很多东西都需要用栈来存储，像是操作系统就会给每个线程创建一个栈用来存储函数调用时各个函数的参数，返回地址及临时变量等，函数本身也有一个函数栈用来存储函数的局部变量等。

栈的特点就是后进先出，需要O(N)的时间才能找到栈中的最值。

队列和栈刚好相反，是先进先出，表面上和栈是一对矛盾体，但实际上，都可以利用对方来实现自己。

关于栈和队列的具体代码实现，我们将栈和队列分为顺序、链式四种类型，每种类型都有不同的结构体定义及函数操作，以下代码完整地进行了总结，同时知识要点也在注释中给出，已经过VS2019测试成功运行。

// 第三章 栈和队列.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。编写—JoeyBG,代码算法和程序排版上还有不足之处，敬请见谅
//

#include <iostream>
#include<iomanip>
#include<string.h>
#include<math.h>
#include<time.h>
using namespace std;

#define Maxsize 100  //空间分配定义常数，这里可以用于栈和队列的初始建立；

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件


/*
栈和队列一些易考知识点小结：

(1)栈、队列的定义及其相关数据结构的概念，包括：顺序栈，链栈，共享栈，循环队列，链队等。栈与队列存取数据(请注意包括：存和取两部分)的特点。
(2)递归算法。栈与递归的关系，以及借助栈将递归转向于非递归的经典算法：n!阶乘问题，fib数列问题，hanoi问题，背包问题，二叉树的递归和非递归遍历问题，图的深度遍历与栈的关系等。其中，涉及到树与图的问题，多半会在树与图的相关章节中进行考查。
(3)栈的应用：数值表达式的求解，括号的配对等的原理，只作原理性了解，具体要求考查此为题目的算法设计题不多。
(4)循环队列中判队空、队满条件，循环队列中入队与出队(循环队列在插入时也要判断其是否已满，删除时要判断其是否已空)算法，其中条件可简要总结如下：
【循环队列的队空队满条件：】
为了方便起见，约定：初始化建空队时，令
front=rear=0,
当队空时：front=rear，
当队满时：front=rear 亦成立，
因此只凭等式front=rear无法判断队空还是队满。
有两种方法处理上述问题：
(1)另设一个标志位以区别队列是空还是满。
(2)少用一个元素空间，约定以“队列头指针front在队尾指针rear的下一个位置上”作为队列“满”状态的标志。
队空时： front=rear，
队满时： (rear+1)%maxsize=front

循环队列的主要操作：
(1)创建循环队列
(2)初始化循环队列
(3)判断循环队列是否为空
(4)判断循环队列是否为满
(5)入队、出队
*/

//顺序栈的建立及操作代码
typedef struct SqStack {
	int* base; //栈底指针
	int* top; //栈顶指针
}SqStack;//顺序栈的结构体定义

bool InitStack(SqStack& S) 
{
	S.base = new int[Maxsize];//为顺序栈分配一个最大容量为Maxsize的空间
	if (!S.base)    //空间分配失败
		return false;
	S.top = S.base;  //top初始为base，空栈
	return true;
}//顺序栈的初始化代码

bool Push(SqStack& S, int e) 
{
	if (S.top - S.base == Maxsize) //栈满
		return false;
	*(S.top++) = e; //元素e压入栈顶，然后栈顶指针加1，等价于*S.top=e; S.top++;
	return true;
}//插入新的栈元素，由于栈是一个只允许头进头出的结构，因而元素e只能放在栈顶，但是不要忘记栈顶指针+1

bool Pop(SqStack& S, int& e)
{
	if (S.base == S.top) //栈空
		return false;
	e = *(--S.top); //栈顶指针减1，将栈顶元素赋给e
	return true;
}//栈删除元素的操作函数，这里只能在栈的头部进行元素的剔出，暂存在变量e中，不要忘记栈顶指针-1的操作

int GetTop(SqStack S) 
{
	if (S.top != S.base)  //栈非空
		return *(S.top - 1); //返回栈顶元素的值，栈顶指针不变
	else
		return -1;
}//取得S的栈顶元素函数，相对于栈删除元素唯一的不同在于栈顶指针不变


//链栈的操作代码详解
typedef struct Snode {
	int data; //数据域
	struct Snode* next; //指针域
}Snode, * LinkStack;//链栈的结构体定义

bool InitStack(LinkStack& S)
{
	S = NULL;
	return true;
}//链栈的初始化构造函数，直接先将头节点赋NULL即可

bool Push(LinkStack& S, int e) 
{
	LinkStack p;
	p = new Snode; //生成新结点
	p->data = e; //将e放在新结点数据域
	p->next = S; //将新结点的指针域指向S，即将S的地址赋值给新结点的指针域
	S = p;    //修改栈顶指针为p
	return true;
}//在栈顶插入元素的函数，这里我们是将新节点指向S，意味着栈虽然头进头出，但是指针链接的方向是反向的

bool Pop(LinkStack& S, int& e) 
{
	LinkStack p;
	if (S == NULL) //栈空
		return false;
	e = S->data;  //将栈顶元素赋给e
	p = S;  //用p保存栈顶元素地址，以备释放
	S = S->next;  //修改栈顶指针，指向下一个结点
	delete p;  //释放原栈顶元素的空间
	return true;
}//栈删除元素的操作函数，这里只能在栈的头部进行元素的剔出，暂存在变量e中，不要忘记释放原栈顶元素的空间，类似于上述顺序栈头指针-1操作

int GetTop(LinkStack S) 
{
	if (S != NULL) //栈非空
		return S->data; //返回栈顶元素的值，栈顶指针不变
	else
		return -1;
}//取得S的栈顶元素函数，相对于栈删除元素唯一的不同在于不用释放任何空间
//由以上四个函数的操作可以看出，链栈和链表本质上是相同的两个东西，只不过在操作上栈只能对头节点进行增删工作，实则是比链表更简单的数据结构


//循环队列的操作代码详解
typedef  struct SqQueue {
	int* base; //基地址
	int front, rear; //头指针,尾指针
}SqQueue;//循环队列的结构体定义

bool InitQueue(SqQueue& Q)//注意使用引用参数，否则出了函数，其改变无效
{
	Q.base = new int[Maxsize];//分配空间
	if (!Q.base) return false;
	Q.front = Q.rear = 0; //头指针和尾指针置为零，队列为空
	return true;
}//循环队列的初始化操作函数


bool EnQueue(SqQueue& Q, int e)//将元素e放入Q的队尾
{
	if ((Q.rear + 1) % Maxsize == Q.front) //尾指针后移一位等于头指针，表明队满
		return false;
	Q.base[Q.rear] = e; //新元素插入队尾
	Q.rear = (Q.rear + 1) % Maxsize; //队尾指针加1
	return true;
}//循环队列的入队，从尾指针处插入一个元素，同时头指针等于尾指针后移一位是队列满，不要忘记队尾指针需要模Maxsize才是步数


bool DeQueue(SqQueue& Q, int& e) //删除Q的队头元素，用e返回其值
{
	if (Q.front == Q.rear)
		return false; //队空
	e = Q.base[Q.front]; //保存队头元素
	Q.front = (Q.front + 1) % Maxsize; //队头指针加1
	return true;
}//循环队列的出队函数，删除头指针元素，头指针+1移动一位且用e暂存值

int GetHead(SqQueue Q)//返回Q的队头元素，不修改队头指针
{
	if (Q.front != Q.rear) //队列非空
		return Q.base[Q.front];
	return -1;
}//取循环队列的队头元素函数，需要判断队列非空的时候才能进行操作

int QueueLength(SqQueue Q)
{
	return (Q.rear - Q.front + Maxsize) % Maxsize;
}//循环队列的长度获取函数，直接返回长度即可，同样不要忘记模Maxsize才是步数，否则物理地址不是按一个二进制数or寄存器对应一个结构体来存的

//链队列操作代码
typedef  struct Qnode {
	int data;
	struct Qnode* next;
}Qnode, * Qptr;//链队列的结构体定义

typedef struct {
	Qnode* front;
	Qnode* rear;
}LinkQueue;//链队列的二级总控（相当于同时存储头尾指针的一个封装）

void InitQueue(LinkQueue& Q)//注意使用引用参数，否则出了函数，其改变无效
{
	Q.front = Q.rear = new Qnode; //创建头结点，头指针和尾指针指向头结点
	Q.front->next = NULL;
}//链队列的初始化函数


void EnQueue(LinkQueue& Q, int e)//将元素e放入队尾
{
	Qptr s;
	s = new Qnode;
	s->data = e;
	s->next = NULL;
	Q.rear->next = s;//新元素插入队尾
	Q.rear = s;     //队尾指针后移
}//链队列的入队函数，新元素插入队尾，不要忘记队尾指针的移动

bool DeQueue(LinkQueue& Q, int& e) //删除Q的队头元素，用e返回其值
{
	Qptr p;
	if (Q.front == Q.rear)//队空
		return false;
	p = Q.front->next;
	e = p->data;     //保存队头元素
	Q.front->next = p->next;
	if (Q.rear == p) //若队列中只有一个元素，删除后需要修改队尾指针
		Q.rear = Q.front;
	delete p;
	return true;
}//链队列的出队操作函数，从头出去，不要忘记释放空间，这与循环队列只改指针指向不同

int GetHead(LinkQueue Q)//返回Q的队头元素，不修改队头指针
{
	if (Q.front != Q.rear) //队列非空
		return Q.front->next->data;
	return -1;
}//取链队列的头元素函数，这里相对于删除是不会释放任何空间的


//各栈或队列的调用总函数及程序的主函数接口
int SqStackmain()
{
	int n, x;
	SqStack S;
	InitStack(S);//初始化一个顺序栈S
	cout << "请输入元素个数n：" << endl;
	cin >> n;
	cout << "请依次输入n个元素，依次入栈：" << endl;
	while (n--)
	{
		cin >> x; //输入元素
		Push(S, x);
	}
	cout << "元素依次出栈：" << endl;
	while (S.top != S.base)//如果栈不空，则依次出栈
	{
		cout << GetTop(S) << "\t";//输出栈顶元素
		Pop(S, x);   //栈顶元素出栈
	}
	return 0;
}//顺序栈的总调用函数

int LinkStackmain()
{
	int n, x;
	LinkStack S;
	InitStack(S);//初始化一个顺序栈S
	cout << "请输入元素个数n：" << endl;
	cin >> n;
	cout << "请依次输入n个元素，依次入栈：" << endl;
	while (n--)
	{
		cin >> x; //输入元素
		Push(S, x);
	}
	cout << "元素依次出栈：" << endl;
	while (S != NULL)//如果栈不空，则依次出栈
	{
		cout << GetTop(S) << "\t";//输出栈顶元素
		Pop(S, x);   //栈顶元素出栈
	}
	return 0;
}//链栈的总调用函数

int SqQueuemain()
{
	SqQueue Q;
	int n, x;
	InitQueue(Q);//初始化队列(一定要初始化，否则后面存储出错)
	cout << "请输入元素个数n：" << endl;
	cin >> n;
	cout << "请依次输入n个整型数，依次入队：" << endl;
	while (n--)
	{
		cin >> x;
		EnQueue(Q, x);//入队
	}
	cout << endl;
	cout << "队列内元素个数，即长度：" << QueueLength(Q) << endl;
	cout << "队头元素：" << GetHead(Q) << endl;
	cout << "元素依次出队：" << endl;
	while (true)//如果队列不空，则依次出队
	{
		if (DeQueue(Q, x))
			cout << x << "\t";//出队元素
		else
			break;
	}
	cout << endl;
	cout << "队列内元素个数，即长度：" << QueueLength(Q) << endl;
	return 0;
}//循环队列的总调用函数

int LinkQueuemain()
{
	LinkQueue Q;
	int n, x;
	InitQueue(Q);//初始化队列(一定要初始化，否则后面存储出错)
	cout << "请输入元素个数n：" << endl;
	cin >> n;
	cout << "请依次输入n个整型数，依次入队：" << endl;
	while (n--)
	{
		cin >> x;
		EnQueue(Q, x);//入队
	}
	cout << "队头元素：" << GetHead(Q) << endl;
	cout << "元素依次出队：" << endl;
	while (true)//如果栈不空，则依次出栈
	{
		if (DeQueue(Q, x))
			cout << x << "\t";//出队元素
		else
			break;
	}
	cout << endl;
	return 0;
}//链队列的总调用函数

int main()
{
	int judgenumber = 0;
	char judge = '\n';
	cout << "栈和队列学习笔记+总结代码本—编写&调试:JoeyBG,算法尚有大量不足之处，还望不吝指正！" << endl;
	cout << "------------------------------------------------------------------------------------" << endl;
	cout << endl;
labelstart:
	cout << "1、顺序栈" << endl;
	cout << "2、链栈" << endl;
	cout << "3、循环队列" << endl;
	cout << "4、链队列" << endl;
	cout << endl;
	cout << "键入你需要的栈或队列类型数字：";
	cin >> judgenumber;
	if (judgenumber == 1)
	{
		system("cls");
		SqStackmain();
	}
	else if (judgenumber == 2)
	{
		system("cls");
		LinkStackmain();
	}
	else if (judgenumber == 3)
	{
		system("cls");
		SqQueuemain();
	}
	else if (judgenumber == 4)
	{
		system("cls");
		LinkQueuemain();
	}
	else
	{
		cout << "键入数字有误!" << endl;
	}
	cout << endl;
	cout << "是否继续查看其它链表或者退出（Y/N）？";
	cin >> judge;
	if (judge == 'Y')
	{
		system("cls");
		goto labelstart;
	}
	else if (judge == 'N')
	{
		system("cls");
		exit(0);
	}
	else
	{
		cout << "键入字符有误，系统默认退出！" << endl;
		exit(0);
	}
	return 1;
}//主函数，进行初始界面及人工选择数据结构的工作


/*
参考文献：
1、速度七十迈：软考初级程序员常考知识点汇总（2）线性表和栈与队列，http://www.51mokao.com/forumpostscont.html?id=177082
2、陈小玉：趣学数据结构，人民邮电出版社，2019.09
*/

---

北京理工大学徐特立学院乐学平台关于栈和队列数据结构给出了四道程序编写练习题，依照以上总结的栈和队列操作方式，我们给出如下的代码解答：

Q1.输出学生成绩

试设计一个算法，建立一个学生成绩栈要求从键盘上输入法 N 个整数，按照下列要求分别进入不同栈，并分别输出每个栈的内容。

（1） 若输入的整数 x 小于 60 ，则进入第一个栈；

（2） 若输入的整数 x 大于等于 60 ，小于 100 ，则进入第二个栈；

（3） 若输入的整数 x 大于等于 100 ，则进入第三个栈；

#include<iostream>  

#include<queue>  

using namespace std;  

void pusha(queue<int>a)  

{  

    while(!a.empty())  

    {  

        cout<<a.front()<<" ";  

        a.pop();  

    }  

    cout<<endl;     

}  

int main()  

{  

    queue<int>r,s,t;  

    int N,x;  

    cin>>N;  

    while(N--)  

    {cin>>x;  

    if(x>=100) t.push(x);  

    else if(x<60) r.push(x);  

    else s.push(x);  

    }  

    cout<<"60>x:";pusha(r);  

    cout<<"60<=x<100:";pusha(s);  

    cout<<"x>=100:";pusha(t);  

    return 0;  

}

利用C++STL标准模板库中的队列模板省掉了复杂的函数重写工作，但是其本质与上述知识相符，详细也可参看编译器&工作站中的<queue>头文件具体代码内容。

以下是queue模板库的常用成员函数对应功能：

①size() 返回队列中元素的个数

②empty() 如果队列空则返回真 

③back() 返回最后一个元素引用即队尾

④front() 返回第一个元素引用即队首

⑤pop() 删除第一个元素，即队首元素。不返回 

⑥push() 在末尾加入一个元素，即放置在队尾 。不返回

 

Q2.括号是否配对

假设一个算术表达式可以包含三种括号：“（”和“）”，方括号“[”和“]”，及花括号“ { ”和“ } ”，且这三种括号可嵌套使用。试设计算法判断给定表达式中所含括号是否配对出现。

#include<iostream>  

#include<queue>  

using namespace std;  

int main()  

{  

    queue<char>s;  

    char x,i=1;  

    double a=0;  

    while((x=getchar())!='\n'&&i!=0)  

    {  

        s.push(x);  

        if(x=='{'||x=='['||x=='(')   {a+=x/(++i);}  

        else if(x=='}'||x==']') {a-=(x-2)/(i--);}  

        else if(x==')')  {a-=(x-1)/(i--);}  

    }  

    if(a==0)  

    cout<<"括号配对"<<endl;  

    else cout<<"括号不配对"<<endl;   

}

仍然是queue模板库的使用，但是分析这道题，和我们非常熟悉的队列应用“回文算法”如出一辙，换了个说法而已。

 

Q3.奇偶数输出

编写一个程序，任意输入n个100以内的数，将它们的奇数和偶数分别存入链队为Q1和Q2中，然后配对输出链队Q1、Q2中的值，直到任一队列为空为止。

#include<iostream>  

#include<queue>  

using namespace std;  

int main()  

{  

    queue<int>Q1,Q2;  

    int n,x;  

    cin>>n;  

    while(n--)  

    {  

        cin>>x;  

        if(x%2==0) Q2.push(x);  

        else Q1.push(x);  

    }   

    while(!Q1.empty()&&!Q2.empty())  

    {  

        cout<<Q1.front()<<" "<<Q2.front()<<endl;  

        Q1.pop();Q2.pop();  

    }  

    return 0;  

}

 

Q4.回文

利用栈和队列的特性设计一个算法，用于判断一个字符串是否为回文。

#include<iostream>  

#include<stack>  

#include<queue>  

using namespace std;  

int main()  

{  

    stack<char> s;  

    queue<char> t;  

    char c;  

    int i=0;  

    while((c=getchar())!='\n')  

    {  

        s.push(c);  

        t.push(c);  

        i++;  

    }  

    while(i--)  

    {  

        if(s.top()==t.front())  

            {s.pop();  t.pop(); }  

        else { cout<<"不";break;}  

    }  

    cout<<"是回文"<<endl;   

    return 0;  

}

回文问题是最最基础的算法实例了，在刚进大学时学习C语言程序设计已经多次接触到了它。这一次我们同时利用栈和队列模板库重写了这个算法，在代码的简洁度易读性上比C语言中首位指标缩进比对方式优化许多。