栈和队列
括号匹配
//检查一个表达式的括号匹配问题，算数表达式存储于字符数组中。
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
typedef struct
{
char data[MAXSIZE]; //顺序栈存储空间
int top; //栈顶指针
}SeqStack; //顺序栈类型
void Init_SeqStack(SeqStack**s) //顺序栈初始化
{
*s=(SeqStack *)malloc(sizeof(SeqStack)); //在主调函数中申请占空间
(*s)->top=-1; //置栈空标志
}
int Empty_SeqStack(SeqStack*s) //判栈空
{
if(s->top==-1) //栈为空
return 1;
else
return 0;
}
void Push_SeqStack(SeqStack*s,char x) //元素入栈
{
if(s->top==MAXSIZE-1) //栈已满
printf("Stack is full!\n");
else
{
s->top++;
s->data[s->top]=x; //将元素压入栈
}
}
void Pop_SeqStack(SeqStack*s,char *x) //元素出栈并将元素返回给主调函数
{
if(s->top==-1)
printf("Error!\n"); //栈为空
else
{
*x=s->data[s->top]; //栈顶元素出栈
s->top--;
}
}
void Top_SeqStack(SeqStack*s,char *x) //取栈顶元素
{
if(s->top==-1)
printf("Stack is empty!\n"); //栈为空
else
*x=s->data[s->top]; //取栈顶元素值
}
void Correct(char ex[]) //检查算数表达式中的括号匹配
{
SeqStack *p;
char x,*ch=&x;
int i=0;
Init_SeqStack(&p); //顺序栈初始化为空
while(ex[i]!='\0') //扫描算数表达式未结束
{
if(ex[i]=='('||ex[i]=='['||ex[i]=='{') //扫描字符为（【{则入栈
Push_SeqStack(p,ex[i]);
if(ex[i]==')'||ex[i]==']'||ex[i]=='}')
{
Top_SeqStack(p,ch); //读出栈顶字符
if(ex[i]==')'&&*ch=='(') //栈顶字符与当前扫描字符匹配则出栈
{
Pop_SeqStack(p,ch);
i++;
continue;
}
if(ex[i]==']'&&*ch=='[')
{
Pop_SeqStack(p,ch);
i++;
continue;
}
if(ex[i]=='}'&&*ch=='{');
{
Pop_SeqStack(p,ch);
i++;
continue;
}
} //继续扫描下一个字符
}
if(!Empty_SeqStack(p)) //算数表达式结束或非正常结束时若栈不为空则不配对
printf("Error!\n");
else
printf("Right!\n");
}
void main()
{
char x[30];
printf("Input exp:\n"); //输入一个算数表达式
scanf("%s",x);
Correct(x); //检查算数表达式中括号是否匹配
}
链和队列基本运算
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 30
typedef struct node
{
char data;
struct node *next;
}QNode; //链队列结点类型
typedef struct
{
QNode *front,*rear; //将头、尾指针纳入到一个结构体的连队列
}LQueue; //链队列类型
void Init_LQueue(LQueue**q) //创建一个带头结点的空队列
{
QNode *p;
*q=(LQueue *)malloc(sizeof(LQueue)); //申请带头、尾指针的结点
p=(QNode *)malloc(sizeof(QNode)); //申请连队列的头结点
p->next=NULL; //头结点的nex指针置为空
(*q)->front=p; //队头指针指向头结点
(*q)->rear=p; //队尾指针指向头结点
}
int Empty_LQueue(LQueue*q) //判队为空
{
if(q->front==q->rear) //队为空
return 1;
else
return 0;
}
void In_LQueue(LQueue *q,charx) //入队
{
QNode *p;
p=(QNode *)malloc(sizeof(QNode)); //申请新连队列结点
p->data=x;
p->next=NULL; //新结点作为队尾结点时其next域为空
q->rear->next=p; //将新结点*p链到原队尾结点之后
q->rear=p; //使队尾指针指向新的队尾结点*p
}
void Out_LQueue(LQueue*q,char *x) //出队
{
QNode *p;
if(Empty_LQueue(q))
printf("Queue is empty!\n"); //队空，出队失败
else
{
p=q->front->next; //指针p指向看、链队列第一个数据结点
q->front->next=p->next; //头结点的next指针指向链队列第二个数据元素结点
*x=p->data; //将删除的队头结点数据经由指针x返回
free(p);
if(q->front->next==NULL) //出队后队为空，则置为空队列
q->rear=q->front;
}
}
void print(LQueue *q) //队列输出
{
QNode *p;
p=q->front->next;
while(p!=NULL)
{
printf("%4c",p->data);
p=p->next;
}
printf("\n");
}
void main()
{
LQueue *q;
char x,*y=&x; //出队元素经指针y传给x
Init_LQueue(&q); //链队列初始化
if(Empty_LQueue(q)) //判对空
printf("Queue is empty!\n");
printf("Input anystring:\n"); //给链队列输入元素
scanf("%c",&x);
while(x!='\n')
{
In_LQueue(q,x); //元素入队
scanf("%c",&x);
}
printf("Output element ofQueue:\n");
print(q); //链队列输出
printf("Output queue:\n");
Out_LQueue(q,y); //元素出队
printf("Element of output Queue is%c\n",*y); //输出出队元素值
printf("Output element ofQueue:\n");
print(q); //输出出队后的连队列的元素值
}
链栈的基本运算
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
char data;
struct node *next;
}StackNode; //链栈元素类型
void Init_LinkStack(StackNode**s) //链栈初始化
{
*s=NULL;
}
int Empty_LinkStack(StackNode*s) //判断链栈是否为空
{
if(s==NULL)
return 1;
else
return 0;
}
void Push_LinkStack(StackNode**top,char x) //链栈元素入栈
{
StackNode *p;
p=(StackNode*)malloc(sizeof(StackNode)); //生成链栈元素的存储空间
p->data=x;
p->next=*top; //新生成的栈顶元素*p其后继为原栈顶元素**p
*top=p; // 栈顶指针*top指向新的栈顶元素*p
}
void Pop_LinkStack(StackNode**top,char *x) //链栈元素出栈
{
StackNode *p;
if(*top==NULL)
printf("Stack is empty!\n"); //栈为空
else
{
*x=(*top)->data; //栈顶元素经指针x传给对应的变量
p=*top;
*top=(*top)->next; //栈顶指针*top指向出栈后的新栈顶元素
free(p);
}
}
void print(StackNode *p) //链栈输出
{
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
printf("\n");
}
void main()
{
StackNode *s;
char x,*y=&x; //出栈元素经过指针传给x
Init_LinkStack(&s); //链栈初始化
if(Empty_LinkStack(s)); //判断链栈是否为空
printf("Stack isempty!\n");
printf("Input anystring:\n"); //链栈元素入栈
scanf("%c",&x);
while(x!='\n')
{
Push_LinkStack(&s,x);
scanf("%c",&x);
}
printf("Output string :\n");
print(s); //链栈元素输出
printf("Output stack :\n");
Pop_LinkStack(&s,y); //链栈元素出栈
printf("Elenment of Output stack is%c\n",*y); //输出出栈元素
printf("Output string:\n");
print(s); //链栈输出
}
顺序栈基本实现
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
typedef struct
{
char data[MAXSIZE]; //栈中元素存储空间
int top; //栈顶指针
}SeqStack; //顺序栈类型
void Init_SeqStack(SeqStack**s) //顺序栈初始化
{
*s=(SeqStack*)malloc(sizeof(SeqStack)); //在主调函数中申请栈空间
(*s)->top=-1; //置栈空标志
}
int Empty_SeqStack(SeqStack*s) //判栈是否为空
{
if(s->top==-1) //栈为空
return 1;
else
return 0;
}
voidPush_SeqStack(SeqStack*s,char x) //顺序栈元素入栈
{
if(s->top==MAXSIZE-1)
printf("Stack is full!\n"); //栈已满
else
{
s->top++;
s->data[s->top]=x; //元素x压入*s中
}
}
void Pop_SeqStack(SeqStack*s,char *x) //将栈中的栈顶元素出栈并通过参数x返回给主调函数
{
if(s->top==-1)
printf("Stack is empty!\n"); //栈为空
else
{
*x=s->data[s->top]; //栈顶元素出栈
s->top--;
}
}
void Top_SeqStack(SeqStack*s,char *x) //取顺序栈栈顶元素
{
if(s->top==-1)
printf("Stack is empty!\n"); //栈为空
else
*x=s->data[s->top]; //取栈顶元素
}
void print(SeqStack *s) //顺序输出栈
{
int i;
for(i=0;i<=s->top;i++)
printf("%4c",s->data[i]);
printf("\n");
}
void main()
{
SeqStack *s;
char x,*y=&x; //y指向x的指针，出栈元素经过y传递给变量x
Init_SeqStack(&s); // 顺序栈初始化
if(Empty_SeqStack(s)) //判栈是否为空
printf("Stack isempty!\n");
printf("Input data ofstack:\n"); //顺序栈元素入栈
scanf("%c",&x);
while(x!='\n')
{
Push_SeqStack(s,x);
scanf("%c",&x);
}
printf("Output all dataof stack:\n");
print(s); //输出顺序栈中的元素
Pop_SeqStack(s,y); //顺序栈元素的出栈
printf("Output data ofPop stack:%c\n",*y); //输出出栈元素
printf("Output all dataof stack:\n");
print(s); //输出出栈后顺序栈中的元素
Top_SeqStack(s,y); //读取顺序栈栈顶元素
printf("Output data oftop stack:%c\n",*y); //输出读出的栈顶元素
printf("Output all dataof stack:\n");
print(s); //输出当前的顺序栈中元素
}
循环队列基本实现
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
typedef struct
{
char data[MAXSIZE]; //队中元素存储空间
int rear,front; //队尾队头指针
}SeQueue; //顺序队列类型
void Int_SeQueue(SeQueue**q) //循环队列初始化
{
*q=(SeQueue *)malloc(sizeof(SeQueue)); //生成循环队列存储空间
(*q)->front=0; //队头与队尾指针相等则队为空
(*q)->rear=0;
}
int Empty_SeQueue(SeQueue*q) //判断队列是否为空
{
if(q->front==q->rear) //队列为空
return 1;
else //队列不为空
return 0;
}
void In_SeQueue(SeQueue*q,char x) //元素入队
{
if((q->rear+1)%MAXSIZE==q->front)
printf("Queue is full!\n"); //队满，入队失败
else
{
q->rear=(q->rear+1)%MAXSIZE; //队尾指指针加1
q->data[q->rear]=x; //将x入队
}
}
void Out_SeQueue(SeQueue*q,char *x) //元素出队
{
if(q->front==q->rear)
printf("Queue is empty!\n"); //对空出队失败
else
{
q->front=(q->front+1)%MAXSIZE; //队头指针加1
*x=q->data[q->front]; //队头元素出队并由x返回头元素值
}
}
void print(SeQueue *q) //循环队列输出
{
int i;
i=(q->front+1)%MAXSIZE;
while(i!=q->rear)
{
printf("%4c",q->data[i]);
i=(i+1)%MAXSIZE;
}
printf("%4c\n",q->data[i]);
}
void main()
{
SeQueue *q;
char x,*y=&x; //出队元素经指针y传给x
Int_SeQueue(&q); //循环队列初始化
if(Empty_SeQueue(q)) //判队空
printf("Queue is empty!\n");
printf("Input anystring:\n"); //给循环队列输入元素
scanf("%c",&x);
while(x!='\n')
{
In_SeQueue(q,x); //元素入队
scanf("%c",&x);
}
printf("Output element ofQueue:\n");
print(q); //循环队列输出
printf("Output Queue:\n");
Out_SeQueue(q,y); //循环队列元素出队
printf("Element of Output Queue is%c\n",*y); //输出出队元素
printf("Output element ofQueue:\n");
print(q); //输出出队后的循环队列元素
}
队列和栈将元素逆置
//已知q是一个非空队列，仅用队列和栈以及少量工作变量完成队列元素的逆置
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 30
typedef struct
{
char data[MAXSIZE]; //顺序栈存储空间
int top; //栈顶指针
}SeqStack; //顺序栈类型
void Init_SeqStack(SeqStack**s) //顺序栈初始化
{
*s=(SeqStack *)malloc(sizeof(SeqStack)); //在主调函数中申请栈空间
(*s)->top=-1; //置栈空标志
}
int Empty_SeqStack(SeqStack*s) //判栈空
{
if(s->top==-1) //栈为空时
return 1;
else
return 0;
}
void Push_SeqStack(SeqStack*s,char x) //元素入栈
{
if(s->top==MAXSIZE-1)
printf("Stackis full!\n"); //栈已满
else
{
s->top++;
s->data[s->top]=x; //元素压入栈中
}
}
void Pop_SeqStack(SeqStack *s,char *x) //元素出栈
{
if(s->top==-1)
printf("Stack isempty!\n"); //栈为空
else
{
*x=s->data[s->top]; //栈顶元素出栈
s->top--;
}
}
typedef struct
{
char data[MAXSIZE]; //队中元素存储空间
int rear,front; //队尾和队头指针
}SeQueue; //顺序对类型
void Init_SeQueue(SeQueue **q) //循环队列初始化
{
*q=(SeQueue *)malloc(sizeof(SeQueue));
(*q)->front=0;
(*q)->rear=0;
}
int Empty_SeQueue(SeQueue *q) //判队空
{
if(q->front==q->rear)
return 1;
else
return 0;
}
void In_SeQueue(SeQueue *q,char x) //元素入队
{
if((q->rear+1)%MAXSIZE==q->front)
printf("Queue isfull!\n"); //队满，入队失败
else
{
q->rear=(q->rear+1)%MAXSIZE; //队尾指针加一
q->data[q->rear]=x; //元素入队
}
}
void Out_SeQueue(SeQueue *q,char *x) //元素出队
{
if(q->front==q->rear)
printf("Queue isempty!\n"); //队空出队失败
else
{
q->front=(q->front+1)%MAXSIZE; //队头指针加一
*x=q->data[q->front]; //对头元素出队并返回元素值
}
}
void print(SeQueue *q) //循环队列输出
{
int i;
i=(q->front+1)%MAXSIZE;
while(i!=q->rear)
{
printf("%4c",q->data[i]);
i=(i+1)%MAXSIZE;
}
printf("%4c",q->data[i]);
}
void Revers_Queue(SeQueue *q,SeqStack*s) //用栈逆置队列
{
char x,*p=&x;
Init_SeqStack(&s); //栈初始化
while(!Empty_SeQueue(q))
{
Out_SeQueue(q,p); //取出队头元素
Push_SeqStack(s,*p); //将对头元素压入栈
}
while(!Empty_SeqStack(s))
{
Pop_SeqStack(s,p); //栈顶元素出栈
In_SeQueue(q,*p); //将栈顶元素入队
}
}
void main()
{
SeqStack *s;
SeQueue *q;
char x,*y=&x;
Init_SeqStack(&s); //顺序栈初始化
Init_SeQueue(&q); //循环队列初始化
if(Empty_SeQueue(q)) //判队空
printf("Queue isempty!\n");
printf("Input anystring:\n"); //给队列输入元素
scanf("%c",&x);
while(x!='\n')
{
In_SeQueue(q,x); //元素入队
scanf("%c",&x);
}
printf("Output element ofQueue:\n"); //输出队列元素
print(q);
printf("\nConver Queue\n");
Revers_Queue(q,s); //队列元素逆置
printf("Output element of Queue:\n");
print(q); //输出逆置后的队列元素
}
扫一扫
826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
