栈和队列的操作（c）

其他 2018-07-01 05:09:44 阅读次数: 0

全部在VC6.0++下实现

//顺序栈
#include
#include

#define MAXSIZE 10
typedef int datatype;
typedef struct{
	datatype data[MAXSIZE];
	int top;                //栈顶指针
}SeqStack;

//置空栈:首先建立栈空间，然后初始化栈顶指针
SeqStack* Init_SeqStack(){
	SeqStack *s;
	s=(SeqStack *)malloc(sizeof(SeqStack));
	if(s==NULL){
		printf("申请内存失败！\n");
		return NULL;
	}
	else{
		s->top=-1; //置空栈操作，栈顶指针始终指向当前栈顶元素的位置
		return s;
	}
}

//判空栈
int Empty_SeqStack(SeqStack *s){
	if(s->top== -1) //空栈标志
		return 1;
	else
		return 0;
}

//入栈
int Push_SeqStack(SeqStack *s,datatype x){
	if(s->top==MAXSIZE-1){
		printf("栈满不能入栈\n");
		return 0;      //栈满不能入栈
	}
	else{
		s->top++;
		s->data[s->top]=x;
		return 1;
	}
}

//出栈
int Pop_SeqStack(SeqStack *s,datatype *x){
	if(Empty_SeqStack(s)){
        printf("栈为空不能出栈\n");
		return 0;        //栈空不能出栈
	}
	else{
		*x=s->data[s->top]; //取栈顶值，栈顶指针始终指向当前栈顶元素的位置
		s->top--;
		return 1;
	}
}

//取栈顶元素
int Top_SeqStack(SeqStack *s,datatype *x){
	if(Empty_SeqStack(s)){//栈空
		printf("栈为空，不能取!\n");
		return 0;
	}
	else{
		*x=s->data[s->top]; //只读取栈顶元素的值，栈顶指针指针top位置保持不变
		return 1;
	}
}

//测试
int main(void){
	int i;
	int a;
	SeqStack *s;
	s=Init_SeqStack();//创建栈
	if(s==NULL)
		return 0;
	i=0;
	while(i<=MAXSIZE){
		printf("请输入元素值（整形）：");
		scanf("%d",&a);
        Push_SeqStack(s,a);
		i++;
	}
    Pop_SeqStack(s,&a);
	printf("出栈顶元素为%d\n",a);
    Top_SeqStack(s,&a);
    printf("取栈顶元素为%d\n",a);
	return 1;
}


//链栈
#include
#include
#define FALSE 0;
#define TRUE  1;

typedef int Elemtype;
typedef struct Stacknode{
	Elemtype data;
	struct Stacknode *next;
}slStacktype;

//初始化操作
slStacktype * init_Lstack(){           //创建带有头结点的链栈
	slStacktype *p;
	p=(slStacktype *)malloc(sizeof(slStacktype));
	if(p==NULL)
		printf("申请内存失败，初始化失败！\n");
	else
		p->next=NULL;
	return p;
}

//入栈操作
int push_Lstack(slStacktype *top,Elemtype x){ 
	slStacktype *p;
	p=(slStacktype*)malloc(sizeof(slStacktype));
	if(p==NULL){
		printf("申请内存失败，入栈失败！\n");
		return FALSE;
	}
	p->data=x;                 //根据栈的特点采用头插法
	p->next=top->next;
	top->next=p;
	return TRUE;
}

//出栈
int pop_Lstack(slStacktype *top,Elemtype * x){
	slStacktype *p;
	if(top->next==NULL){         //判空栈
		printf("栈为空，出栈失败!\n");
		return FALSE;
	}
	p=top->next;               //出栈
	top->next=p->next;
	*x=p->data;
	free(p);                  //释放资源
	return TRUE;
}

//打印栈中的数据
void print_Lstack(slStacktype *top){
	slStacktype *p;
	p=top->next;
	while(p!=NULL){
		printf("%d\n",p->data);
		p=p->next;
	}
}

//测试
int main(void){
	int a;
	slStacktype *top;
	top=init_Lstack();
	if(top!=NULL){
		printf("请输入，入栈值（-1结束）：");
		scanf("%d",&a);
		while(a!=-1){
           push_Lstack(top,a);
           printf("请输入，入栈值（-1结束）：");
	       scanf("%d",&a);
		}
        pop_Lstack(top,&a);
		printf("出栈值为%d\n",a);
		printf("打印栈中的元素：\n");
		print_Lstack(top);
	}
}
//两栈的共享，共享一维数组
#include
#include

#define MAXNUM 10
#define FALSE 0
#define TRUE  1

typedef int Elemtype;
typedef struct{
	Elemtype stack[MAXNUM];  //左右栈共享的数据区
	int lefttop;   //左栈栈顶指针
	int righttop;  //右栈栈顶指针
}dupsqstack;
/*
   为了识别左右栈，设置两个标志
   char status;
   status='L';   //左栈
   status='R';   //右栈
*/

//初始化操作
int init_DupStack(dupsqstack *s){
	/*
	if((s=(dupsqstack *)malloc(sizeof(dupsqstack)))==NULL){
		printf("申请内存失败！\n");
		return FALSE;
	}
	*/
	s->lefttop=-1;          //左栈空时，标志
	s->righttop=MAXNUM;    //右栈空时，标志
	return TRUE;
}

//入栈操作
int push_DupStack(dupsqstack *s,char status,Elemtype x){
	if(s->lefttop+1==s->righttop){  //栈满标志
		printf("栈满不能入栈！\n");
		return FALSE;
	}
	if(status=='L'){
        s->lefttop++;
		s->stack[s->lefttop]=x;    //++左栈进栈
	}
	else if(status=='R'){
		    s->righttop--;
		    s->stack[s->righttop]=x; //--右栈进栈
	}
	else{
		printf("输入符号有误，入栈失败！\n");
		return FALSE;
	}
	return TRUE;
}

//出栈操作
int pop_DupStack(dupsqstack *s,char status,Elemtype *x){
	//先判断栈是出那个栈元素，再进行出栈操作
	if(status=='L'){                          //左栈
		if(s->lefttop<0){
			printf("左栈为空，出栈失败！\n");
		    return FALSE;
		}
		else{
			*x=s->stack[s->lefttop];   //取栈顶元素
			s->lefttop--;              //改变栈顶指针--
			return TRUE;
		}
	}
	else if(status=='R'){                    //右栈
		if(s->righttop>MAXNUM-1){
			printf("右栈为空，出栈失败！\n");
			return FALSE;
		}
		else{
			*x=s->stack[s->righttop];  //取栈顶元素
			s->righttop++;             //改变栈顶指针++
			return TRUE;
		}
	}
	else{
		printf("选择栈有问题，出栈失败!");
		return FALSE;
	}
}


//测试
int main(void){
   int i;
   dupsqstack s;
   char st;
   int x;
   init_DupStack(&s);
   i=0;
   while(i<=MAXNUM){
	   printf("请选择栈（R或L）：");
	   scanf("%c",&st);
	   printf("请输入入栈值：");
	   scanf("%d",&x);
       fflush(stdin);             //清除标准输入设备（即键盘）的缓冲区。
       push_DupStack(&s,st, x);
	   i++;
   }
   printf("出栈，请选择栈（R或L）：");
   scanf("%c",&st);
   pop_DupStack(&s,st,&x);
   printf("出栈值为%d\n",x);
   fflush(stdin);
   printf("出栈，请选择栈（R或L）：");
   scanf("%c",&st);
   pop_DupStack(&s,st,&x);
   printf("出栈值为%d\n",x);
}

//用数组保存所有链栈的栈顶指针，访问链栈时要提供对应链栈的下标
#define FALSE 0;
#define TRUE  1;
#define M  10;
typedef int Elemtype;
typedef struct Stacknode{
	Elemtype data;
	struct Stacknode *next;
}slStacktype;

//将栈顶指针放在一个一维数组中，统一管理
//slStacktype *top[M];

//入栈操作
int push_Lstack(slStacktype *top[],int i,Elemtype x){
	//将元素x压入链栈top[i]中
	slStacktype *p;
	p=(slStacktype*)malloc(sizeof(slStacktype));
	if(p==NULL){
		printf("申请内存失败，入栈失败！\n");
		return FALSE;
	}
	p->data=x;                 //根据栈的特点采用头插法
	p->next=top[i]->next;
	top[i]->next=p;
	return TRUE;
}

//出栈
int pop_Lstack(slStacktype *top[],int i,Elemtype * x){
	//从链栈top[i]中删除栈顶元素
	slStacktype *p;
	if(top[i]->next==NULL){         //判空栈
		printf("栈为空，出栈失败!\n");
		return FALSE;
	}
	p=top[i]->next;               //出栈
	top[i]->next=p->next;
	*x=p->data;
	free(p);                  //释放资源
	return TRUE;
}
//顺序队列
#include
#include

#define MAXSIZE 10

typedef int datatype;
typedef struct{
	datatype data[MAXSIZE];
	int front; //队头指示器，总是指向队头元素的前一个位置
	int rear; //队尾指示器，总是指向队尾元素
}SeQueue;

//初始化队列
SeQueue* Init_Queue(){
	SeQueue *p;
	p=(SeQueue*)malloc(sizeof(SeQueue));
	if(p==NULL)
		printf("初始化失败！\n");
	else{
		p->front=-1;  //初始化
		p->rear=-1;
	}
	return p;
}
//不考虑溢出情况下入队
void In_Queue(SeQueue *p,datatype x){
	p->rear++;
	p->data[p->rear]=x;
}
//不考虑空队情况下出队
void  Out_Queue(SeQueue *p,datatype *x){
	p->front++;
	*x=p->data[p->front];
}
//循环队列---规定顺序队列最后一个单元的后继为第一个单元
#include
#include

#define MAXSIZE 10       //循环队列中最多存储MAXSIZE-1个元素
#define FALSE  0
#define TRUE  1
typedef int datatype;
typedef struct{
	datatype data[MAXSIZE];
	int front; //队头指示器，总是指向队头元素的前一个位置
	int rear; //队尾指示器，总是指向队尾元素
}CSeQueue;

//置空队
CSeQueue* Init_SeQueue(){
	CSeQueue *p;
	p=(CSeQueue *)malloc(sizeof(CSeQueue));
	if(p==NULL)
		printf("置空队失败！！！\n");
	else{
		p->front=MAXSIZE-1;      //置空队条件
	    p->rear=MAXSIZE-1;
	}
	return p;
}

//入队
int In_SeQueue(CSeQueue *q,datatype x){
	if((q->rear+1)%MAXSIZE==q->front){   //队满条件
		printf("队满，不能入队\n");
		return FALSE;
	}
	else{
		q->rear=(q->rear+1)%MAXSIZE;            //入对条件
		q->data[q->rear]=x;
		return TRUE;
	}
}

//出队
int Out_SeQueue(CSeQueue *q,datatype *x){
	if(q->front==q->rear){   //空队条件
		printf("队空，不能出队!\n");
		return FALSE;
	}
	else{
		q->front=(q->front+1)%MAXSIZE;  //出队条件
		*x=q->data[q->front];           //读出队头元素
		return TRUE; 
	}
}

//判队空
int Empty_SeQueue(CSeQueue *q){
	if(q->front==q->rear)
		return TRUE;
	else
		return FALSE;
}

// 读队头元素
int Front_SeQueue(CSeQueue *p,datatype *x){
	int k;
	if(Empty_SeQueue(p)){
		printf("队空\n");
		return FALSE;
	}
	else{
        k=p->front;
		k=(k+1)%MAXSIZE;
		*x=p->data[k];
		return TRUE;
	}
}

//测试
int main(void){
	int i;
	int x;
	CSeQueue *q;
	q=Init_SeQueue();
	if(q==NULL)
		return 0;
	else{
		printf("判断队是否为空1:%d\n",Empty_SeQueue(q));
		i=0;
		while(i
#include

#define TRUE  1
#define FALSE 0

typedef int datatype;
//链队列的数据类型描述
typedef struct node{
	datatype data;
	struct node *next;
}QNode;                      //链队列结点的描述
typedef struct {
	QNode *front; //队头指针
	QNode *rear;  //队尾指针
}LQueue;

//创建一个带头结点的空队
LQueue * Init_LQueue(){
	LQueue *q;
	QNode *p;
	q=(LQueue *)malloc(sizeof(LQueue));//申请头尾指针结点
	p=(QNode *)malloc(sizeof(QNode)); //申请链队头结点
	if(p==NULL || q==NULL)
		printf("创建失败！！\n");
	else{
		p->next=NULL;
		q->front=q->rear=p; //置空队，指向头结点
	}
	return q;
}

//入队
int IN_LQueue(LQueue *q,datatype x){
	QNode *p;
	p=(QNode *)malloc(sizeof(QNode));
	if(p==NULL){
	  printf("入队申请内存失败！\n");
	  return FALSE;
	}
	else{
		p->data=x;
		p->next=NULL;      //因为在队尾所以置为NULL
		q->rear->next=p;  //将p链接到队尾
		q->rear=p;       //改变队尾指针
	    return TRUE;
	}
}

//判队空
int Empty_LQueue(LQueue *q){
	if(q->front==q->rear) //空队条件
		return TRUE;
	else
		return FALSE;
}

//出队
int Out_LQueue(LQueue *q,datatype *x){
	QNode *p;
	if(Empty_LQueue(q)){
		printf("空队！！\n");
		return FALSE;
	}
	else{
		p=q->front->next;         //带头结点的队
		q->front->next=p->next;
		*x=p->data;
		free(p);
		if(q->front->next==NULL) //只有一个元素时，出队后为空，修改队尾指针
			q->rear=q->front;
		return TRUE;
	}
}

//打印队列中的元素
int  print_LQueue(LQueue *q){
	QNode *p;
    if(Empty_LQueue(q)){
		printf("空队！！\n");
		return FALSE;
	}
	else{
		p=q->front->next;
		while(p!=NULL){
			printf("%d\n",p->data);
			p=p->next;
		}
		return TRUE;
	}

}

//测试
int main(void){
	int x;
	LQueue *q;
	q=Init_LQueue();
	if(q==NULL)
		return 0;
	else{
		printf("判断队是否为空%d\n",Empty_LQueue(q));
		printf("请输入入队值（整形-1结束）：");
		scanf("%d",&x);
		while(x!=-1){
           IN_LQueue(q, x);
           printf("请输入入队值（整形-1结束）：");
	       scanf("%d",&x);
		}
        printf("判断队是否为空%d\n",Empty_LQueue(q));
		Out_LQueue(q,&x);
		printf("出队元素%d\n",x);
       print_LQueue(q);
		return 1;
	}
}

猜你喜欢

转载自blog.csdn.net/b903299114/article/details/47117051
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022