数据结构- 2 栈和队列

栈和队列

1 栈

1.1 定义和逻辑结构

stack：只能在一端进入和删除的线性表，先进后出(FILO)

1.2 存储结构

1.2.1 顺序栈

int stack[maxSize];
int top = -1;          //初始化栈顶指针
x = stack[++top];			 //入栈操作
x = stack[top--];      //出栈操作
top = -1;              //栈空状态
top = maxSize - 1;     //栈满状态

1.2.2 链式栈

//建立一个链式栈
LNode *head = (LNode*)malloc(sizeof(LNode));
head->next = NULL;
LNode *top = NULL;

//元素入栈，将栈顶元素指向头节点并且连在头节点之前
top = (LNode*)malloc(sizeof(LNode));
top->next = NULL;
top->data = 'A';    //同理，如果插入其他的节点，则将此处的A改为其他节点的值
top->next = head->next;
head->next = top;

//元素出栈，也就是删除链表中的元素
x = top->data;
head->next = top->next;
free(top);
top = head->next;

//栈空状态
head->next = NULL;   //此为真，则栈空，只要内存够大，就不存在栈满状态

2 队列

2.1逻辑结构

queue，只可在一端插入，另一端删除的线性表。可插入元素的一端叫队尾（Rear），删除的一端叫队头（Front）。先进先出，FIFO。

2.2存储结构

2.2.1 线性队

int queue[maxSize];
int rear = 0, front = 0;
//根据具体情况推导出队空状态，不仅仅包括 rear = front
//入队操作
queue[++rear] = x;
//出队操作,注意front指针在出队操作完成之后不指向元素，而是指向一个空的内存
x = queue[++front];

//假溢出指的是在rear指针指向数组中最后一个元素时，没有办法进行进一步的插入操作，此时为假溢出
//为了避免假溢出的出现，形象上把整个数组掰弯形成一个环，这在具体的代码中就是取余操作
//“掰弯”之后的入队操作：
rear = (rear+1) % maxSize;
queue[rear] = x;
//“掰弯”之后的出队操作：
front = (front+1) % maxSize;
x = queue[front];

//此时的队空状态：
front == rear 为真
//此时的队满状态：
front == (rear+1) % maxSize 为真

2.2.2 链队

//考试时一般采取的结构体定义方式：
typedef struct{
LNode *front;
LNode *rear;
}queue;

//链队为空的情况：
head->next == NULL为真

3 考点

3.1 输出序列

3.1.1 由出栈序列判断容量

举个例子：具体问答时一般不会直接给出出栈序列，需要根据一些条件进行推测，如下图所示：

1）给出入栈和出栈的顺序，进行判断最大的的存储容量：这种题目的方法就是一个一个地试。

2）给出入栈和出栈的顺序，要求判断哪种出栈是不可能的。这种问题有固定的套路，即如果123，则无312。如果最后一个入栈的第一个出栈，那么整个栈中的出栈顺序就是固定的。

3）Catalan number-只需要记忆

3.2 表达式的转换问题

中缀表达式

前缀表达式（波兰式）

后缀表达式（逆波兰式）

1）中缀转换成前缀或者后缀的方法是给所有的运算参数上加上括号，如果转成前缀，则将括号之间的符号提到两个括号之前。后缀是放在括号之后。

2）前缀后缀转换成中缀

看到两个数字后面紧跟着符号，则将这两个数字括在一起，中间/前面加符号。

3.3 用栈实现表达式的转换

注意中缀转后缀时，新入栈的符号的优先级大于等于栈中的符号的优先级，则出栈。

void infixToPostFix(char infix[], char s2[], int &top2)
{
		char s1[maxSize];
		int top1 = -1;
		int i = 0;
		while(infix[i] != '\0')
		{
		
		//如果扫描到的是数字，则入结果栈
				if('\0' <= infix[i] && infix[i] <= '9')
				{
						s2[++top2] = infix[i];
						++i;
				}   
        
    //如果扫描到的是左括号，则入辅助栈
				else if (infix[i] == ')')
				{
						s1[++top1] = ')';
						--i;							//对应中缀转后缀的--i
				}
				
		//在输入符号的时候，判断符号的优先级
				else if (infix[i] == '+' || infix[i] == '-' || infix[i] == '*' ||infix[i] == '/')
				{
						if (top == -1 || s1[top1] == '(' || getPriority(infix[i]) >= getPriority(s1[top1])) //注意等号
						{
								s1[++top1] = infi[i];
						}
						else
								s2[++top2] = s1[top1--];
        }	
       else if (infix[i] == '(')
       {
       			while (s1[top1] != ')")
       					s2[++top2] = s1[top1--];
       					--top1;
       					--i;          //对应中缀转后缀的--i
       }
		}
		while (top1 != -1)
       			s2[++top2] = s1[top1--];
}

而在中缀转前缀时，新入栈的符号的优先级大于栈中的符号的优先级的时候才出栈，否则继续入栈。

void infixToPostFix(char infix[], char s2[], int &top2)
{
		char s1[maxSize];
		int top1 = -1;
		int i = 0;
		while(infix[i] != '\0')
		{
		
		//如果扫描到的是数字，则入结果栈
				if('\0' <= infix[i] && infix[i] <= '9')
				{
						s2[++top2] = infix[i];
						++i;
				}   
        
    //如果扫描到的是左括号，则入辅助栈
				else if (infix[i] == '(')
				{
						s1[++top1] = '(';
						++i;
				}
				
		//在输入符号的时候，判断符号的优先级
				else if (infix[i] == '+' || infix[i] == '-' || infix[i] == '*' ||infix[i] == '/')
				{
						if (top == -1 || s1[top1] == '(' || getPriority(infix[i]) > getPriority(s1[top1]))
						{
								s1[++top1] = infi[i];
						}
						else
								s2[++top2] = s1[top1--];
        }	
       else if (infix[i] == ')')
       {
       			while (s1[top1] != '(")
       					s2[++top2] = s1[top1--];
       					--top1;
       					++i;
       }
		}
		while (top1 != -1)
       			s2[++top2] = s1[top1--];
}

后缀转前缀的方法是：将数字压入栈中，每两个算式遇到一个符号，则对两个算式进行重新处理，循环往复。

3.4用栈实现表达式求值

3.4.1 中缀表达式

float calInfix(char exp[])
{
		float s1[maxSize]; int top1 = -1;
		char s2[maxSize]; int top2 = -1;
		int i = 0;
		while(exp[i] != '\0')     //遇到串尾，则结束扫描
		{
				if('0' < exp[i] && exp[i] < '9')
				{
						
				//字符转换为数字
						s1[++top1] = exp[i] - '0';    
						++i;
				}
				
				 //左括号直接入字符栈
				else if(exp[i] == '(')          
				{
						s2[++top] = '(';
						++i;
				}
				
				//判断扫描的值是符号
				else if(exp[i] = '+'||exp[i] = '-'||exp[i] = '*'||exp[i] = '/')
				{
						if(top2 == -1 || s2[top2] =='('|| getPriority(exp[i]) > getPriority(s2[top2]) )
						{
								s2[top2] =exp[i];
								++i;
						}
						else 
						{
								int flag = calStackTopTow(s1, top1, s2, top2);
								if(flag == 0)
								return 0;
						}
				else if(exp[i] == ')')
				{
						while(s2[top2] != '(' )
						{
								int flag = calStackTopTow(s1, top1, s2, top2);
								if(flag == 0)
								return 0;
						}
						--top2;
						++i;
				}
				}
				
				 //扫描结束如果栈中还有字符串剩余
				while (top2 != -1) 
				{
			 					int flag = calStackTopTow(s1, top1, s2, top2);
								if(flag == 0)
								return 0;
				}
		}
		return s1[top1];
}

3.4.2 后缀表达式

3.4.3 前缀表达式

从左到右扫描

3.5配置问题

队列的配置是考察的重点

3.5.1正常配置

//假溢出指的是在rear指针指向数组中最后一个元素时，没有办法进行进一步的插入操作，此时为假溢出
//为了避免假溢出的出现，形象上把整个数组掰弯形成一个环，这在具体的代码中就是取余操作
//“掰弯”之后的入队操作：
rear = (rear+1) % maxSize;
queue[rear] = x;
//“掰弯”之后的出队操作：
front = (front+1) % maxSize;
x = queue[front];

//此时的队空状态：
front == rear 为真
//此时的队满状态：
front == (rear+1) % maxSize 为真

计算元素个数的问题

rear>front 时
个数 = rear-front

3.5.2 非正常配置

1）第一种情况

2）第二种情况

3.6扩展问题-双端队列

3.7 栈的扩展内容

3.7.1 共享栈

3.7.2 用栈模拟队列

一定要注意在模拟过程中如果要保证顺序一致，则在移动过程中需要将元素全部移出，否则无法得到一致的顺序。

3.8括号匹配问题

括号匹配：

3.9 利用栈进行计算