栈

/*一、简答题


答：栈的操作原则是后进先出。


2、递归与栈有何关系？递归算法有何优缺点？


答：
递归函数是利用栈实现的；
递归算法的优点：简洁。只需少量代码就可以描述出解题过程中所需的多次重复计算，大大减少了代码量；
递归算法的缺点：时间空间消耗大，效率低。


3、队列的操作原则是什么?


答：队列操作的原则是先进先出。


4、顺序队列操作中的“假溢出”是什么？如何解决？


答：队列操作的“假溢出”是当进队MaxSize个元素后，队满的条件成立rear==MaxSize-1，此时，即使有元素出队，队满条件仍成立，但实际上队列中有空位置。
解决方法：把数组的前端和后端连接起来，形成一个环形的顺序表，即循环队列。


5、循环队列是存储在循环链表中吗？
答：是


6、已知循环队列的队头指针front和队尾指针rear,则队列的长度是多少？
答：(rear-front+MaxSize)%MaxSize


7、栈和队列的共同点和不同点是什么？


答：共同点：都是只允许在端点处插入和删除元素的数据结构；

不同点：栈是仅在栈顶进行访问，遵循后进先出的原则；队列是在队尾插入数据，在队头删除数据，先进先出。

算法题：

1、已知两个顺序栈共享一个存储空间，试编写算法初始化initstack_d(&S)，入栈push_d(&S,i,e)，出栈pop_d(&S,i,&e)操作。

#include <stdlib.h>
#include <iostream>
#define MAXSIZE  20
using namespace std;
typedef int ElemType;
typedef struct
{
    ElemType data[MAXSIZE];
    int top1;  //栈1栈顶指针
    int top2;  //栈2栈顶指针
}SqDoubleStack;

void InitStack(SqDoubleStack *&S)  //初始化操作，建立一个空栈S  
{  
	S=(SqDoubleStack *)malloc(sizeof(SqDoubleStack));
    S->top1 = -1;  
    S->top2 = MAXSIZE;  
}  

bool Push(SqDoubleStack *&s , ElemType e , int stackNumber)
  {
      if(s->top1+1 == s->top2)       //栈已满，不能再push新元素了
          return false;
      if(stackNumber == 1)           //栈1有元素进栈
          s->data[++s->top1] = e;    //若栈1则先top+1后给数组元素赋值
      else if(stackNumber == 2)      //栈2有元素进栈
          s->data[--s->top2] = e;    //若栈2则先top2-1后给数组元素赋值
      return true;
 
 }

 bool Pop(SqDoubleStack *&s , ElemType &e , int stackNumber)
  {
      if(stackNumber == 1)
      {
          if(s->top1 == 1)
              return false;            //说明栈1已经是空栈，溢出
          e = s->data[s->top1--];     //将栈1的栈顶元素出栈 
      }
     else if(stackNumber == 2)
     {
         if(s->top2 == MAXSIZE)
            return false;            //说明栈2已经是空栈，溢出
         e = s->data[s->top2++];     //将栈2的栈顶元素出栈
     }
     return true;
 }
//判断是否配对
bool Match(char exp[],int n)
{
	char st[MAXSIZE];
	int top=-1,i=0;
	bool tag=true;
	while(i<n&&tag)
	{
		if(exp[i]=='('||exp[i]=='['||exp[i]=='{')
		{
			top++;
			st[top]=exp[i];
		}
		if(exp[i]==')')
			if(st[top]=='(')
				top--;
			else tag=false;
		if(exp[i]==']')
			if(st[top]=='[')
				top--;
			else tag=false;
	    if(exp[i]=='}')
			if(st[top]=='{')
				top--;
			else tag=false;
	}
	if(top>=0) tag=false;
    return(tag);

 }
void main()
{
  SqDoubleStack *S;
  ElemType e;
  InitStack(S);
}

2.括号配对

bool Match(char exp[],int n)
{
	char st[MAXSIZE];
	int top=-1,i=0;
	bool tag=true;
	while(i<n&&tag)
	{
		if(exp[i]=='('||exp[i]=='['||exp[i]=='{')
		{
			top++;
			st[top]=exp[i];
		}
		if(exp[i]==')')
			if(st[top]=='(')
				top--;
			else tag=false;
		if(exp[i]==']')
			if(st[top]=='[')
				top--;
			else tag=false;
	    if(exp[i]=='}')
			if(st[top]=='{')
				top--;
			else tag=false;
	}
	if(top>=0) tag=false;
    return(tag);

3.采用带头结点的循环单链表存储链式队列，已知指针rear指向最后一个结点，试编写算法分别实现队列初始化、入队列和出队列操作。

#include "stdlib.h"
#include <iostream>
#include <iomanip>
using namespace std;

#define MaxSize 16
typedef int ElemType;
typedef struct qnode //链堆数据节点类型定义
{  ElemType data;
   struct qnode *next;
}QNode;
typedef struct   //链队类型定义
{
	QNode * front;
	QNode * rear;
}LiQueue;

void InitQueue(LiQueue *&q)
{
	q=(LiQueue*)malloc(sizeof(LiQueue));
	q->front=q->rear=NULL;
}
void enQueue(LiQueue *&q,ElemType e)
{
	QNode *p;
	p=(QNode*)malloc(sizeof(QNode));
	p->data=e;
	p->next-NULL;
	if(q->rear==NULL)
		q->front=q->rear=p;
	else
	{
		q->rear->next=p;
		q->rear=p;
	}

}

bool deQueue(LiQueue *&q,ElemType e)
{
		QNode *t;
		if(q->rear==NULL)
			return false;
		t=q->front;
		if(q->front==q->rear)
			q->front=q->rear=NULL;
		else
			q->front-q->front->next;
		e=t->data;
		free(t);
		return true;

}

void mian()
{
	LiQueue *q;
	InitQueue(q);
    enQueue(q,22);
	enQueue(q,33);
	deQueue(q,22);
}