栈和队列的操作（c）

最新推荐文章于 2022-01-28 19:46:54 发布
最新推荐文章于 2022-01-28 19:46:54 发布
阅读量403 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/B903299114/article/details/47117051
版权

全部在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; } }

 

自由的路飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[栈及队列的操作]数据结构实验报告C语言源码
07-05
实验报告 栈和队列 数据结构C语言源代码 够详细
Linux内核中的dup系统调用
qingkongyeyue的博客
03-28 986
转自http://www.51testing.com/html/49/n-832449-2.html 2、内核初始化中的相关源码分析 static int init(void * unused) {  ...  if (sys_open((const char __user *) "/dev/console", O_RDWR, 0)   printk(KE
栈和队列基本操作及练习
08-05
栈和队列基本操作及练习
【浅谈数据结构】队列的基本函数与操作
GuLeng______的博客
01-28 2199
文章目录1、定义及基本运算定义:说明：注意：2、队列的基本运算(0)、队列的定义(1)、QueueInit（Q）(2)、QueueEmpty（Q）(3)、 QueueFull（Q）(4)、EnQueue（Q，x）(5)、 DeQueue（Q）(6)、QueueFront（Q）一、顺序队列(1)、顺序队列的定义(2)、 顺序队列的表示(3)、 顺序队列的基本操作注意：二、循环队列 1、定义及基本运算 定义: 队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表 说明：   (1)、允
程序填空题
大家一起入坑
12-26 5392
5-1 链栈入栈出栈操作。 #include<iostream> using namespace std; typedef char SElemType; typedef struct StackNode { SElemType data; struct StackNode *next; } StackNode, *LinkStack; int Push(LinkStack &S, SElemType e) { LinkStack p; p
栈和队列的基本操作
01-02
把堆栈和队列的顺序存储（环队）和链表存储的数据进队、出队等运算其中一部分进行程序实现。可以实验一的结果自己实现数据输入、数据显示的函数。
C语言 表、栈和队列详解及实例代码
01-20
C语言 表、栈和队列详解 表ADT  形如A1,A2,A3…An的表，这个表的大小为n，而大小为0的表称为空表，非空表中，Ai+1后继Ai，Ai-1前驱Ai，表ADT的相关操有PrintList打印表中的元素；CreateEmpty创建一个空表；Find...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
C语言用栈和队列实现的回文检测功能示例
01-20
本文实例讲述了C语言用栈和队列实现的回文功能。分享给大家供大家参考，具体如下： #include #include<malloc>//内存分配头文件 #include<math.h>//在math.h中已定义OVERFLOW的值为3 #define SIZE 100 #...
数据结构 栈与队列
迁就100
07-08 275
实验项目中文名称：栈与队列 实验项目英文名称：Stack and queue 实验项目编码：2 实验学时：5 适用专业：信息与计算科学、数学与应用数学 所属课程：数据结构 开课学院：理学院 开课学期：第5学期 教材及实验指导书： 耿国华主编，《数据结构—（第三版）》，电子工业出版社，2011年 一、实验目的或任务 通过指导学生上机实践，对常用数据结构的基本概念及其不同的实现方法的理论得到进一步的掌...
数据结构：栈和队列（c语言）
qq_37253540的博客
07-21 1114
一、栈和队列基本介绍 栈和队列是两种重要的线性结构。从数据结构角度来看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集，他们是操作受限制的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，它们是和线性表大不相同的两类重要的抽象数据类型。由于它们广泛应用在各种软件系统中，因此在面向对象的程序设计中，它们是多型数据类型。 二、栈 栈是限定仅在表尾进行插入或者删除操作的线性表。因此，对栈来说，表尾端有特殊含义，称为栈顶，相应的，表头称为栈底。不含元素的空表称为空栈。 栈的修改
多栈共享技术，双端栈的初始化、进栈、出栈操作
weixin_33724659的博客
05-08 508
栈的应用非常广泛，经常会出现一个程序中需要同时使用多个栈的情况。若使用顺序栈，会因为对栈空间大小难以准确估计，从而产生有的栈溢出、有的栈空间还很空闲的情况。为了解决这个问题，可以让多个栈共享一个足够大的数组空间，通过利用栈的动态特性来使其存储空间互相补充，这就是多栈的共享技术。 在顺序栈的共享技术中，最常用的是两个栈的共享技术，即双端栈。它主要利用了栈的栈底位置...
数据结构--实验2--队列的操作
weixin_30631587的博客
07-02 788
1 #include"stdio.h" 2 #include"malloc.h" 3 typedef int datatype; 4 5 #define MAXSIZE 50 //队列的最大容量 6 //定义队列结构体 7 typedef struct 8 { 9 datatype data[MAXSIZE]; 10 i...
考研题目 第三章 栈和队列
懒王子的专栏
12-02 1万+
导读： 　　2. 在作进栈运算时,应先判别栈是否( ① ),在作退栈运算时应先判别栈是否( ② )。当栈中元素为n个,作进栈运算时发生上溢,则说明该栈的最大容量为( ③ )。 　　为了增加内存空间的利用率和减少溢出的可能性,由两个栈共享一片连续的内存空间时,应将两栈的( ④ )分别设在这片内存空间的两端,这样,当( ⑤ )时，才产生上溢。 　　①, ②: A. 空 B. 满 C. 上溢 D
循环队列初始化C语言传指针,C语言实现循环队列的初始化&进队&出队&读取队头元素&判空-1...
weixin_35853254的博客
05-20 1064
目前，处在学习数据结构+ing，由于之前学过了队列，今天就把自己写过的代码做了一些完善分享给大家，希望能够帮助到有需要的朋友，有不足的地方欢迎大家交流 φ(゜▽゜*)♪队列是另一种限定性的线性表，它只允许在表的一端插入元素，而在另一端删除元素，所以队列具有先进先出的特性。系统用到的抽象数据类型定义ADT Queue{数据元素：可以是任意类型的数据，但必须属于同一个数据对象。数据关系：队列中数...
共享栈：定义及基本操作的代码实现
a1369760658的博客
02-23 1250
共享栈的定义及基本操作的代码实现 所用编译器：Visual Studio Code 1.42.1 C++环境 #include <stdio.h> #define MaxSize 15 //定义int别名为ElemType typedef int ElemType; //栈的数据结构表示 typedef struct{ ElemType data[MaxSize]; ...
数据结构与算法（C语言） | 栈和队列——队列
Shannon
08-06 1014
                                                                队列  •与栈相反，队列是一种先进先出（First In First Out, FIFO）的线性表。只允许在表尾一端进行插入操作而在表头一端进行删除操作。   队列既可以用链表实现，也可以用顺序表实现。 跟栈相反的是，栈一般我们用顺序表来实现，而队列我们常用链...
顺序队列
weixin_30852367的博客
03-21 152
顺序队列的出队、入队、判空、判满，挖五个空，填写代码。 #include<stdio.h> #include<malloc.h> #define Maxsize 100 typedef struct{ int data[Maxsize]; int rear,front; int num; }C_Sequeue; //队列的初始化算法 C_Sequ...
队列相关习题及详解(选择题和综合题) ——数据结构
热门推荐
Amour
10-31 3万+
队列的基本概念队列的定义队列（Queue）：队列简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队是一致的，最早排队的也是最早离队的。其操作的特性是先进先出（First In First Out, FIFO），故又称为先进先出的线性表。队头（Front）：允许删除的一端，又称为首队 队
 数据结构栈和队列c语言
最新发布
10-19
栈和队列是两种常见的数据结构，它们都可以用来存储一系列的数据，并且具有不同的...在C语言中，栈和队列可以用数组或链表来实现。引用和分别介绍了链队列和顺序队列的存储结构，而引用则介绍了循环队列的实现方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值