//顺序栈
#define Max 100
typedef struct {
ElemType data[Max];//存放栈中的元素
int top;//栈顶元素
}Stack;
//顺序栈的基本操作:
//初始化
void InitStack(Stack &S){
S.top==-1;
}
//判栈空
bool isEmpty(Stack S){
if(S.top==-1)
return true;
else
return false;
}
//进栈
void Push(Stack &S,int x){
if(S.top==Max-1)
return false;
S.top=S.top+1;
S.data[S.top]=x;//S.data[++S.top]=x
return true;
}
//出栈
void Pop(Stack &S,int &x){
if(S.top==-1)
return false;
x=S.data[S.top--];
}
//读取栈顶元素
bool GetTop(Stack S,int &x){
if(S.top==-1)
return false;
x=S.data[S.top];
return true;
}
//若栈顶初始化指针S.top==0,即top指向栈顶元素的下一个位置
//初始化
void InitStack(Stack &S){
S.top==0;
}
//判栈空
bool isEmpty(Stack S){
if(S.top==0)
return true;
else
return false;
}
//进栈
void Push(Stack &S,int x){
if(S.top==Max)
return false;
S.data[S.top++]=x;
return true;
}
//出栈
void Pop(Stack &S,int &x){
if(S.top==-1)
return false;
x=S.data[--S.top];
}
//读取栈顶元素
bool GetTop(Stack S,int &x){
if(S.top==0)
return false;
x=S.data[S.top];
return true;
}
//顺序队列
typedef struct{
ElemType data[Max];
int front,rear;
}SqQueue;
//初始化
void InitQueue(SqQueue &Q){
Q.rear=Q.front=0;
}
//判队空
bool isEmpty(SqQueue Q){
if(Q.rear==Q.front)
return true;
else
return false;
}
//入队
void EnQueue(SqQueue &Q,int x){
if((Q.rear+1)%Max==Q.front)
return false;
Q.data[Q.rear]=x;
Q.rear=(Q.rear+1)%Max;
return true;
}
//出队
void DeQueue(SqQueue &Q,int &x){
if(Q.rear==Q.front)
return false;
x=Q.data[Q.front];
Q.front=(Q.front+1)%Max;
return true;
}
//循环队列增加tag变量(进队tag=1,出队tag=0,只有入队操作导致队满,出队导致队空)
//入队
int EnQueue1(SqQueue &Q,int x){
if(Q.front==Q.rear && Q.tag==1)
return 0;
Q.data[Q.rear]=x;
Q.rear=(Q.rear+1)%Max;
Q.tag=1;
return 1;
}
//出队
int DeQueue1(SqQueue &Q,int &x){
if(Q.rear==Q.front && Q.tag==0)
return 0;
x=Q.data[Q.front];
Q.front=(Q.front+1)%Max;
Q.tag=0;
return 1;
}
//判空
bool isEmpty1(SqQueue Q){
if(Q.rear==Q.front && Q.tag==0)
return true;
else
return false;
}
//判满
bool isFull(SqQueue Q){
if(Q.rear==Q.front && Q.tag==1)
return true;
else
return false;
}
//Q是一个队列,S是一个空栈,实现将队列中的元素逆置
void Inverser(Stack &S,SqQueue &Q){
while(!isEmpty(Q)){
x=DeQueue(Q);
Push(S,x);
}
while(!isEmpty(S)){
Pop(S,x);
EnQueue(Q,x);
}
}
//括号匹配算法
bool Bracket(char *str){
InitStack(S);
int i=0;
while(str[i]!='\0'){
switch(str[i]){
case '(':Push(S,'(');break;
case '{':Push(S,'{');break;
case '[':Push(S,'[');break;
case ')':Pop(S,e);
if(e!='(') return false;
break;
case '}':Pop(S,e);
if(e!='{') return false;
break;
case ']':Pop(S,e);
if(e!='[') return false;
break;
default:
break;
}
i++;
}
if(!isEmpty(S)){
printf("括号不匹配\n");
return false;
}
else{
printf("括号匹配\n");
return true;
}
}
//链队列
typedef struct LinkNode{
ElemType data;
struct LinNode *next;
}LinkNode;
typedef struct{
LinkNode *front,*rear;
}LinkQueue;
//初始化:带头结点
void InitQueue(LinkQueue &Q){
Q.front=Q.rear=(LinkLNode*)malloc(sizeof(LinkLNode));//建立头结点
Q.front->next=null;
}
//初始化:不带头结点
void InitQueue1(LinkQueue &Q){
Q.rear=null;
Q.front=null;
}
//判断队空
bool isEmpty(LinkQueue Q){
if(Q.rear==Q.front)
return true;
else
return false;
}
bool isEmpty1(LinkQueue Q){
if(Q.front==null)//或者Q.rear==null
return true;
else
return false;
}
//入队
bool EnQueue(LinkQueue &Q,int x){
LinkLNode *s=(LinkLNode *)malloc(sizeof(LinkLNode));
s->data=x;
Q.rear->next=s;//插入链尾
Q.rear=s;//修改尾指针
}
bool EnQueue(LinkQueue &Q,int x){
LinkLNode *s=(LinkLNode *)malloc(sizeof(LinkLNode));
s->data=x;
s->next=null;
if(Q.front==null){
Q.front=s;
Q.rear=s;
}
else{
Q.rear->next=s;
Q.rear=s;
}
}
//出队
bool DeQueue(LinkQueue &Q,int &x){
if(Q.rear==Q.front)
return false;//空队列
LinkNode *p=Q.front->next;
x=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
return true;
}
bool DeQueue(LinkQueue &Q,int &x){
if(Q.rear==null)
return false;//空队列
LinkNode *p=Q.front;
x=p->data;
Q.front=p->next;
if(Q.rear==p){
Q.front=null;
Q.rear=null;
}
free(p);
return true;
}
//读取链队的队头元素
bool GetHeadQueue(LinkQueue Q,int &x) {
if(Q.front==Q.rear) //判断是否为空队
return false;
x=Q.front->next->data;
return true;
}
int getFront(LinkQueue Q) {
if (Q->front != NULL) {
return Q->front->data;
} else {
printf("Queue is empty.\n");
return -1;
}
}
第三章:队列和栈
最新推荐文章于 2024-08-24 14:08:21 发布