数据结构——栈和队列

最新推荐文章于 2025-07-08 19:52:11 发布
转载 最新推荐文章于 2025-07-08 19:52:11 发布 · 4.2k 阅读 · 10


1．栈

1.1 栈的定义

栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示：


结论：后进先出（Last In First Out），简称为LIFO线性表。

栈的基本运算有六种：

构造空栈：InitStack(S)、

判栈空: StackEmpty(S)、

判栈满： StackFull(S)、

进栈： Push(S,x)、可形象地理解为压入，这时栈中会多一个元素

退栈： Pop(S) 、 可形象地理解为弹出，弹出后栈中就无此元素了。

取栈顶元素：StackTop(S),不同与弹出，只是使用栈顶元素的值，该元素仍在栈顶不会改变。

    由于栈也是线性表，因此线性表的存储结构对栈也适用，通常栈有顺序栈和链栈两种存储结构，这两种存储结构的不同，则使得实现栈的基本运算的算法也有所不同。

我们要了解的是，在顺序栈中有"上溢"和"下溢"的概念。顺序栈好比一个盒子，我们在里头放了一叠书，当我们要用书的话只能从第一本开始拿(你会把盒子翻过来吗?真聪明^^)，那么当我们把书本放到这个栈中超过盒子的顶部时就放不下了(叠上去的不算，哼哼)，这时就是"上溢","上溢"也就是栈顶指针指出栈的外面，显然是出错了。反之，当栈中已没有书时，我们再去拿，看看没书，把盒子拎起来看看盒底，还是没有，这就是"下溢"。"下溢"本身可以表示栈为空栈,因此可以用它来作为控制转移的条件。

链栈则没有上溢的限制，它就象是一条一头固定的链子，可以在活动的一头自由地增加链环(结点)而不会溢出，链栈不需要在头部附加头结点，因为栈都是在头部进行操作的，如果加了头结点，等于要在头结点之后的结点进行操作，反而使算法更复杂，所以只要有链表的头指针就可以了。


1.2 栈的顺序存储

使用c++的面向对象封装：

[cpp] view plain copy print ?
  1. // Test.cpp : Defines the entry point for the console application.  
  2. //  
  3. #include "stdafx.h"    
  4. #include <iostream>  
  5. using namespace std;  
  6. #define MAX 10 // MAXIMUM STACK CONTENT  
  7. class stack     
  8. {     
  9. private:     
  10.     int arr[MAX];   
  11.     int top;   
  12. public:     
  13.     stack()   
  14.     {     
  15.         inItStack();   
  16.     }  
  17.     /************************************************************************/  
  18.     /* 初始化栈                                                                     */  
  19.     /************************************************************************/  
  20.     void inItStack()   
  21.     {   
  22.         top=-1;   
  23.     }   
  24.     /************************************************************************/  
  25.     /* 入栈                                                                     */  
  26.     /************************************************************************/  
  27.     void push(int a)   
  28.     {     
  29.         top++;  
  30.         if(top < MAX)  {     
  31.             arr[top]=a;   
  32.         }   else   {     
  33.             cout<<"STACK FULL!!"<<top;     
  34.         }     
  35.     }     
  36.     /************************************************************************/  
  37.     /* 出栈                                                                     */  
  38.     /************************************************************************/  
  39.     int pop()  
  40.     {      
  41.         if(isEmpty())   {     
  42.             cout<<"STACK IS EMPTY ";  
  43.             return NULL;     
  44.         } else {     
  45.             int data=arr[top];   
  46.             arr[top]=NULL;   
  47.             top--;  
  48.             return data;   
  49.         }     
  50.     }     
  51.   
  52.     /************************************************************************/  
  53.     /* 是否为空                                                                     */  
  54.     /************************************************************************/  
  55.     bool isEmpty()  
  56.     {  
  57.         if(top == -1) return true;  
  58.         else return false;  
  59.     }  
  60. };     
  61. int main()     
  62. {     
  63.     stack a;     
  64.     a.push(3);     
  65.     a.push(10);     
  66.     a.push(1);     
  67.     cout<<"Pop:"<<a.pop();        
  68.     return 0;     
  69. }  
// Test.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"  
#include <iostream>
using namespace std;
#define MAX 10 // MAXIMUM STACK CONTENT
class stack   
{   
private:   
	int arr[MAX]; 
	int top; 
public:   
	stack() 
	{   
		inItStack(); 
	}
	/************************************************************************/
	/* 初始化栈                                                                     */
	/************************************************************************/
	void inItStack() 
	{ 
		top=-1; 
	} 
	/************************************************************************/
	/* 入栈                                                                     */
	/************************************************************************/
	void push(int a) 
	{   
		top++;
		if(top < MAX)  {   
			arr[top]=a; 
		}   else   {   
			cout<<"STACK FULL!!"<<top;   
		}   
	}   
	/************************************************************************/
	/* 出栈                                                                     */
	/************************************************************************/
	int pop()
	{    
		if(isEmpty())   {   
			cout<<"STACK IS EMPTY ";
			return NULL;   
		} else {   
			int data=arr[top]; 
			arr[top]=NULL; 
			top--;
			return data; 
		}   
	}   

	/************************************************************************/
	/* 是否为空                                                                     */
	/************************************************************************/
	bool isEmpty()
	{
		if(top == -1) return true;
		else return false;
	}
};   
int main()   
{   
	stack a;   
	a.push(3);   
	a.push(10);   
	a.push(1);   
	cout<<"Pop:"<<a.pop();      
	return 0;   
}
结论：由于栈的插入和删除操作具有它的特殊性，所以用顺序存储结构表示的栈并不存在插入删除数据元素时需要移动的问题，但栈容量难以扩充的弱点仍就没有摆脱。

1.3 栈的链式存储
若是栈中元素的数目变化范围较大或不清楚栈元素的数目，就应该考虑使用链式存储结构。人们将用链式存储结构表示的栈称作"链栈"。链栈通常用一个无头结点的单链表表示。如图所示：


栈的操作是线性表操作的特例。

简单用c实现：

[cpp] view plain copy print ?
  1. // Test.cpp : Defines the entry point for the console application.    
  2. //    
  3. #include "stdafx.h"    
  4. #include <stdio.h>    
  5. #include "stdlib.h"  
  6. #include <iostream>  
  7. using namespace std;  
  8. //宏定义    
  9. #define TRUE   1    
  10. #define FALSE   0    
  11. #define OK    1    
  12. #define ERROR   0    
  13. #define INFEASIBLE -1    
  14. #define OVERFLOW -2   
  15. #define STACKEMPTY -3    
  16.   
  17. #define LT(a,b)   ((a)<(b))    
  18. #define N = 100           
  19.   
  20. typedef int Status;    
  21. typedef int ElemType;    
  22.   
  23. typedef struct LNode{    
  24.     ElemType        data;                 
  25.     struct LNode   *next;       
  26. }LNode, *LinkList;   
  27.   
  28. typedef struct stack{  
  29.     LinkList top;  
  30. } STACK;  
  31.   
  32.   
  33. /************************************************************************/  
  34. /*     接口： 
  35. */  
  36. /************************************************************************/  
  37. void InitStack(STACK &S);  
  38. void Push(STACK &S,ElemType e);  
  39. void Pop(STACK &S, ElemType *e);  
  40. ElemType GetTop(STACK S,ElemType *e);  
  41. int StackEmpty(STACK S);  
  42.   
  43. /************************************************************************/  
  44. /*  
  45. */  
  46. /************************************************************************/  
  47. void InitStack(STACK &S)  
  48. {  
  49.     S.top=NULL;  
  50. }  
  51.   
  52. /************************************************************************/  
  53. /* 入栈  
  54. */  
  55. /************************************************************************/  
  56. void Push(STACK &S,ElemType e)  
  57. {  
  58.     LinkList p;  
  59.     p = (LinkList )malloc(sizeof(LNode));  
  60.     if (!p) exit(OVERFLOW);  
  61.     p->data = e;  
  62.     p->next = S.top;  
  63.     S.top = p;  
  64. }  
  65. /************************************************************************/  
  66. /* 出栈 
  67. */  
  68. /************************************************************************/  
  69. void Pop(STACK &S, ElemType *e)  
  70. {  
  71.     LinkList p;  
  72.     if(StackEmpty(S)) exit(STACKEMPTY);  
  73.     *e = S.top->data;  
  74.     p = S.top;  
  75.     S.top = p->next;   
  76.     free(p);  
  77. }  
  78. /************************************************************************/  
  79. /* 获取栈顶元素内容 
  80. */  
  81. /************************************************************************/  
  82. ElemType GetTop(STACK S, ElemType *e)  
  83. {  
  84.     if(StackEmpty(S)) exit(STACKEMPTY);  
  85.     *e = S.top->data;  
  86. }  
  87.   
  88. /************************************************************************/  
  89. /* 判断栈S是否空  
  90. */  
  91. /************************************************************************/  
  92. int StackEmpty(STACK S)   
  93. {  
  94.     if(S.top==NULL) return TRUE;  
  95.     return   FALSE;  
  96. }  
  97.   
  98. void main()    
  99. {    
  100.   
  101.     STACK S;  
  102.     InitStack( S);  
  103.     Push(S, 3);  
  104.     Push(S, 4);  
  105.     ElemType e;  
  106.     Pop(S,&e);  
  107.     cout<<"Pop elem:"<<e;  
  108. }    
// Test.cpp : Defines the entry point for the console application.  
//  
#include "stdafx.h"  
#include <stdio.h>  
#include "stdlib.h"
#include <iostream>
using namespace std;
//宏定义  
#define TRUE   1  
#define FALSE   0  
#define OK    1  
#define ERROR   0  
#define INFEASIBLE -1  
#define OVERFLOW -2 
#define STACKEMPTY -3  

#define LT(a,b)   ((a)<(b))  
#define N = 100         

typedef int Status;  
typedef int ElemType;  

typedef struct LNode{  
	ElemType		data;               
	struct LNode   *next;     
}LNode, *LinkList; 

typedef struct stack{
	LinkList top;
} STACK;


/************************************************************************/
/*     接口：
*/
/************************************************************************/
void InitStack(STACK &S);
void Push(STACK &S,ElemType e);
void Pop(STACK &S, ElemType *e);
ElemType GetTop(STACK S,ElemType *e);
int StackEmpty(STACK S);

/************************************************************************/
/* 
*/
/************************************************************************/
void InitStack(STACK &S)
{
	S.top=NULL;
}

/************************************************************************/
/* 入栈 
*/
/************************************************************************/
void Push(STACK &S,ElemType e)
{
	LinkList p;
	p = (LinkList )malloc(sizeof(LNode));
	if (!p) exit(OVERFLOW);
	p->data = e;
	p->next = S.top;
	S.top = p;
}
/************************************************************************/
/* 出栈
*/
/************************************************************************/
void Pop(STACK &S, ElemType *e)
{
	LinkList p;
	if(StackEmpty(S)) exit(STACKEMPTY);
	*e = S.top->data;
	p = S.top;
	S.top = p->next; 
	free(p);
}
/************************************************************************/
/* 获取栈顶元素内容
*/
/************************************************************************/
ElemType GetTop(STACK S, ElemType *e)
{
	if(StackEmpty(S)) exit(STACKEMPTY);
	*e = S.top->data;
}

/************************************************************************/
/* 判断栈S是否空 
*/
/************************************************************************/
int StackEmpty(STACK S) 
{
	if(S.top==NULL) return TRUE;
	return   FALSE;
}

void main()  
{  

	STACK S;
	InitStack( S);
	Push(S, 3);
	Push(S, 4);
	ElemType e;
	Pop(S,&e);
	cout<<"Pop elem:"<<e;
}

1.4 栈的应用

1)  数制转换

2）语法词法分析

3）表达式求值等


1.5 栈的递归和实现

汉诺塔的问题：

解决：

1）如果有一个盘子，直接从X移到Z即可。
2）如果有n个盘子要从X移到Z，Y作为辅助。问题可以转化为，先将上面n-1个从X移动到Y，Z作为辅助，然后将第n个从X移动到Z，最后将剩余的n-1个从Y移动到Z，X作为辅助。

完整实现代码，包括栈的实现：

[cpp] view plain copy print ?
  1. // Test.cpp : Defines the entry point for the console application.    
  2. //    
  3. #include "stdafx.h"    
  4. #include <stdio.h>    
  5. #include "stdlib.h"  
  6. #include <iostream>  
  7. using namespace std;  
  8. //宏定义    
  9. #define TRUE   1    
  10. #define FALSE   0    
  11. #define OK    1    
  12. #define ERROR   0    
  13. #define INFEASIBLE -1    
  14. #define OVERFLOW -2   
  15. #define STACKEMPTY -3    
  16.   
  17. #define LT(a,b)   ((a)<(b))    
  18. #define N = 100           
  19.   
  20. typedef int Status;    
  21. typedef int ElemType;    
  22.   
  23. typedef struct LNode{    
  24.     ElemType        data;                 
  25.     struct LNode   *next;       
  26. }LNode, *LinkList;   
  27.   
  28. typedef struct stack{  
  29.     LinkList top;  
  30. } STACK;  
  31.   
  32.   
  33. /************************************************************************/  
  34. /*     接口： 
  35. */  
  36. /************************************************************************/  
  37. void InitStack(STACK &S);  
  38. void Push(STACK &S,ElemType e);  
  39. void Pop(STACK &S, ElemType *e);  
  40. ElemType GetTop(STACK S,ElemType *e);  
  41. int StackEmpty(STACK S);  
  42.   
  43. /************************************************************************/  
  44. /*  
  45. */  
  46. /************************************************************************/  
  47. void InitStack(STACK &S)  
  48. {  
  49.     S.top=NULL;  
  50. }  
  51.   
  52. /************************************************************************/  
  53. /* 入栈  
  54. */  
  55. /************************************************************************/  
  56. void Push(STACK &S,ElemType e)  
  57. {  
  58.     LinkList p;  
  59.     p = (LinkList )malloc(sizeof(LNode));  
  60.     if (!p) exit(OVERFLOW);  
  61.     p->data = e;  
  62.     p->next = S.top;  
  63.     S.top = p;  
  64. }  
  65. /************************************************************************/  
  66. /* 出栈 
  67. */  
  68. /************************************************************************/  
  69. void Pop(STACK &S, ElemType *e)  
  70. {  
  71.     LinkList p;  
  72.     if(StackEmpty(S)) exit(STACKEMPTY);  
  73.     *e = S.top->data;  
  74.     p = S.top;  
  75.     S.top = p->next;   
  76.     free(p);  
  77. }  
  78. /************************************************************************/  
  79. /* 获取栈顶元素内容  
  80.  
  81. */  
  82. /************************************************************************/  
  83. ElemType GetTop(STACK S, ElemType *e)  
  84. {  
  85.     if(StackEmpty(S)) exit(STACKEMPTY);  
  86.     *e = S.top->data;  
  87. }  
  88. void printStack(STACK S){  
  89.     LinkList p;  
  90.     p = S.top;  
  91.     printf("栈： ");  
  92.     while (p) {  
  93.         printf("%d ", p->data);  
  94.         p = p->next;  
  95.     }  
  96. }  
  97. /************************************************************************/  
  98. /* 如果有一个盘子，直接从X移到Z即可。 
  99. 如果有n个盘子要从X移到Z，Y作为辅助。问题可以转化为，先将上面n-1个从X移动到Y，Z作为辅助，然后将第n个从X移动到Z，最后将剩余的n-1个从Y移动到Z，X作为辅助。 
  100. */  
  101. /************************************************************************/  
  102.   
  103. void move(STACK &Sa,STACK &Sb)  
  104. {     
  105.     ElemType e;  
  106.     Pop(Sa,&e);  
  107.     Push(Sb, e);  
  108. }  
  109. void hanoi(int n,STACK  &X,STACK &Y,STACK &Z)  
  110. {  
  111.     if(n==1) return move(X, Z);     //将圆盘1号直接移到z  
  112.     hanoi(n-1,X,Z,Y);               //将x上的1大n-1圆盘移到y，z做辅助塔  
  113.     move(X, Z);                     //将编号为n的圆盘移z  
  114.     hanoi(n-1,Y,X,Z);               //将y上的1大n-1圆盘移到z，x做辅助塔  
  115. }  
  116.   
  117. /************************************************************************/  
  118. /* 判断栈S是否空  
  119. */  
  120. /************************************************************************/  
  121. int StackEmpty(STACK S)   
  122. {  
  123.     if(S.top==NULL) return TRUE;  
  124.     return   FALSE;  
  125. }  
  126.   
  127. void main()    
  128. {    
  129.   
  130.     STACK Sx, Sy,Sz;  
  131.     InitStack( Sx);  
  132.     InitStack( Sy);  
  133.     InitStack( Sz);  
  134.     int i, n = 10;  
  135.     for (i = 10 ; i>=1 ;i--) {  
  136.         Push(Sx, i);  
  137.     }  
  138.     printStack(Sx);  
  139.     hanoi(n,  Sx,Sy,Sz);  
  140.     printStack(Sz);  
  141. }    
// Test.cpp : Defines the entry point for the console application.  
//  
#include "stdafx.h"  
#include <stdio.h>  
#include "stdlib.h"
#include <iostream>
using namespace std;
//宏定义  
#define TRUE   1  
#define FALSE   0  
#define OK    1  
#define ERROR   0  
#define INFEASIBLE -1  
#define OVERFLOW -2 
#define STACKEMPTY -3  

#define LT(a,b)   ((a)<(b))  
#define N = 100         

typedef int Status;  
typedef int ElemType;  

typedef struct LNode{  
	ElemType		data;               
	struct LNode   *next;     
}LNode, *LinkList; 

typedef struct stack{
	LinkList top;
} STACK;


/************************************************************************/
/*     接口：
*/
/************************************************************************/
void InitStack(STACK &S);
void Push(STACK &S,ElemType e);
void Pop(STACK &S, ElemType *e);
ElemType GetTop(STACK S,ElemType *e);
int StackEmpty(STACK S);

/************************************************************************/
/* 
*/
/************************************************************************/
void InitStack(STACK &S)
{
	S.top=NULL;
}

/************************************************************************/
/* 入栈 
*/
/************************************************************************/
void Push(STACK &S,ElemType e)
{
	LinkList p;
	p = (LinkList )malloc(sizeof(LNode));
	if (!p) exit(OVERFLOW);
	p->data = e;
	p->next = S.top;
	S.top = p;
}
/************************************************************************/
/* 出栈
*/
/************************************************************************/
void Pop(STACK &S, ElemType *e)
{
	LinkList p;
	if(StackEmpty(S)) exit(STACKEMPTY);
	*e = S.top->data;
	p = S.top;
	S.top = p->next; 
	free(p);
}
/************************************************************************/
/* 获取栈顶元素内容 

*/
/************************************************************************/
ElemType GetTop(STACK S, ElemType *e)
{
	if(StackEmpty(S)) exit(STACKEMPTY);
	*e = S.top->data;
}
void printStack(STACK S){
	LinkList p;
	p = S.top;
	printf("栈： ");
	while (p) {
		printf("%d ", p->data);
		p = p->next;
	}
}
/************************************************************************/
/* 如果有一个盘子，直接从X移到Z即可。
如果有n个盘子要从X移到Z，Y作为辅助。问题可以转化为，先将上面n-1个从X移动到Y，Z作为辅助，然后将第n个从X移动到Z，最后将剩余的n-1个从Y移动到Z，X作为辅助。
*/
/************************************************************************/

void move(STACK &Sa,STACK &Sb)
{	
	ElemType e;
	Pop(Sa,&e);
	Push(Sb, e);
}
void hanoi(int n,STACK  &X,STACK &Y,STACK &Z)
{
	if(n==1) return move(X, Z);		//将圆盘1号直接移到z
	hanoi(n-1,X,Z,Y);				//将x上的1大n-1圆盘移到y，z做辅助塔
	move(X, Z);						//将编号为n的圆盘移z
	hanoi(n-1,Y,X,Z);			    //将y上的1大n-1圆盘移到z，x做辅助塔
}

/************************************************************************/
/* 判断栈S是否空 
*/
/************************************************************************/
int StackEmpty(STACK S) 
{
	if(S.top==NULL) return TRUE;
	return   FALSE;
}

void main()  
{  

	STACK Sx, Sy,Sz;
	InitStack( Sx);
	InitStack( Sy);
	InitStack( Sz);
	int i, n = 10;
	for (i = 10 ; i>=1 ;i--) {
		Push(Sx, i);
	}
	printStack(Sx);
	hanoi(n,  Sx,Sy,Sz);
	printStack(Sz);
}


1．队列

1.1 队列定义 

队列(Queue)也是一种运算受限的线性表，它的运算限制与栈不同，是两头都有限制，插入只能在表的一端进行(只进不出)，而删除只能在表的另一端进行(只出不进)，允许删除的一端称为队尾(rear)，允许插入的一端称为队头 (Front)

,队列的操作原则是先进先出的，所以队列又称作FIFO表(First In First Out)

队列的基本运算也有六种：

置空队 ：InitQueue(Q)

判队空： QueueEmpty(Q)

判队满： QueueFull(Q)

入队 ： EnQueue(Q,x)

出队 ： DeQueue(Q)

取队头元素： QueueFront(Q),不同与出队，队头元素仍然保留。

队列也有顺序存储和链式存储两种存储结构，前者称顺序队列，后者为链队。

对于顺序队列，我们要理解"假上溢"的现象。

我们现实中的队列比如人群排队买票，队伍中的人是可以一边进去从另一头出来的，除非地方不够，总不会有"溢出"的现象，相似地，当队列中元素完全充满这个向量空间时，再入队自然就会上溢，如果队列中已没有元素，那么再要出队也会下溢。

那么"假上溢"就是怎么回事呢?

因为在这里，我们的队列是存储在一个向量空间里，在这一段连续的存储空间中，由一个队列头指针和一个尾指针表示这个队列，当头指针和尾指针指向同一个位置时，队列为空，也就是说，队列是由两个指针中间的元素构成的。在队列中，入队和出队并不是象现实中，元素一个个地向前移动，走完了就没有了,而是指针在移动，当出队操作时，头指针向前(即向量空间的尾部)增加一个位置，入队时，尾指针向前增加一个位置，在某种情况下，比如说进一个出一个，两个指针就不停地向前移动，直到队列所在向量空间的尾部，这时再入队的话，尾指针就要跑到向量空间外面去了，仅管这时整个向量空间是空的，队列也是空的，却产生了"上溢"现象，这就是假上溢。

为了克服这种现象造成的空间浪费，我们引入循环向量的概念，就好比是把向量空间弯起来，形成一个头尾相接的环形，这样，当存于其中的队列头尾指针移到向量空间的上界(尾部)时，再加1的操作(入队或出队)就使指针指向向量的下界，也就是从头开始。这时的队列就称循环队列。

通常我们应用的大都是循环队列。由于循环的原因，光看头尾指针重叠在一起我们并不能判断队列是空的还是满的，这时就需要处理一些边界条件，以区别队列是空还是满。方法至少有三种，一种是另设一个布尔变量来判断(就是请别人看着，是空还是满由他说了算)，第二种是少用一个元素空间，当入队时，先测试入队后尾指针是不是会等于头指针，如果相等就算队已满，不许入队。第三种就是用一个计数器记录队列中的元素的总数，这样就可以随时知道队列的长度了，只要队列中的元素个数等于向量空间的长度，就是队满。


2.2 队列的顺序存储

顺序存储如图：


由于是顺序存储结构的存储空间是静态分配的，所以在添加数据的时，有可能没有剩余空间的情况。

解决这种“假溢出”情况，使用循环队列。在C语言中，不能用动态分配的一维数组来实现循环队列。若使用循环队列，必须设置最大队列长度，若无法估计最大长度，就使用链式队列。

c实现：

#include "stdafx.h"    
#include <stdio.h>    
#include "stdlib.h"  
#include <iostream>  
using namespace std;  
//宏定义    
#define TRUE   1    
#define FALSE   0    
#define OK    1    
#define ERROR   0    
#define INFEASIBLE -1    
#define OVERFLOW -2   
#define QUEUEEMPTY  -3    
        
#define MAX_QUEUE 10 //队列的最大数据元素数目  
  
typedef int Status;    
typedef int ElemType;    
  
typedef struct queue{    
    ElemType        elem[MAX_QUEUE] ;     ///假设当数组只剩下一个单元时认为队满            
    int front;      //队头指针  
  int rear;       //队尾指针     
}QUEUE;   
  
  
/************************************************************************/  
/*     各项基本操作算法。 
*/  
/************************************************************************/  
void InitQueue(QUEUE *&Q);  
void EnQueue(QUEUE *Q,ElemType elem);  
void DeQueue(QUEUE *Q,ElemType *elem);  
int QueueEmpty(QUEUE Q);  
  
/************************************************************************/  
/*  
  初始化 
  直接使用结构体指针变量，必须先分配内存地址，即地址的指针 
*/  
/************************************************************************/  
void InitQueue(QUEUE *&Q)   
{  
  
    Q = (QUEUE *) malloc (sizeof(QUEUE));  
    Q->front = Q->rear = -1;  
  
}  
/************************************************************************/  
/*     入队                                                               
*/  
/************************************************************************/  
   
void EnQueue(QUEUE *Q, ElemType elem)  
{  
    if((Q->rear+1)% MAX_QUEUE == Q->front) exit(OVERFLOW);  
    Q->rear = (Q->rear + 1)%MAX_QUEUE;  
    Q->elem[Q->rear] = elem;   
}  
/************************************************************************/  
/*     出队                                                                
*/  
/************************************************************************/  
void DeQueue(QUEUE *Q,ElemType *elem)  
{  
    if (QueueEmpty(*Q))  exit(QUEUEEMPTY);  
    Q->front =  (Q->front+1) % MAX_QUEUE;  
    *elem=Q->elem[Q->front];  
}  
/************************************************************************/  
    获取队头元素内容                                                             
*/  
/************************************************************************/  
  
void GetFront(QUEUE Q,ElemType *elem)   
{  
    if ( QueueEmpty(Q) )  exit(QUEUEEMPTY);  
    *elem = Q.elem[ (Q.front+1) % MAX_QUEUE ];  
}  
/************************************************************************/  
/*    判断队列Q是否为空                                                              
*/  
/************************************************************************/  
int QueueEmpty(QUEUE Q)  
{  
    if(Q.front==Q.rear) return TRUE;  
    else return FALSE;  
}  
  
void main()    
{    
  
    QUEUE *Q;  
    InitQueue( Q);  
    EnQueue( Q, 1);  
    EnQueue( Q, 2);  
    ElemType e;  
    DeQueue( Q,&e);  
    cout<<"De queue:"<<e;  
}


注意：InitQueue(QUEUE *&Q) 传的是指针的地址。


2.3 链式队列：

#include "stdafx.h"    
#include <stdio.h>    
#include "stdlib.h"  
#include <iostream>  
using namespace std;  
//宏定义    
#define TRUE   1    
#define FALSE   0    
#define OK    1    
#define ERROR   0    
#define INFEASIBLE -1    
#define OVERFLOW -2   
#define QUEUEEMPTY  -3    
        
  
typedef int Status;    
typedef int ElemType;    
  
typedef struct LNode {          //链式队列的结点结构  
    ElemType elem;          //队列的数据元素类型  
    struct LNode *next;      //指向后继结点的指针  
}LNode, *LinkList;  
  
typedef struct queue{   //链式队列  
    LinkList front;     //队头指针  
    LinkList rear;      //队尾指针  
}QUEUE;   
  
/************************************************************************/  
//     各项基本操作算法。 
  
/************************************************************************/  
void InitQueue(QUEUE *Q);  
void EnQueue(QUEUE *Q,ElemType elem);  
void DeQueue(QUEUE *Q,ElemType *elem);  
void GetFront(QUEUE Q,ElemType *elem) ;  
bool QueueEmpty(QUEUE Q);  
  
/************************************************************************/  
  
  
/*初始化队列Q  */  
void InitQueue(QUEUE *Q)  
{  
    Q->front = (LinkList)malloc(sizeof(LNode));  
    if (Q->front==NULL) exit(ERROR);  
    Q->rear= Q->front;  
}  
/*入队 */   
void EnQueue(QUEUE *Q,ElemType elem)  
{  
    LinkList s;  
    s = (LinkList)malloc(sizeof(LNode));  
    if(!s) exit(ERROR);  
    s->elem = elem;  
    s->next = NULL;  
    Q->rear->next = s;  
    Q->rear = s;  
}  
  
/*出队  */   
void DeQueue(QUEUE *Q,ElemType *elem)  
{  
    LinkList s;  
    if(QueueEmpty(*Q)) exit(ERROR);  
    *elem = Q->front->next->elem;  
    s = Q->front->next;  
    Q->front->next = s->next;  
    free(s);  
}  
/*获取队头元素内容  */   
  
void GetFront(QUEUE Q,ElemType *elem)   
{  
        if(QueueEmpty(Q)) exit(ERROR);  
    *elem = Q.front->next->elem;  
}  
/*判断队列Q是否为空   */   
bool QueueEmpty(QUEUE Q)  
{  
    if(Q.front == Q.rear) return TRUE;  
    return FALSE;  
}  
  
void main()    
{    
  
    QUEUE Q;  
    InitQueue( &Q);  
    EnQueue( &Q, 1);  
    EnQueue( &Q, 2);  
    ElemType e;  
    DeQueue( &Q,&e);  
    cout<<"De queue:"<<e;  
}


2. 4．队列的应用
【举例 1 】银行排队
【举例 2 】模拟打印机缓冲区。
在主机将数据输出到打印机时，会出现主机速度与打印机的打印速度不匹配的问题。这时主机就要停下来等待打印机。显然，这样会降低主机的使用效率。为此人们设想了一种办法：为打印机设置一个打印数据缓冲区，当主机需要打印数据时，先将数据依次写入这个缓冲区，写满后主机转去做其他的事情，而打印机就从缓冲区中按照先进先出的原则依次读取数据并打印，这样做即保证了打印数据的正确性，又提高了主机的使用效率。由此可见，打印机缓冲区实际上就是一个队列结构。
【举例 3 】 CPU 分时系统
在一个带有多个终端的计算机系统中，同时有多个用户需要使用 CPU 运行各自的应用程序，它们分别通过各自的终端向操作系统提出使用 CPU 的请求，操作系统通常按照每个请求在时间上的先后顺序，将它们排成一个队列，每次把 CPU 分配给当前队首的请求用户，即将该用户的应用程序投入运行，当该程序运行完毕或用完规定的时间片后，操作系统再将 CPU 分配给新的队首请求用户，这样即可以满足每个用户的请求，又可以使 CPU 正常工作。

    

52jingmin
关注
栈和队列学习总结
Marmara
04-04 1万+
一、栈 1、特点及应用 先进后出。（如果会和队列先进先出记混的话，就记场景吧：弹栈弹栈，就是把最上面的最新进来的弹出去；而队列就像我们火车站排队检票出站一样，谁排在前面谁就先出去。） 应用的话，其实我们经常接触呀。比如Undo操作（就是撤销操作）就是使用的栈的思想，以及程序调用的系统栈。下面我们举一个经典的括号匹配的例子： 题目要求： 给定一个只包括...
栈与队列
Programmer's Way
02-12 256
栈 栈是限定仅在表尾进行插入和操作的线性表；允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈，栈又称后进先出的线性表(即LIFO结构) 栈是特殊的线性表(限制了这个线性表的插入和删除位置)，有前驱和后继关系，线性表的表尾是指栈顶，栈顶是固定的 栈的插入(push)操作叫进栈(压栈、入栈)，删除(pop)操作叫出栈(弹栈) 顺序栈(栈的顺序存储结构) 当栈...
数据结构-栈和队列
weixin_30636089的博客
06-19 2258
1．栈 1.1栈的定义 栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示： 结论：后进先出（Last In First Out），简称为LIFO线性表。 栈的基本运算有六种： 构造空栈：InitStack(S)、 判栈空: StackEmpty(S)、 判栈满：StackFull(S)、 ...
栈和队列（数据结构学习笔记）
最新发布
2401_87777360的博客
07-08 919
栈（stack）是一个特殊的线性表，是限定仅在一端（通常是表尾）进行插入和删除的线性表。又称为后进先出（Last In First Out）的线性表,简称LIFO结构。栈是仅在表尾进行插入、删除的线性表。表尾（即an端）称为栈顶Top;表头（即a1端）称为栈底Base。插入元素到栈顶（即表尾）的操作，称为入栈。“入”=压入=PUSH(x)从栈顶（即表尾）删除最后一个元素的操作，称为出栈。“出”=弹出=POP(y)队列（queue）是一种。
C++实现的任意进制转换（数据结构——栈和队列）
08-10
本文将深入探讨如何使用C++语言实现任意进制转换，特别是涉及到小数部分的处理，并结合数据结构中的栈和队列进行阐述。C++作为一门强大的静态类型语言，其丰富的库支持和高效性能使得它成为实现这种算法的理想选择。...
栈 和 队列
weixin_47270825的博客
04-02 762
栈和队列前言一、栈和队列二、栈1.2.3.三、队列1.2.3.总结 前言 一、栈和队列 栈和队列：都是线性表，都是基于List基础上的实现 线性表：数组，链表，字符串，栈，队列 元素按照一条"直线"排列，线性表这个结构中，一次添加单个元素 非线性结构：树，图 栈和队列是一个使用更加严格的线性表 动态数组，链表可以在任意位置进行插入和删除，栈和队列不可以 二、栈 1. 2. 3. 三、队列 1. 2. 3. 总结 ...
栈和队列
weixin_43319635的博客
02-27 184
一、栈 栈（stack）是运算受限的线性表，只允许在表的一端进行添加和删除（先进后出，后进先出） 插入删除的一端叫做栈顶（top)，表的另一端叫栈底（bottom） 插入–>进栈（push) 删除–>出栈(pop) 得到栈顶元素（Peek） 栈的存储结构 顺序栈，类似于顺序表，底层使用数组 链栈，类似于单链表，节点 二、队列 队列（queue）简称队，也是一种运算受限的线性表，只允许...
递归工作栈与数据结构——栈和队列解析
"这篇内容主要介绍了C语言中的数据结构——栈和队列，特别是递归工作栈的概念。栈是一种后进先出（LIFO）的数据结构，常用于递归调用中的存储。" 栈和队列是计算机科学中两种基本的数据结构。栈是一种特殊的线性表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值