栈和队列初学总结

一.栈的顺序存储

#include<iostream>
#include<cstdlib>
#include<string>
typedef char ElemType;

#define MAXSIZE 50

typedef struct
{
ElemType data[MAXSIZE];
int top;
}SqStack;

void InitStack(SqStack *&s)
{
s = (SqStack *)malloc(sizeof(SqStack));
s->top = -1;
}

void DestoryStack(SqStack *&s)
{
free(s);
}

bool StackEmpty(SqStack *s)
{
return (s->top == -1);
}

bool Push(SqStack *&s, ElemType e)
{
if (s->top == MAXSIZE - 1)
return false;
s->top++;
s->data[s->top] = e;
return true;
}

bool Pop(SqStack *&s, ElemType &e)//后进先出
{
if (s->top == -1)
return false;
e = s->data[s->top];//保留被“删除”的数据
s->top--;
return true;
}

bool GetTop(SqStack *s, ElemType &e)//元素出栈时，保留出栈元素
{
if (s->top == -1)
return false;
e = s->data[s->top];
return true;
}

bool symmetry(ElemType str[])
{
int i;
ElemType save;
SqStack *s;
InitStack(s);
for (i = 0;str[i] != '\0'; i++)
{
Push(s,str[i]);
}
if (StackEmpty(s))
{
return true;
DestoryStack(s);
}
//方法一
#if(0)
{
for (i = 0;(i!=s->top)&&(i<s->top); i++)//当字符串个数为奇数时,(i!=s->top);当字符串个数为偶数时,(i<s->top)
{
GetTop(s, save);//得到栈顶元素后，top没变
if (s->data[i] != save)
{
break;
}
Pop(s,save);
}
if (i == s->top||i>s->top)
{
DestoryStack(s);
return true;
}
else
{
DestoryStack(s);
return false;
}
}
#endif

//方法二
for(i=0;str[i]!='\0';i++)
{
Pop(s,save);//直接用出栈函数，取得top值
if(str[i]!=save)
{
DestoryStack(s);
return false;
}
}
DestoryStack(s);
return true;
}

int main(void)
{
char str[MAXSIZE];
std::cout<<"请输入一段字符串:\n";
std::cin.getline(str,MAXSIZE);
if(symmetry(str))
{
std::cout<<"该串是对称串！\n";
}
else
{
std::cout<<"该串不是对称串！\n";
}
system("pause");
return 0;
}
二.栈的链式存储

#include<iostream>
#include<cstdlib>
//#include<string>

typedef char ElemType;
#define MaxSize 20

typedef struct linknode
{
ElemType data;
struct linknode * next;
}LiStack;

void InitStack(LiStack *&s)
{
s = (LiStack *)malloc(sizeof(LiStack));//该链表头结点无数据
s->next = NULL;
}

void DestroyStack(LiStack *&s)
{
LiStack *p = s, *q = s->next;
while (q != NULL)
{
free(p);
p = q;
q = p->next;
}
free(p);
}

bool StackEmpty(LiStack *s)//判断列表是否为空
{
return(s->next == NULL);
}

void Push(LiStack *&s, ElemType e)//进栈，头插法，此时“top”即最后进去的那个数，与顺序法一样
{
LiStack *p;
p = (LiStack *)malloc(sizeof(LiStack));
p->data = e;
p->next = s->next;
s->next = p;
}

bool Pop(LiStack *&s, ElemType &e)//后进先出
{
LiStack *p;
if (s->next == NULL)//判断链表是否为空，为空则不能再出栈
{
return false;
}
p = s->next;
e = p->data;//出栈时，要保留出栈的元素
s->next = p->next;
free(p);
return true;
}

bool GetTop(LiStack *s, ElemType &e)
{
if (s->next == NULL)//若链表为空，则无法提取栈顶元素
{
return false;
}
e = s->next->data;
return true;
}

bool Match(char exp[])
{
int i;
bool match = true;
ElemType save;
LiStack *s;
InitStack(s);
for (i = 0; exp[i] != '\0'; i++)
{
if (exp[i] == '(')
{
Push(s, exp[i]);
}
if (exp[i] == ')')
{
if (GetTop(s, save) == true)//若此时的栈顶元素没有取到，则说明没有‘(’与')'相匹配
{
if (save == '(')
{
Pop(s, save);
}
else
{
match = false;
}
}
else match = false;
}
}
if (!StackEmpty(s))
{
match = false;
}
return match;
}

int main(void)
{
char str[MaxSize];
std::cout<<"请输入一段字符串:\n";
std::cin.getline(str,MaxSize);
if(Match(str))
{
std::cout<<"匹配成功！\n";
}
else
{
std::cout<<"匹配失败！\n";
}
system("pause");
return 0;
}


三.队列的顺序存储

#include<iostream>
#include<cstdlib>

typedef char ElemType;

#define MaxSize 50

typedef struct
{
ElemType data[MaxSize];
int front, rear;
}SqQueue;

void InitQueue(SqQueue *&q)
{
q = (SqQueue *)malloc(sizeof(SqQueue));
q->front = q->rear = -1;
}

void DestroyQueue(SqQueue *&q)
{
free(q);
}

bool QueueEmpty(SqQueue *q)
{
return (q->front == q->rear);//顺序表为空的条件
}

bool enQueue(SqQueue *&q,ElemType e)
{
if(q->rear==MaxSize-1)//队列上溢的条件
{
return false;
}
q->rear++;//数组尾下标+1
q->data[q->rear]=e;
return true;
}

bool deQueue(SqQueue *&q,ElemType &e)
{
if(q->front==q->rear)
{
return false;
}
q->front++;
e=q->data[q->front];
return true;
}

int main(void)
{
system("pause");
return 0;
}

四.队列的链式存储
#include<iostream>
#include<cstdlib>

typedef int ElemType;

typedef struct qnode
{
ElemType data;
struct qnode * next;
}Qnode; //链表数据节点类型定义

typedef struct
{
Qnode *front;//通过front、rear指挥链表的排列
Qnode *rear;
}LiQueue;

void InitQueue(LiQueue *&q)
{
q=(LiQueue*)malloc(sizeof(LiQueue));
q->front=q->rear=NULL;//头尾‘指挥’的初始化
}

void DestroyQueue(LiQueue *&q)
{
Qnode *p=q->front,*r;
if(p!=NULL)
{
r=p->next;
while(r!=NULL)
{
free(p);
p=r;
r=p->next;
}
}
free(p);
free(q);
}

bool QueueEmpty(LiQueue *q)
{
return(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)//队列中只有一个节点时，链表的front可以存数！！！
{
q->front=q->rear=NULL;
}
else
{
q->front=q->front->next;//首先让front指向要被‘删除’数的后一个数，不给它‘出现’的机会，然后存在被删除数，最后释放‘该’内存
}
e=t->data;
free(t);
return true;
}

int main(void)
{
system("pause");
return 0;
}


五.循环列表的链式存储

#include<iostream>
#include<cstdlib>

typedef int ElemType;

typedef struct qnode
{
ElemType data;
struct qnode *next;
struct qnode *rear;
}LinkList;

void InitQueue(LinkList *&rear)//初始化队运算算法
{
rear=NULL;//队列链表的初始化都是对尾(首)‘指挥官’
}

void enQueue(LinkList *&rear,ElemType x)//进队运算算法
{
LinkList *p;
p=(LinkList *)malloc(sizeof(LinkList));
p->data=x;//该链表的头节点也是有值的
if(rear==NULL)//原链表为空
{
p->next=p;//构成循环链表
rear=p;
}
else
{
p->next=rear->next;//将*p节点插到*rear节点之后
rear->next=p;
rear=p;
}
}

bool deQueue(LinkList *&rear,ElemType &x)
{
LinkList *q;
if(rear==NULL)//删除链表之前，检查该链表是否为空
{
return false;
}
//原队中只有一个节点，没有选择，只能删他
else if(rear->next==rear)//循环链表的特征
{
x=rear->data;
free(rear);//释放完rear的空间后，需对rear赋值
rear=NULL;
}
else//原队中有两个或两个以上的节点
{
q=rear->next;//从'头'开始删
x=q->data;
rear->next=q->next;//较常用
free(q);
}
return true;
}

bool queueEmpty(LinkList *rear)//判断链表是否为空
{
return(rear==NULL);
}

int main(void)
{
system("pause");
return 0;
}



六.环形队列的顺序存储

#include<iostream>
#include<cstdlib>

typedef char ElemType;
#define MaxSize 20

typedef struct
{
ElemType data[MaxSize];
int front,rear;
}SqQueue;

void InitQueue(SqQueue *&q)
{
q=(SqQueue *)malloc(sizeof(SqQueue));
q->front=q->rear=0;//与单顺序表不同
}

void DestroyQueue(SqQueue *&q)
{
free(q);
}

bool QueueEmpty(SqQueue *q)
{
return(q->front==q->rear);
}

bool enQueue(SqQueue *&q,ElemType e)
{
if((q->rear+1)%MaxSize==q->front)//判断队列表是否上溢,(q->rear+1)%MaxSize是为了让q->rear可以重新回到0下标，实现循环，循环表中的front下标中还是不‘存在’数
{
return false;
}
q->rear=(q->rear+1)%MaxSize;//尾坐标先+1,再存数
q->data[q->rear]=e;
return true;
}

bool deQueue(SqQueue *&q,ElemType &e)
{
if(q->front==q->rear)//判断队列是否下溢
{
return false;
}
q->front=(q->front+1)%MaxSize;//同样地，先头坐标+1
e=q->data[q->front];//存在'消失'的数字
return true;
}

int main(void)
{
system("pause");
return 0;
}
//当判断上溢时，需要判断rear的前面一个，即rear+1是否和front相等(所以就需要用到(q->rear+1)%MaxSize),如果相等则溢出，因为front坐标所指‘不放’数字；
//当判断下溢时，需要判断rear是否与front相等，若相等，则相当于front把rear里的最后一个数也给'灭'了；
//上溢出，rear'追'front;下溢出，front'追'rear;