数据结构与算法（二）栈和队列c语言实现

最新推荐文章于 2023-04-07 23:35:22 发布
最新推荐文章于 2023-04-07 23:35:22 发布
阅读量259 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 队列 栈 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52534495/article/details/113780893
版权

数据结构与算法（二）栈和队列

  1. 栈的顺序实现

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct Arr
{
	int* pBase;
	int len;//数组长度
	int top;//栈顶指针
}Arr;

void init_arr(Arr*, int);
bool push(Arr*, int);
bool insert_arr(Arr*, int, int);
bool pop(Arr*,int*);
bool is_empty(Arr*);
bool is_full(Arr* pArr);
void sort_arr(Arr*);
void show_arr(Arr*);
void inversion_arr(Arr*);

int main()
{
	int val0;
	int val1;
	struct Arr arr;
	init_arr(&arr, 6);
	push(&arr, 1);
	push(&arr, 2);
	push(&arr, 3);
	show_arr(&arr);
	pop(&arr, &val0);
	pop(&arr, &val1);
	printf("弹出的数字是：%d\n",val0);
	printf("弹出的数字是：%d\n",val1);
	show_arr(&arr);
	free((&arr)->pBase);
	return 0;
}

void init_arr(Arr* pArr, int length)
{
	pArr->pBase = (int*)malloc(sizeof(int) * length);
	if (pArr->pBase == NULL)
	{
		printf("内存分配失败\n");
		exit(-1);
	}
	else
	{
		pArr->top = 0;
		pArr->len = length;
	}
}

bool push(Arr* pArr, int val)
{
	if (is_full(pArr))
		return false;
	else
	{
		pArr->pBase[pArr->top] = val;
		(pArr->top++);
		return true;
	}

}

void show_arr(Arr* pArr)
{
	if (is_empty(pArr))
	{
		printf("数组为空\n");
	}
	else
	{
		for (int i = pArr->top - 1; i >= 0; --i)
		{
			printf("%d\n", pArr->pBase[i]);
		}
	}
}

bool is_empty(Arr* pArr)
{
	if (pArr->top == NULL)
		return true;
	else
		return false;
}

bool is_full(Arr* pArr)
{
	if (pArr->top == pArr->len)
		return true;
	else
		return false;
}

bool pop(Arr* pArr, int* pVal)
{
	if (is_empty(pArr))
		return false;
	else
	{
		*pVal = pArr->pBase[pArr->top-1];
		pArr->top--;
	}
	return true;
}

在这里插入图片描述

  1. 两栈共享空间
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <math.h>
#include <time.h>


#define MAX 20

typedef struct
{
	int data[MAX];
	int top1;
	int top2;
}SqDuStack;

int visit(int c)
{
	printf("%d ",c);
	return 1;
}

int initStack(SqDuStack* S)
{
	S->top1 = -1;
	S->top2 = MAX;
	return 1;
}

int ClearStack(SqDuStack* S)
{
	S->top1 = -1;
	S->top2 = MAX;
	return 1;
}

int StackEmpty(SqDuStack* S)
{
	if (S->top1 == -1 && S->top2 == MAX)
		return 1;
	else
		return 0;
}

int StackLength(SqDuStack* S)
{
	return (S->top1 + 1) + (MAX - S->top2);
}

int push(SqDuStack* S, int e, int stackNumber)
{
	if (S->top1 + 1 == S->top2)
		return 0;
	if (stackNumber == 1)
		S->data[++S->top1] = e;
	else if (stackNumber == 2)
		S->data[--S->top2] = e;
	return 1;
}

int pop(SqDuStack* S, int* e, int stackNumber)
{
	
	if (stackNumber == 1)
	{
			if (S->top1 == -1)
				return 0;
			*e = S->data[S->top1--];
	}
	else if(stackNumber == 2)
	{
			if (S->top2 == MAX)
				return 0;
				*e = S->data[S->top2++];
	}
	return 1;
}

int StackTraverse(SqDuStack* S)
{
	int i = 0;
	while (i <= S->top1)
	{
		visit(S->data[i++]);
	}
	i = S->top2;
	while (i < MAX)
	{
		visit(S->data[i++]);
	}
	printf("\n");
	return 1;
}

int main()
{
	int j;
	SqDuStack s;
	int e;
	if (initStack(&s) == 1)
	{
		for (j = 1; j <= 5; j++)
			push(&s, j, 1);
		for (j = MAX; j >= MAX - 2; j--)
			push(&s,j,2);
	}

	printf("栈中的元素为：");
	StackTraverse(&s);

	printf("当前栈中元素有：%d\n",StackLength(&s));

	pop(&s,&e,2);
	printf("弹出的栈顶元素为e=%d\n",e);
	printf("栈是否为空：%d(1空，0非空)\n",StackEmpty(&s));

	for (j = 6; j < MAX - 2; j++)
		push(&s,j,1);

	printf("栈中元素依次为：");
	StackTraverse(&s);

	printf("栈满否：%d(1空，0非空)\n", push(&s,100,1));


	ClearStack(&s);
	printf("清空后，栈空否：%d(1空，0非空)\n", StackEmpty(&s));
	return 0;
}

在这里插入图片描述
静态栈的使用-迷宫求解

  1. 栈的链式实现
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

typedef struct node
{
	int data;
	struct  node* next;
}NODE,*PNODE;

typedef struct linklist
{
	PNODE top;//栈顶指针
	int count;//计数
}LinkStack;

void init_Stack(LinkStack* pS)
{
	pS->count = 0;
	pS->top = NULL;
}

bool push(LinkStack* pS, int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if (pNew == NULL)
	{
		printf("内存分配失败\n");
		exit(-1);
	}
	pNew->data = val;
	pNew->next = pS->top;
	pS->top = pNew;
	pS->count++;
	return true;
}

bool pop(LinkStack* pS, int* pVal)
{
	PNODE p;
	if (pS->top == NULL)
		return false;
	else
	{
		*pVal = pS->top->data;
		p = pS->top;
		pS->top = p->next;
		free(p);
		pS->count--;
		return true;
	}
}

void show(LinkStack* pS)
{
	int i = 0;
	PNODE q = pS->top;
	if (pS->count == 0)
		printf("栈为空\n");
	else 
	{
		for (i = 0; i < pS->count; ++i)
		{
			printf("%d\t",q->data);
			q = q->next;
		}
		printf("\n");
	}
}

int main()
{
	int val;
	LinkStack S;
	init_Stack(&S);
	push(&S,1);
	push(&S,2);
	push(&S,3);
	push(&S,4);
	show(&S);
	pop(&S,&val);
	printf("弹出的数字为：%d\n",val);
	show(&S);
	return 0;
}

在这里插入图片描述

  1. 栈与递归
#include <stdio.h>

int move(int n, char X, char Y)
{
	printf("将%c的%d块：%c-->%c\n",X,n,X,Y);
	return 0;
}

void hanoi(int n, char X, char Y, char Z)
{
	if (n == 1)
	{
		move(n,X,Z);
	}
	else
	{
		hanoi(n-1,X,Z,Y);
		move(n,X,Z);
		hanoi(n - 1, Y, X, Z);
	}
}

int main()
{
	int n;
	printf("几个：\t");
	scanf_s("%d",&n);
	hanoi(n,'A','B','C');
}

在这里插入图片描述

  1. 队列的顺序实现
/*顺序栈由于空间有限所以一般使用循环队列*/

#include <stdio.h>
#include <malloc.h>

#define MAX 10

typedef struct
{
	int data[MAX];
	int rear, front;
}SeQueue;

void init_Queue(SeQueue* Sq)
{
	Sq->front = -1;
	Sq->rear=Sq->front;
}


bool is_full(SeQueue* Sq)
{
	if ((Sq->rear + 1) % MAX == Sq->front)
		return true;
	else
		return false;
}

bool In_Queue(SeQueue* Sq,int val)
{
	if (is_full(Sq))
		return false;
	else
	{
		Sq->rear=(Sq->rear+1)%MAX;
		Sq->data[Sq->rear] = val;
	}
	return true;
}

bool Out_Queue(SeQueue* Sq, int* pVal)
{
	Sq->front=(Sq->front+1)%MAX;
	*pVal = Sq->data[Sq->front];
	Sq->data[Sq->front] = NULL;
	return true;
}

void show(SeQueue* Sq)
{
	int i = 0;
	for (i = 0; i < MAX; i++)
	{
		printf("%d\t",Sq->data[i]);
	}
	printf("\n");
}

int main()
{
	int val;
	SeQueue q;
	init_Queue(&q);
	In_Queue(&q, 1);
	In_Queue(&q, 2);
	In_Queue(&q, 3);
	In_Queue(&q, 4);
	In_Queue(&q, 5);
	In_Queue(&q, 6);
	In_Queue(&q, 7);
	In_Queue(&q, 8);
	In_Queue(&q, 9);
	In_Queue(&q, 10);
	In_Queue(&q, 11);
	show(&q);
	Out_Queue(&q,&val);
	printf("出队的数字是%d\n",val);
	show(&q);
	return 0;
}

在这里插入图片描述

  1. 队列的链式实现
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

typedef struct node
{
	int data;
	struct node* next;
}NODE,*PNODE;

typedef struct
{
	PNODE front;
	PNODE rear;
}LinkQueue;

void init_Queue(LinkQueue* Sq)
{
	Sq->front = (PNODE)malloc(sizeof(NODE));
	if (Sq->front == NULL)
	{
		printf("内存分配失败\n");
		exit(-1);
	}
	else
	{
		Sq->rear = Sq->front;
		Sq->front->next = NULL;
	}
}


bool is_empty(LinkQueue* Sq)
{
	if (Sq->front == Sq->rear)
		return true;
	else
		return false;
}

bool In_Queue(LinkQueue* Sq,int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if (pNew == NULL)
	{
		printf("内存分配失败\n");
		exit(-1);
	}
	else
	{
		pNew->data = val;
		pNew->next = NULL;
		Sq->rear->next = pNew;
		Sq->rear = pNew;
		return true;
	}
}

bool Out_Queue(LinkQueue* Sq, int* pVal)
{
	if (is_empty(Sq))
		return false;
	else
	{
		PNODE q = Sq->front->next;
		*pVal = q->data;
		Sq->front->next = q->next;
		free(q);
		q = NULL;

		if (Sq->front->next == NULL)
		{
			Sq->rear = Sq->front;
		}
		return true;
	}
}

void show(LinkQueue* Sq)
{
	PNODE q = Sq->front;
	while (q != Sq->rear)
	{
		printf("%d\t",q->next->data);
		q = q->next;
	}
	printf("\n");
}

int main()
{
	int val;
	LinkQueue q;
	init_Queue(&q);
	In_Queue(&q, 1);
	In_Queue(&q, 2);
	In_Queue(&q, 3);
	In_Queue(&q, 4);
	show(&q);
	Out_Queue(&q, &val);
	printf("出队的数字是%d\n", val);
	show(&q);
	return 0;
}

在这里插入图片描述如有问题请多指教

一个董憨憨
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言--用栈实现队列
loreal8的博客
04-13 488
用栈实现队列 要想用栈实现队列功能，则至少需要2个栈。 存储数据的栈按照栈的后进先出原则依次进入另一个栈，再按照栈的后进先出原则出栈就实现了队列的先进先出，相当于负负得正的感觉。 typedef int type; typedef struct Stack { type* array; size_t size; size_t capacity; }Stack; //栈初始化 void Sta...
算法总结 栈+队列(c语言实现)
天上飞的云传奇
03-25 175
栈+队列 还是一道题 两个人交替出牌。出牌时，如果某人打出的牌与桌上某张牌的牌面相同，即可将两张相同的牌及其中间所夹的牌全部取走，并依次放到自己手中牌的末尾。当任意一人 手中的牌全部出完时，游戏结束，对手获胜。 两个人可以当成两个队列，出牌是出队，赢牌是入队。而桌面则可当成栈，有牌则top++，人拿回牌则top–; 首先创建结构体实现队和栈 typedef struct node1...
反转链表
weixin_39618542的博客
10-03 115
/* 链表结构 */ typedef struct node{ int val; struct node *next; }ListNode; /* 反转单向链表 */ ListNode *reverlist(ListNode *head) { ListNode *pre = NULL; ListNode *cur = head; ListNode *tmp = cur; while...
c语言错题集
hkkcsdn的博客
12-30 5065
在 C 语言程序中 , 凡是没有出现存储类说明符的变量都是自动类的。 (1分) T F 正确答案是T 两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。 (1分) T F 正确答案是T： 根据声明int a[10], *p=a; ，下列表达式错误的是（d）。 (2分) a[9] p[5] a++ *p++ 以下数组定义中错误的是（ ）。 (2分) in...
二叉树的建立
Davidmvp的博客
10-28 425
#include<stdio.h> #include<conio.h> #include <cstdlib> #include<malloc.h> #define MAX 20 typedef struct BTNode { /*节点结构声明*/ char data ; /*节点数据*/ struct B...
常见数据结构与算法C语言实现
最新发布
05-04
# 常见数据结构与算法C语言实现 内容包含常见基本数据结构实现（C语言版）如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等 以及包含各个数据结构常见算法题的解答（C语言版...
数据结构各章节算法实现（C语言版）.docx
10-12
本资料《数据结构各章节算法实现（C语言版）》提供了详细的数据结构算法实现，采用C语言编写，适合计算机专业的学生、ACM竞赛参与者、考研复习者以及准备面试笔试的人群使用。以下是对各个章节主要算法的详细说明： ...
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据结构初学者的一个优秀教材，旨在帮助读者快速掌握这一领域。 首先，数据...
使用C语言实现的常见数据结构和算法.zip
10-09
这个名为"使用C语言实现的常见数据结构和算法.zip"的压缩包很可能包含了多种常用的数据结构及其相关的算法实现，旨在帮助学习者通过C语言提升自己的编程技能。 数据结构是组织、存储和管理数据的方式，它允许我们...
C语言描述的数据结构与算法教程
09-23
数据结构与算法是计算机科学的基础，C语言作为一门强大的编程语言，被广泛用于描述和实现这些概念。本教程旨在帮助初学者理解数据结构和算法，并通过C语言进行实践。同时，教程还涉及到机器学习的基本算法，使学习者...
数据结构#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;
二叉树的基本操作（参考数据结构严蔚敏版）
weixin_46356798的博客
10-12 1985
以ABC###DE##F##为例，先序建立二叉树，并完成基本操作。 在这里插入代码片
【c语言】链表（适合初学者）
weixin_74337975的博客
04-07 2280
C语言中的链表是一种常见的数据结构，它由一系列的节点（node）组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表可以用来表示各种数据结构，例如队列、堆栈、树等。在C语言中，链表的节点通常是通过结构体来定义的。int data;在这个结构体中，data是节点存储的数据元素，next是指向下一个节点的指针。因为next指向的是另一个Node类型的结构体，所以需要使用类型来定义。链表的头指针是指向第一个节点的指针，通常称为head。对于一个空链表，头指针为NULL。链表的尾节点的next。
链栈及思考
晓逸_诶嘿的博客
05-05 800
链栈及思考 文章目录链栈及思考1 创建结构2 初始化3 判空4 向栈中添加元素5 从栈中删除元素6 销毁栈完整代码 1 创建结构 typedef struct SNode { int data; struct SNode * next; }SNode, *LinkStack; 这里创建了一个结点，其中包含数据域data和指针域next，二者共同构成结点SNode，引用的方式举例： SNode k – 声明一个结点 SNode * s – 声明一个指向结点的指针 LinkStack L
DIJ算法之path路径求解
weixin_45875453的博客
06-04 627
path路径求解 关于使用迪杰特斯拉算法对路径求解 在使用迪杰特斯拉算法后我们会直接得到一个源点到另一个顶点的距离，以及根据path矩阵能得出所到各个顶点的前驱，接下来是小编写的一种算法，利用栈的思想将根据path矩阵得出源点到各个顶点的一个路径。 代码如下： void Show_MG_path(MGraph* G, bool p[][MAX_VERTEX_NUM], Stack* s, VertexType v, VertexType v0) //打印某条路径 { if (p[v][0] == fal
C语言 数据结构 实验二 【自用】
LangYueMoon的博客
01-26 1354
C语言 数据结构 实验二 8583 - 顺序栈的基本操作 #include <malloc.h> #include <stdio.h> #define OK 1 #define ERROR 0 #define STACK_INIT_SIZE 100 //存储空间初始分配量 #define STACKINCREMENT 10 //存储空间分配增量 typedef int ...
数据结构学习笔记（7）顺序循环队列
weixin_52971492的博客
11-26 471
完整代码 目录 Queue.h Queue.c Queue.h #pragma once #include<stdio.h> #include<malloc.h> #include<stdlib.h> #define MaxSize 6 typedef int DataType; typedef struct { DataType queue[MaxSize]; int front; int rear; int count; }SeqQueue;
链表
weixin_30325971的博客
11-08 62
不支持随机访问，相比数组占用额外的空间，适合有大量插入和删除，无访问要求的操作。 1.链表生成：头插和尾插 typedef struct node{ int val; struct node* next; }Node,*pNode; int a[]={1,2,3,4,5}; pNode phead = (pNode)calloc(sizeof(Node),0); ...
C语言每日一题（四）
万里羊的博客
12-06 3922
C语言作为嵌入式Linux开发的必备工具，作为嵌入式Linux开发的基础语言，那么在面试嵌入式工程师时C语言定是面试中的重中之重 。作为一名大三的老学长，不得不为找工作做必要准备。每天做一道C语言面试题，为面试打基础。
数据结构深入解析：栈与队列
本资料主要介绍了两个基本的数据结构——栈和队列，特别是它们在C语言中的实现。 栈是一种特殊的线性数据结构，被称为“后进先出”（LIFO，Last In First Out）或“先进后出”（FILO，First In Last Out）结构。它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值