数据结构（C语言）--栈和队列

已于 2022-06-17 16:49:34 修改
阅读量429 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 顺序栈 链栈 顺序队列 循环队列 数据结构
于 2019-07-08 16:44:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/d_eng_/article/details/95071221
本文详细介绍了使用C语言实现的四种基本数据结构：顺序栈、链栈、链队列和循环队列。每种结构都提供了核心操作的代码示例，如创建、入栈/入队、出栈/出队等，帮助读者深入理解这些数据结构的工作原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

基于C语言实现的栈与队列

1.顺序栈

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define True 1
#define False 0


#define STACK_INT_SIZE 10  /*存储空间初始分配量*/
#define STACKINCREMENT 5  /*存储空间分配增量*/
typedef  int ElemType; /*定义元素的类型*/
typedef  int Status; /*定义元素的类型*/
typedef struct{
    ElemType *base;
    ElemType *top;
    int stacksize;     /*当前已分配的存储空间*/
}SqStack;

Status InitStack(SqStack &S);   /*构造空栈*/
Status push(SqStack &S,ElemType e); /*入栈*/
Status Pop(SqStack &S,ElemType &e);  /*出栈*/
Status GetTop (SqStack S, ElemType &e); /*取顺序栈栈顶元素*/
Status StackEmpty(SqStack  S); /*判断顺序栈是否为空*/
int StackLength( SqStack S );/*求顺序栈的长度*/
Status CreateStack(SqStack &S);     /*创建栈*/
void PrintStack(SqStack &S);   /*出栈并输出栈中元素*/
Status DestroyStack( SqStack &S );   /*销毁栈*/

Status InitStack(SqStack &S){
    S.base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType));
    if(!S.base) return ERROR;
    S.top=S.base;
    S.stacksize=STACK_INT_SIZE;
    return OK;
}/*InitStack*/

Status Push(SqStack &S,ElemType e)  /*入栈*/
{
    while(S.top-S.base>=S.stacksize)
	{
		S.base=(ElemType *)realloc(S.base,
			(S.stacksize + STACKINCREMENT)*sizeof(ElemType));
		if(!S.base)return False;
		S.top=S.base+S.stacksize;
		S.stacksize+=STACKINCREMENT;
	}
	*S.top++ =e;
	return OK;
}/*Push*/

Status Pop(SqStack &S,ElemType &e)   /*出栈*/
{
	if(S.top ==S.base)return ERROR;
	e = *--S.top;
	return OK;
	
}/*Pop*/

Status GetTop (SqStack S, ElemType &e) /*取顺序栈栈顶元素*/
{
	if(S.top ==S.base)return ERROR;
	e=*(S.top - 1);
	return OK;
}/*GetTop*/

Status StackEmpty(SqStack  S) /*判断顺序栈是否为空*/
{
	if(S.top==S.base)return True;
	else return ERROR;
}/*StackEmpty*/

int StackLength( SqStack S )/*求顺序栈的长度*/
{
	return S.top-S.base;
}/*StackLength*/

Status CreateStack(SqStack &S)    /*创建栈*/
{
    int e;
    if(InitStack(S))
        printf("Init Success!\n");
    else{
        printf("Init Fail!\n");
        return ERROR;
    }
    printf("input data:(Terminated by inputing a character)\n");
    while(scanf("%d",&e))
        Push(S,e);
    return OK;
}/*CreateStack*/

void PrintStack(SqStack &S){
    ElemType e;
    while(Pop(S,e))
        printf("%3d",e);
    printf("\n");
}/*Pop_and_Print*/

Status DestroyStack(SqStack &S)   /*销毁栈*/
{
	if( S.base )
	{
		free(S.base);
		S.stacksize = 0;
		S.base = S.top = NULL;
	}
	return OK;
}

int main(){
    SqStack ss;
	ElemType e;
    printf("\ncreate Stack\n");
    CreateStack(ss);
	GetTop(ss,e);
    printf("\nData on the top of the Stack is %d\n",e);
    printf("\n");
	if(StackEmpty(ss)) 
		printf("\nthe Stack is empty.\n");
	else
		printf("\nthe Stack is not empty.\n");
    printf("\n");
    printf("\nThere are %d datas in the Stack \n",StackLength(ss));
    printf("\n");
    printf("\nPop&Print\n");
    PrintStack(ss);	
	if(StackEmpty(ss)) 
		printf("\nthe Stack is empty.\n");
	else
		printf("\nthe Stack is not empty.\n");
    printf("\n");	
	DestroyStack(ss);
    return 0;
}

2.链栈

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define True 1
#define False 0

typedef  int SElemType; /*定义元素的类型*/
typedef  int Status; 

typedef  struct StackNode{
	SElemType  data;
	struct StackNode *next;
} StackNode, *LinkStack;

Status InitStack(LinkStack &S);   /*构造空栈*/
Status push(LinkStack &S,SElemType e); /*入栈*/
Status Pop(LinkStack &S,SElemType &e);  /*出栈*/
Status GetTop (LinkStack S, SElemType &e); /*取链栈栈顶元素*/
Status StackEmpty(LinkStack  S); /*判断链栈是否为空*/
int StackLength(LinkStack S );/*求链栈的长度*/
Status CreateStack(LinkStack &S);     /*创建栈 栈中元素依次入栈*/
void PrintStack(LinkStack &S);   /*出栈并输出栈中元素*/
Status DestroyStack(LinkStack &S );   /*销毁栈*/

Status InitStack(LinkStack &S)   /*构造空栈*/
{
	S=NULL;
	return True;
}
Status push(LinkStack &S,SElemType e) /*入栈*/
{
	StackNode *p;
	p=(StackNode *)malloc(sizeof(StackNode));
	if(!p)return False;
	p->data=e;
	p->next=S;
	S=p;
	return OK;
}
Status Pop(LinkStack &S,SElemType &e)  /*出栈*/
{
	StackNode *p;
	if(S==NULL)return ERROR;
	e = S->data;
	p=S;
	S=S->next;
	free(p);
	return OK;
}
Status GetTop (LinkStack S, SElemType &e) /*取链栈栈顶元素*/
{
	if(S==NULL)return ERROR;
	else return e=S->data;
}
Status StackEmpty(LinkStack  S) /*判断链栈是否为空*/
{
	if(S==NULL)return True;
	else return ERROR;
}
int StackLength(LinkStack S )/*求链栈的长度*/
{
	int j=0;
	while(S!=NULL)
	{
		j++;
		S=S->next;
	}
	return j;
}
Status CreateStack(LinkStack &S)     /*创建栈 栈中元素依次入栈*/
{
	int e;
	if(InitStack(S))
		printf("Init Success!\n");
    else
	{
        printf("Init Fail!\n");
        return ERROR;
	}
	printf("input data:\n");
    while(scanf("%d",&e))
        push(S,e);
    return OK;
	
}
void PrintStack(LinkStack &S)   /*出栈并输出栈中元素*/
{
	SElemType e;
	while(Pop(S,e))
	{
		
		printf("%d",e);
	}
	
}
Status DestroyStack(LinkStack &S )   /*销毁栈*/
{
	while(S)
	{
		free(S);	
	}
	return OK;
}

int main()
{
	LinkStack ss;
	SElemType e;
	printf("\ncreate Stack\n");
	CreateStack(ss);
	GetTop(ss,e);
	printf("\nData on the top of the Stack is %d\n",e);
    printf("\n");
	if(StackEmpty(ss)) 
		printf("\nthe Stack is empty.\n");
	else
		printf("\nthe Stack is not empty.\n");
    printf("\n");
    printf("\nThere are %d datas in the Stack \n",StackLength(ss));
    printf("\n");
	printf("\nPop&Print\n");
    PrintStack(ss);	
	if(StackEmpty(ss)) 
		printf("\nthe Stack is empty.\n");
	else
		printf("\nthe Stack is not empty.\n");
    printf("\n");	
	DestroyStack(ss);
    return 0;
}

3.链队列

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define True 1
#define False 0

typedef  int QElemType; /*定义元素的类型*/
typedef  int Status; 

typedef  struct QNode{//结点类型
	QElemType data ;
	struct QNode *next ;
}QNode, *QueuePtr;
typedef   struct{ // 链队列类型
	QueuePtr front;  //队头指针
	QueuePtr rear;   //队尾指针
}LinkQueue;

Status InitQueue (LinkQueue &Q);   /*初始化链队列*/
Status EnQueue(LinkQueue &Q, QElemType e); /*入队*/
Status DeQueue(LinkQueue &Q, QElemType &e);  /*出队*/
Status GetHead(LinkQueue Q, QElemType &e); /*取链队列的队头元素*/
Status QueueEmpty(LinkQueue Q); /*判断链队列是否为空*/
int QueueLength (LinkQueue Q);/*求队长*/
Status CreateQueue(LinkQueue &Q);     /*创建链队列  链队列中元素依次入队*/
void PrintQueue(LinkQueue &Q);   /*输出链队列中元素*/
Status DestroyQueue(LinkQueue &Q);   /*销毁链队列*/

Status InitQueue(LinkQueue &Q)   /*初始化链队列*/
{
	Q.front=Q.rear=(QNode *)malloc(sizeof(QNode));
	if(!Q.front)return False;
	Q.front->next=NULL;
	return OK;
}
Status EnQueue(LinkQueue &Q, QElemType e) /*入队*/
{
	QNode *p;
	p=(QNode *)malloc(sizeof(QNode));
	if(!p)return False;
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p;
	return OK;
}
Status DeQueue(LinkQueue &Q, QElemType &e)  /*出队*/
{
	QNode *p;
	if(Q.front==Q.rear)return ERROR;
	p=Q.front->next;
	e=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)Q.rear=Q.front;    //Q.rear=Q.front不可换边，程序提前结束
	free(p);
	return OK;
}
Status GetHead(LinkQueue Q, QElemType &e) /*取链队列的队头元素*/
{
	QNode *p;
	if(Q.front==Q.rear)return ERROR;
    p=Q.front->next;
	e=p->data;
	Q.front->next=p->next;
    if(Q.rear==p)Q.front=Q.rear;
	free(p);
	return OK;
}
Status QueueEmpty(LinkQueue Q) /*判断链队列是否为空*/
{
	if(Q.front==Q.rear)return True;
	else return ERROR;
}
int QueueLength (LinkQueue Q)/*求队长*/
{
    QNode *p;
	QElemType j=0;
    while(Q.front)
	{
		p=Q.front->next;
		j++;
		Q.front=Q.front->next;
	}
	return j;
}
Status CreateQueue(LinkQueue &Q)     /*创建链队列  链队列中元素依次入队*/
{
	QElemType e;
	if(InitQueue(Q))
		printf("Init Success!\n");
    else
	{
        printf("Init Fail!\n");
        return ERROR;
	}
	printf("input data:\n");
    while(scanf("%d",&e))
        EnQueue(Q,e);
    return OK;
}
void PrintQueue(LinkQueue &Q)   /*输出链队列中元素*/
{
	QElemType e;
	while(DeQueue(Q,e))
	printf(" %d  ",e);
}
Status DestroyQueue(LinkQueue &Q)   /*销毁链队列*/
{
	while(Q.front)
	{
		Q.rear=Q.front->next;
		free(Q.front);
		Q.front=Q.rear;
	}
	return OK;
}

int main()
{
	LinkQueue ss;
	QElemType e;
	printf("\ncreate Queue\n");
	CreateQueue(ss);
	GetHead(ss,e);
	printf("\nData on the ahead of the Queue is %d\n",e);
    printf("\n");
	if(QueueEmpty(ss)) 
		printf("\nthe Queue is empty.\n");
	else
		printf("\nthe Queue is not empty.\n");
    printf("\n");
    printf("\nThere are %d datas in the Queue \n",QueueLength(ss));
    printf("\n");	
    printf("\n DeQueue & Print\n");
    PrintQueue(ss);	
	if(QueueLength(ss)) 
		printf("\nthe Queue is empty.\n");
	else
		printf("\nthe Queue is not empty.\n");
    printf("\n");
	DestroyQueue(ss);
    return 0;
}

4.循环队列

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define True 1
#define False 0
#define MAXQSIZE 10 // 最大队列长度

typedef  int QElemType; /*定义元素的类型*/
typedef  int Status; 

typedef struct {
	QElemType *base;// 动态分配存储空间基址
	int front;//队头指针　
	int rear;//队尾指针
} SqQueue;

Status InitQueue (SqQueue &Q);   /*初始化循环队列*/
Status EnQueue(SqQueue &Q, QElemType e); /*入队*/
Status DeQueue(SqQueue &Q, QElemType &e);  /*出队*/
Status GetHead(SqQueue Q, QElemType &e); /*取循环队列的队头元素*/
Status QueueEmpty(SqQueue Q); /*判断循环队列是否为空*/
int QueueLength (SqQueue Q);/*求队长*/
Status CreateQueue(SqQueue &Q);     /*创建循环队列  循环队列中元素依次入队*/
void PrintQueue(SqQueue &Q);   /*输出循环队列中元素*/
Status DestroyQueue(SqQueue &Q);   /*销毁栈循环队列*/

Status InitQueue (SqQueue &Q)   /*初始化循环队列*/
{
	Q.base=(QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
	if(!Q.base)return False;
	Q.front=Q.rear=0;
	return OK;
}
Status EnQueue(SqQueue &Q, QElemType e) /*入队*/
{
	if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;
	Q.base[Q.rear] = e;
	Q.rear=(Q.rear+1)%MAXQSIZE;
	return OK;
}
Status DeQueue(SqQueue &Q, QElemType &e)  /*出队*/
{
	if(Q.front==Q.rear)return ERROR;
	e=Q.base[Q.front];
	Q.front=(Q.front+1)%MAXQSIZE;
	return OK;
}
Status GetHead(SqQueue Q, QElemType &e) /*取循环队列的队头元素*/
{
    if(Q.front==Q.rear)return ERROR;
    e = Q.base[Q.front];
	Q.front=(Q.front+1)%MAXQSIZE;
	return OK;
}
Status QueueEmpty(SqQueue Q) /*判断循环队列是否为空*/
{
	if(Q.front==Q.rear)return True;
	else return ERROR;
}
int QueueLength (SqQueue Q)/*求队长*/
{
	return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}
Status CreateQueue(SqQueue &Q)     /*创建循环队列  循环队列中元素依次入队*/
{
	QElemType e;
    if(InitQueue(Q))
        printf("Init Success!\n");
    else{
        printf("Init Fail!\n");
        return ERROR;
    }
    printf("input data:\n");
    while(scanf("%d",&e))
        EnQueue(Q,e);
    return OK;
}
void PrintQueue(SqQueue &Q)   /*输出循环队列中元素*/
{
	QElemType e;
    while(DeQueue(Q,e))
        printf("%3d",e);
    printf("\n");
}
Status DestroyQueue(SqQueue &Q)   /*销毁栈循环队列*/
{
	while ( Q.front!= Q.rear)
{
  free(&Q.base[Q.front]);
  Q.front=(Q.front+1)%MAXQSIZE;
}	
   return OK;
}
int main()
{
    SqQueue ss;
	QElemType e;
	printf("\ncreate Queue\n");
	CreateQueue(ss);
	GetHead(ss,e);
	printf("\nData on the ahead of the Queue is %d\n",e);
    printf("\n");
	if(QueueEmpty(ss)) 
		printf("\nthe Queue is empty.\n");
	else
		printf("\nthe Queue is not empty.\n");
    printf("\n");
    printf("\nThere are %d datas in the Queue \n",QueueLength(ss));
    printf("\n");	
    printf("\n DeQueue & Print\n");
    PrintQueue(ss);
	DestroyQueue(ss);
	printf("\nthe Queue is destroy......\n");
	printf("\n");
    return 0;
}
数据结构C语言实现栈和队列的基本操作
12-12
用C语言实现了栈和队列的数据结构形式，其中包括栈和队列的初始化，压栈弹栈，进队出堆。和一些其他的基本操作！
C语言-数据结构-栈队列实现
03-10
本主题关注的是如何使用C语言来实现数据结构中的栈和队列，这是两种基础但非常重要的抽象数据类型（ADT）。 栈（Stack）是具有后进先出（LIFO）特性的数据结构。它类似于一个堆叠的盘子，最新的元素被放在顶部，...
数据结构学习之栈和队列（C语言）
m0_62480610的博客
08-05 393
数据结构中栈和队列的学习
C语言数据结构之栈与队列的应用（3）
weixin_30469895的博客
11-02 172
循环队列的应用——舞伴配对问题：在舞会上，男、女各自排成一队。舞会开始时，依次从男队和女队的队头各出一人配成舞伴。如果两队初始人数不等，则较长的那一队中未配对者等待下一轮舞曲。假设初始男、女人数及性别已经固定，舞会的轮数从键盘输入。试模拟解决上述舞伴配对问题。要求：从屏幕输出每一轮舞伴配对名单，如果在该轮有未配对的，能够从屏幕显示下一轮第一个出场的未配对者的姓名。//舞伴配对问题 #def...
C语言数据结构-栈和队列
最新发布
2302_81072215的博客
11-30 1075
/定义栈的数据结构int top;//指向栈顶的位置//空间的大小}ST;由于队列是由链表构成的，所以在结构体定义时，需要将链表中的头结点和尾节点定义出来，队列是由数据域和指针域组成的，也是需要定义出来的。//定义队列结点结构体}QN;QN* phead;QN* ptail;
数据结构——栈和队列（C语言）
m0_68993099的博客
07-06 479
数据结构——栈和队列
数据结构---栈和队列之共享栈（C语言）
05-05
数据结构---栈和队列之共享栈（C语言）完整代码，可以运行
数据结构---栈和队列之顺序栈（C语言）
05-05
在这个主题中，我们将专注于两种基本的线性数据结构：栈和队列，特别是C语言实现的顺序栈。顺序栈是一种在内存中连续分配空间的抽象数据类型，它具有后进先出（LIFO）或先进后出（FILO）的特性。 ### 栈的基本概念 ...
数据结构---栈和队列之顺序队（C语言）
05-05
本主题聚焦于两种基本数据结构：栈和队列，特别是它们的一个实例——顺序队，用C语言实现。这里我们将深入探讨这些概念以及它们在实际编程中的应用。 栈是一种后进先出（LIFO）的数据结构，这意味着最后插入的元素...
c语言数据结构-栈队列数组完美版资料.ppt
11-14
总结来说，栈、队列和数组是C语言中不可或缺的数据结构，它们各有特点，各有优势。理解它们的工作原理和适用场景对于任何想要深入学习计算机科学和编程的开发者来说，都是一个不可或缺的过程。通过本资源，我们希望...
C语言栈和队列代码实现
08-08
包含内容：栈、队列、循环队列的数组实现方式和链表实现方式
数据结构#include
01-05
#include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; #include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList;
数据结构C语言实现——栈和队列
qq_42642142的博客
11-13 731
本文记录了自己学习数据结构与算法课程的栈及队列实现代码 栈部分 stack.h #ifndef STACK_H_ #define STACK_H_ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;stdbool.h&gt; #include&lt;math.h&gt; #include&lt;string.h&gt; #define MAXSIZE 100 typedef int StackType; //顺序栈结构// type
数据结构栈和队列详解（C语言实现）
weixin_58666778的博客
11-22 1281
队列 栈
数据结构---栈和队列之链栈（C语言）
小陆同学LLR的博客
04-10 697
链栈就是采用链表来存储栈。链栈示意图如下。一般用带头结点的单链表实现链栈主要是入栈和出栈操作。入栈其实就是链表的头插法入栈示意图：出栈示意图：---------------------------------------------------------------------------------------------------------------------------------...
数据结构——栈与队列(C语言)
xiaobai06的博客
08-05 989
栈与队列的定义和特点 栈的定义和特点 栈是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾有其特殊含义，称为栈顶，相应地，表头端称为栈底。不含元素的空表称为空栈。 假设栈S=(a1a_1a1​,a2a_2a2​,···,ana_nan​)，则称a1a_1a1​为栈底元素，ana_nan​为栈顶元素。栈中元素按a1a_1a1​，a2a_2a2​，····，ana_nan​的次序进栈，退栈...
栈和队列（C语言版）
坚持是一种品质
02-18 6957
栈和队列是在程序中最常被用到的数据结构，其重要性不言而喻。栈： 定义：限定仅在表尾进行插入和删除操作的线性表，因此表尾称之为栈顶,表头为栈底，重要特点是后进先出（LIFO）操作： InitStack(&S) 初始化一个栈 DestoryStack(&S)销毁一个已经存在的栈 ClearStack(&S)清空一个栈 StackEmpty(S)判断已存在的栈是否为空 St
数据结构与算法--栈和队列代码实现（C语言）
weixin_59725175的博客
06-28 478
数据结构与算法--栈和队列代码实现（C语言）
[C语言数据结构]栈
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
11-15 989
用数组实现栈的详细操作-----C语言；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值