《算法导论》学习（十三）----栈和队列（C语言）

已于 2022-09-15 22:39:30 修改
阅读量434 收藏
点赞数 3
文章标签： c语言 算法 学习 数据结构
于 2022-09-15 22:23:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52042488/article/details/126873881
版权

文章目录

前言

本文主要讲解了栈和队列的内容，给出了它们的顺序结构实现方式和链式结构实现方式
并给出了它的操作函数的C语言实现

一、栈和队列概述

栈和队列的数据处理方式还是很简单的:

1.栈始终保持元素后进先出(LIFO)的原则
2.队列始终保持元素先进先出(FIFO)的原则

同时还有一个注意点：
栈和队列的弹栈或者出队都会删除相应的元素；而访问操作，不会删除相应元素

二、栈

1.顺序结构栈

#include<stdio.h>
#define maxn 100 
typedef struct zhan
{
	int top1;
	int top2;
	int number1;
	int number2;
	int a[maxn];	
}; 
void isempty(zhan * list,int judge)
{
	if(judge)
	{
		if(list->number1<=0)
		{
			printf("栈1为空\n");
		}
		else
		{
			printf("栈1不空\n");
		}
	}
	else
	{
		if(list->number2<=0)
		{
			printf("栈2为空\n");
		}
		else
		{
			printf("栈2不空\n");
		}
	}
 }
void chushihua(zhan *list)
{
	list->top1=-1;
	list->top2=maxn;
	list->number1=0;
	list->number2=0;
}
void push(zhan *list,int judge,int n)
{
	if(list->top1+1==list->top2) printf("满栈,失败\n");
	if(judge)
	{
		list->number1=list->number1+1;
		list->top1=list->top1+1;
		list->a[list->top1]=n;
	}
	else
	{
		list->number2=list->number2+1;
		list->top2=list->top2-1;
		list->a[list->top2]=n;
	}
}
int gettop(zhan *list,int judge)
{
	if(judge)
	{
		if(list->number1==0)
		{
			printf("栈1为空\n");
		}
		else
		{
			return list->a[list->top1];
		}
	}
	else
	{
		if(list->number2==0)
		{
			printf("栈2为空\n");
		}
		else
		{
			return list->a[list->top2];
		}
	}
}
void pritop(zhan *list,int judge)
{
	if(judge)
	{
		if(list->number1==0)
		{
			printf("栈1为空\n");
		}
		else
		{
			printf("%d\n",list->a[list->top1]);
		}
	}
	else
	{
		if(list->number2==0)
		{
			printf("栈2为空\n");
		}
		else
		{
			printf("%d\n",list->a[list->top2]);
		}
	}
}
void popup(zhan *list,int judge)
{
	if(judge)
	{
		if(list->number1==0)
		{
			printf("栈1为空\n");
		}
		else
		{
			list->a[list->top1]=0;
			list->top1=list->top1-1;
			list->number1=list->number1+1;
		}
	}
	else
	{
		if(list->number2==0)
		{
			printf("栈2为空\n");
		}
		else
		{
			list->a[list->top2]=0;
			list->top2=list->top2+1;
			list->number2=list->number2+1;
		}
	}
 }
 int main()
 {
 	zhan x;
 	chushihua(&x);
 	isempty(&x,0);
	isempty(&x,1);
	for(int i=1;i<10;i++)
	{
		push(&x,0,2*i);	
	}
	for(int i=1;i<10;i++)
	{
		push(&x,1,3*i);
	 }
	isempty(&x,0);
	isempty(&x,1);
	for(int i=1;i<10;i++)
	{
		pritop(&x,0);
		pritop(&x,1);
		printf("%d %d\n",gettop(&x,0)+1,gettop(&x,1)+1);
		popup(&x,0);
		popup(&x,1);
	}
	isempty(&x,0);
	isempty(&x,1);
  }

2.链表结构栈

#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
	int data;
	struct  node* next;	
};
typedef struct zhan
{
	node body;
	int number;
};
int isempty(zhan *list)
{
	if(list->number==0)
	return 1;
	else
	return 0; 
}
zhan *chushihua()
{
	zhan *a;
	a=(zhan *)malloc(sizeof(zhan));
	a->number=0;
	a->body.next=NULL;
	return a;
}
void push(zhan *list,int n)
{
	if(list->number==0)
	{	
		node *s;
	 	s=(node*)malloc(sizeof(node));
		list->body.next=s;
		s->data=n;
		s->next=NULL;
		list->number=list->number+1;
	}
	else if(list->number<0)
	{
		printf("栈初始化错误\n");
	}
	else
	{
		node *s;
		s=(node*)malloc(sizeof(node));
		s->next=list->body.next;
		list->body.next=s;
		s->data=n;
		list->number=list->number+1;	
	} 
}
int gettop(zhan *list)
{
	if(list->number==0)
	{
		printf("栈为空,获取失败\n");
		return 223333;
	}
	else
	{
		int temp;
		temp=list->body.next->data;
		return temp;
	}	
} 
void pritop(zhan *list)
{
	if(list->number==0)
	{
		printf("栈为空,获取失败\n");
	}
	else
	{
		int temp;
		temp=list->body.next->data;
		printf("%d\n",temp);
	}
}
void popup(zhan *list)
{
	if(list->number==0)
	{
		printf("栈为空，弹出失败\n");
	}
	else if(list->number==1)
	{
		free(list->body.next);
		list->number=list->number-1;
	}
	else
	{
		node *per;
	 	list->body.next=list->body.next->next;
	 	per=list->body.next;
	 	free(per);
	 	list->number=list->number-1;
	}
}
void destroy(zhan *list)
{
	free(list);
	printf("销毁成功\n");
}
int main()
{
	zhan *a;
	a=chushihua();
	int b[4]={5154351,4848,8444,55};
	for(int  i=0;i<4;i++)
	{
		push(a,b[i]);
	}
	if(!isempty(a))
	{
		printf("栈不空\n");
	}
	else
	{
		printf("栈为空\n");
	}
	for(int i=0;i<4;i++)
	{
		pritop(a);
		printf("%d\n",gettop(a)+1);
		popup(a);
	}
	popup(a);
	if(!isempty(a))
	{
		printf("栈不空\n");
	}
	else
	{
		printf("栈为空\n");
	}
	destroy(a);
	return 0; 
}

三、队列

由于队列的规则是先进先出，形象点讲就是元素从队尾加入，然后从队首出去。如果在内存上仅仅是加尾去头的话，对于数组这样的顺序存储结构十分的困难，因此我们需要编写循环队列，来应对顺序存储结构

1.顺序结构队列

#include<stdio.h>
#define maxn 10
typedef struct duilie
{
	int top;
	int tail;
	int a[maxn];
	int number;
	int judge;
};
void chushihua(duilie *list)
{
	list->top=0;
	list->tail=-1;
	list->number=0;
	list->judge=0;
}
void isempty(duilie *list)
{
	if((list->top%maxn)==(list->tail%maxn)||list->tail==-1)
	{
		printf("队列为空\n");
	}
	else
	{
		printf("队列不为空\n");
	}
}
void push(duilie *list,int n)
{
	if(list->judge==1&&(list->tail+1)%maxn==(list->top%maxn))
	{
		printf("队列为满，无法插入\n");
	}
	else
	{
		list->tail=list->tail+1;
		list->a[list->tail%maxn]=n;
		list->number=list->number+1;
		if((list->tail+1)%maxn==(list->top%maxn))
		{
			list->judge=1;
		} 
	}
}
void pritop(duilie *list)
{
	if((list->top%maxn)==(list->tail%maxn))
	{
		printf("队列空\n");
	}
	else
	{
		printf("%d\n",list->a[list->top%maxn]);
	} 
 }
 int gettop(duilie *list)
 {
 	if((list->top%maxn)==(list->tail%maxn))
	{
		printf("队列空\n");
		return 2233333;
	}
	else
	{
		return list->a[list->top%maxn];
	} 
 }
 void popup(duilie *list)
 {
 	if((list->top%maxn)==(list->tail%maxn))
	{
		printf("队列空\n");
	}
	else
	{
		list->top=list->top+1;
		list->number=list->number-1;
	} 
}
int main()
{
	duilie x;
	isempty(&x);
	chushihua(&x);
	printf("%d %d\n",x.tail,x.top);
	for(int i=0;i<11;i++)
	{
		push(&x,2*i);
	}
	for(int i=0;i<8;i++)
	{
		pritop(&x);
		popup(&x);
		printf("%d %d\n",x.tail,x.top);
	}
	for(int  i=0;i<10;i++)
	{
		push(&x,3*i);
		printf("%d %d\n",x.tail,x.top);
	}
	for(int i=0;i<10;i++)
	{
		pritop(&x);
		popup(&x);
		printf("%d %d\n",x.tail,x.top);
	}
	return 0;
}

2.链式结构队列

#include<stdio.h>
#include<stdlib.h> 
typedef struct body
{
	int value;
	struct body *next;
}; 
body *init()
{
	body *first=(body*)malloc(sizeof(body));
	first->next=NULL;
	first->value=0;
	printf("创建成功\n");
	return first; 
}
void isemp(body *first)
{
	if(first->next==NULL||first==NULL)
	{
		printf("循环队列为空\n");
	}
	else printf("循环队列不为空\n"); 
}
int length(body *first)
{
	if(first->next==NULL)
	{
		return 0;
	}
	else
	{
		return first->value;
	}
}
int gettop(body *first)
{
	if(first->next==NULL)
	{
		printf("循环队列为空表，取值无效\n");
		return 223333;
	}
	else
	{
		int temp; 
		body *per;
		per=first->next;
		return per->value;	
	} 
}
void printtop(body *first)
{
	if(first->next==NULL)
	{
		printf("循环队列为空表，取值无效\n");
	}
	else
	{
		int temp; 
		body *per;
		per=first->next;
		printf("%d\n",per->value);	
	} 
}
void push(body* first,int value1)
{
	body *per;
	per=first;
	for(int k=1;k<first->value;k++)
	{
		per=per->next;
	}
	body *temp;
	temp=(body*)malloc(sizeof(body));
	temp->value=value1;
	temp->next=first->next;
	first->next=temp; 
	per->next=temp;
	printf("入队成功\n");
	first->value=first->value+1;
}
void popuptop(body *first)
{
	body* per;
	per=first;
	if(per->next==NULL)
	{
		printf("出队失败\n");
	}
	else
	{
		per=first;
		for(int k=1;k<first->value;k++)
		{
			per=per->next;
		}
		body *s;
		s=first->next;
		per->next=first->next->next;
		first=per->next;
		free(s);
		first->value=first->value-1;
		printf("出队成功\n");
	}
}
void destroy(body *first)
{
	body* per;
	first->value=0;
	per=first->next;
	for(int i=1;i<=first->value;i++)
	{
		body* temp;
		temp=per;
		per=per->next;
		free(temp);
	}
	first->next=NULL; 
	printf("销毁完成\n"); 
}

总结

文章不妥错误之处请大家包涵和指正
文章大量使用了链表的相关内容，大家可以看文章：
《算法导论》学习（十二）----链表（C语言）

SigmaBull
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
算法导论——队列
qq_36393555的博客
02-15 252
头文件queue.h如下： #pragma once #ifndef _QUEUE_H #define _QUEUE_H #define SIZE 100 class my_queue { private: using pos = char; typedef size_t poa; public: void initqueue(my_queue &q); bool queueempty(
算法导论例程——队列
CFhM_R's Blog
02-09 592
队列是一种delete的方式同栈不同的数据结构，遵循先进先出原则，因此对于队列我们需要它的head和tail两个属性来描述入队和出队。队列的结构如下 #define LENGTH 1000 typedef struct { int num[LENGTH]; int head; int tail; }queue;这里把队列的长度宏定义了具体的数值，在实际应用时可以使用sizeof来获取，或以
算法导论——栈与队列
qq_37457671的博客
05-29 276
用两个栈来实现一个队列。     不包括栈与队列的具体实现，包括10-1课后练习。代码调用STL。     栈的特点是后进先出，队列的特点是先进先出。所以用两个栈实现队列只需要把在出队列时把第一个栈的元素全部压到第二个栈（第二个栈为空），这个时候第二个栈的顺序就是队列顺序也就是先进先出。以下是实现代码。#include #include using namespace std; void
算法导论第十章--队列的实现
小博客
07-25 841
queue.h #include using namespace std; #define Max 20 class queue { private: int length; int *head; int *tail; int Node[Max]; public: queue():length(0) { // head=new int; // tail=new int; }
算法导论-------------队列（queue）的简单实现
chen
11-24 1264
队列的基本操作包括入队enqueue和出队dequeue，队列有队头head和队尾tail指针。元素总是从队头出，从队尾入。采用数组实现队列时候，为了合理利用空间，可以采用循环实现队列空间的有效利用。
算法导论-优先级队列-C语言
qian2729的专栏
09-07 492
#define MIN_INT (-65535) int heapSize; void exchange(int array[],int a, int b); void maxHeapify(int array[], int i); int main() { printf("Hello world!\n"); return 0; } void maxHeapify(int a
算法导论中C语言代码,算法导论-学习笔记与进度
weixin_29660659的博客
05-24 365
算法导论 阅读进度第一部分 基础知识第一章 计算中算法的角色 Done1.1 算法输入与输出算法可以解决哪些问题数据结构技术一些比较难的问题1.2 作为一种技术的算法效率算法和其他技术第二章 算法入门 Done2.1 插入排序伪代码如下：INSERTION_SORT(A)for j = 2 to length[A]do key = A[j]i = j-1// 将其与已经排好序的数组进行...
cpp-算法导论第三版中算法的C实现
08-16
在这个名为“cpp-算法导论第三版中算法的C实现”的压缩包中，我们可以期待找到《算法导论》第三版中所提及的一些算法的C语言实现代码。这些实现对于学习和理解算法的工作原理非常有帮助，同时也可以作为实际编程项目...
《算法导论》的C语言实现.zip
06-13
在这个“《算法导论》的C语言实现.zip”压缩包中，很可能是作者或读者为了更好地理解和实践书中的算法，用C语言编写了这些算法的代码。C语言是一种强大的、低级的编程语言，适合实现算法的底层逻辑，因此它是学习和...
算法导论 经典的参考资料 必看
11-08
在C语言方面，《算法导论》用C语言实现了许多示例代码，让读者能够更直观地理解和应用所学的算法。C语言简洁高效，适合作为学习算法的编程语言，因为它能直接反映出算法的底层运作机制。 书中深入探讨了排序算法，...
CLRS:算法导论学习集
04-30
《CLRS：算法导论学习集》是针对计算机科学领域经典教材《算法导论》（英文原版为"Introduction to Algorithms"，通常简称CLRS，取四位作者Cormen、Leiserson、Rivest和Stein首字母）的一个学习资源集合。...
IO多路复用-select的使用详解【C语言】
qq_42037383的博客
07-21 898
IO多路转接也称为IO多路复用，它是一种网络通信的手段（机制），通过这种方式可以同时监测多个文件描述符并且这个过程是阻塞的，一旦检测到有文件描述符就绪（ 可以读数据或者可以写数据）程序的阻塞就会被解除，之后就可以基于这些（一个或多个）就绪的文件描述符进行通信了。通过这种方式在单线程/进程的场景下也可以在服务器端实现并发。常见的IO多路转接方式有：select、poll、epoll。
C语言——字符串中sizeof和strlen的辨析
weixin_45720999的博客
07-19 393
在C语言中，sizeof 和 strlen 函数在处理字符串时有明显不同的作用和结果。使用不当很容易出现错误......
【C语言】 约瑟夫环，循环链表实现
最新发布
2301_77133426的博客
07-22 100
1、循环链表实现约瑟夫环，每次经过特定步数删除一个元素
c语言（7.22）
fhgfyrsg的博客
07-22 380
在7，23，79，81，103，127，131，147中查找数据*/核心思路：就是从数组的0索引开始，依次往后查找，如果找到了，就会返回数据对应的索引。如果没有找到，就会返回-1。//不是用mid和num进行比较。//2.定义变量表示要查找的数据。//2，定义一个要查的数据。/*需求：数组的二分查找。//mid应该放在循环里面。/* 需求：数组的基本查找。
C语言控制语句：分支、循环和转向
2302_81410974的博客
07-21 889
1. 分支语句：if语句、switch语句； 2. 循环语句：for语句、while语句、do-while语句； 3. 转向语句：break语句、continue语句、return语句、goto语句。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 7413
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
《算法导论》第三版-麻省理工学院教材
- 算法基础：介绍了算法的基本概念，包括数据结构（如数组、链表、栈和队列）和基本操作。 2. 分析篇 - 复杂度分析：讲解了时间复杂度和空间复杂度的概念，如何评估算法效率，以及渐进分析方法。 - 排序与搜索：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SigmaBull

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值