【数据结构】day 6栈和队列

最新推荐文章于 2024-06-24 21:38:41 发布
最新推荐文章于 2024-06-24 21:38:41 发布
阅读量22 收藏
点赞数
文章标签： 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40169105/article/details/130331073
版权

顺序栈，链栈

//1.h
#ifndef __1_H__
#define __1_H__
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXSIZE 4
typedef int datatype;

typedef struct 
{
	datatype data[MAXSIZE];
	int top;
}*ss,SS;

ss create();
int insert(ss s,datatype e);
void output(ss s);

int pop(ss s);

typedef struct node
{
	union
	{
		int len;
		datatype data;
	};
	struct node *next;
}*ls,ll;


ls create1(int flag);
int insert1(ls s,datatype e);
void output1(ls s);
int pop1(ls s);
#endif


//1.c
#include"1.h"
int main(int argc, const char *argv[])
{

	//ss s = create();
	char select;
	datatype e;
#if 0
	while(1)
	{
		printf("input insert data\n");
		scanf("%d",&e);
		printf("go on ? y/n\n");
		scanf(" %c",&select);
		insert(s,e);
		if(select == 'N' ||select == 'n')
			break;
	}
	output(s);
	pop(s);
	output(s);
#else
	ls s = create1(1);
	while(1)
	{
		printf("input insert1 data\n");
		scanf("%d",&e);
		printf("go on ? y/n\n");
		scanf(" %c",&select);
		insert1(s,e);
		if(select == 'N' ||select == 'n')
			break;
	}
	output1(s);
	pop1(s);
	output1(s);

	
#endif
	return 0;
}


//fun1.c
#include"1.h"

//创建
ss create()
{
	ss s = (ss)malloc(sizeof(SS));
	if(!s)
	{
		printf("create failed\n");
		return NULL;
	}
	s->top = -1;
	return s;
}

int insert(ss s,datatype e)
{
	//判断成功和满
	if(!s || s->top == MAXSIZE-1)
	{
		printf("insert failed \n");
		return -1;		
	}
	s->data[++s->top] = e;
	return 0;
}


void output(ss s)
{
	if(!s || s->top == -1)
	{
		printf("output failed\n");
		return;
	}
	for(int i = 0; i <= s->top; i++)
		printf("%d\t",s->data[i]);
	puts("");
}


int pop(ss s)
{
	if(!s || s->top == -1)
	{
		printf("pop failed\n");
		return -1;
	}
	printf("pop data = %d\n",s->data[s->top--]);
}


//

ls create1(int flag)
{
	ls s = (ls)malloc(sizeof(ll));
	if(!s) 
	{
		printf("create1 failed\n");
		return NULL;
	}
	if(flag == 1)
		s->len = 0;
	else if(flag == 0)
		s->data = 0;
	s->next = NULL;
	return s;
}

int insert1(ls s,datatype e)
{
	if(!s)
	{
		printf("insert1 failed\n");
		return -1;
	}
	ls p = create1(0);
	if(!p) return -1;
	p->data = e;
	p->next = s->next;
	s->next = p;
	s->len ++;
	return 0;
}


void output1(ls s)
{
	if(!s || !s->next)
	{
		printf("output1 failed\n");
		return;
	}
	ls p = s;
	while(p->next)
	{
		p = p->next;
		printf("%d\t",p->data);
	}
}

int pop1(ls s)
{
	if(!s || !s->next)
	{
		printf("pop1 failed\n");
		return -1;
	}
	ls p = s->next;
	s->next = p->next;
	printf("pop data = %d\n",p->data);
	free(p);
	p = NULL;
	s->len --;
	return 0;
}

2.顺序队列 循环队列

#ifndef __2_H__
#define __2_H__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int datatype;
#define MAXSIZE 6

typedef struct
{
	datatype data[MAXSIZE];
	int front;
	int rear;
}*qq,Q;

qq create();
int enqueue(qq q,datatype e);
void output(qq q);
int dequeue(qq q);


typedef struct
{
	datatype data[MAXSIZE];
	int front;
	int rear;
}*qq1,Q1;
qq1 create1();
int enqueue1(qq1 q,datatype e);
void output1(qq1 q);
int dequeue1(qq1 q);
int len1(qq1 q);


#endif


//2.c
#include"2.h"
int main()
{
	qq1 q = create1();
	char select[10];
	datatype e;
/*	while(1)
	{
		printf("input enqueue data\n");
		scanf("%d",&e);
		enqueue(q,e);
		printf("go on? yes/no: ");
		scanf("%s",select);
		if(!strcmp(select,"no"))
			break;
	}
	output(q);
	while(1)
	{
		dequeue(q);
		printf("go on? yes/no: ");
		scanf("%s",select);
		if(!strcmp(select,"no"))
			break;
	}
	output(q);
	enqueue(q,1000);
	*/

	while(1)
	{
		printf("input enqueue1 data\n");
		scanf("%d",&e);
		enqueue1(q,e);
		printf("go on? yes/no: ");
		scanf("%s",select);
		if(!strcmp(select,"no"))
			break;
	}
	output1(q);
	while(1)
	{
		dequeue1(q);
		printf("go on? yes/no: ");
		scanf("%s",select);
		if(!strcmp(select,"no"))
			break;
	}
	output1(q);
	enqueue1(q,1000);
	output1(q);
	int len = len1(q);
	printf("len = %d\n",len);


	



	return 0;
}


//fun2.c
#include"2.h"
qq create()
{
	qq q = (qq)malloc(sizeof(Q));
	if(!q) 
	{
		printf("create failed\n");
		return NULL;
	}
	q->front = q->rear = 0;
	return q;
}

int enqueue(qq q,datatype e)
{
	if(!q || q->rear == MAXSIZE)
	{
		printf("enqueue failed\n");
		return -1;
	}
	q->data[q->rear++] = e;
	return 0;
}

void output(qq q)
{
	if(!q || q->rear == q->front)
	{
		printf("output failed\n");
		return;
	}
	for(int i = q->front; i < q->rear; i++)
		printf("%d\t",q->data[i]);
	puts("");
}


int dequeue(qq q)
{
	if(!q || q->rear == q->front)
	{
		printf("dequeue failed\n");
		return -1;
	}
	printf("dequeue data = %d\n",q->data[q->front++]);
	return 0;
}
///
qq1 create1()
{
	qq1 q = (qq1)malloc(sizeof(Q1));
	if(!q) 
	{
		printf("create failed\n");
		return NULL;
	}
	q->front = q->rear = 0;
	return q;
}


int enqueue1(qq1 q,datatype e)
{
	if(!q || q->front == (q->rear+1)%MAXSIZE)
	{
		printf("enqueue failed\n");
		return -1;
	}
	q->data[q->rear] = e;
	q->rear = (q->rear+1)%MAXSIZE;
	return 0;
}



void output1(qq1 q)
{
	if(!q || q->front == q->rear)
	{
		printf("output1 failed\n");
		return;
	}
	for(int i = q->front; i != q->rear; i = (i+1)%MAXSIZE)
		printf("%d\t",q->data[i]);
	puts("");
}

int dequeue1(qq1 q)
{
	if(!q || q->rear == q->front)
	{
		printf("dequeue1 failed\n");
		return -1;
	}
	printf("dequeue1 data = %d\n",q->data[q->front]);
	q->front = (q->front+1)%MAXSIZE;
	return 0;
}

int len1(qq1 q)
{
	return (MAXSIZE-q->front+q->rear);
}

循环队列

因循环队列存在队满的情况，所以引出链式队列，解决循环队列满的问题。
1> 链式存储：逻辑相邻，物理不一定相邻
2> 链式队列的插入和删除
2.1 尾插和头删：单链表的表尾等价于队列的队尾，链表的头等价于队列的队头
2.2 头插和尾删：单链表的头等价于队列的队尾，链表的尾等价于队列的队头

//1.h
#ifndef __3_H__
#define __3_H__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int datatype;

typedef struct links
{
	union
	{
		int len;
		datatype data;
	};
	struct links *next;
}*ls;

typedef struct linkq
{
	ls front;
	ls rear;
}*lq;


lq create_h();
int insert(lq q,datatype e);
void output(lq q);
int dequeue(lq q);
lq free_q(lq q);

#endif


//fun3.c
#include "3.h"
lq create_h()
{
	lq q = (lq)malloc(sizeof(struct linkq));
	if(!q)
	{
		printf("create_h q failed\n");
		return NULL;
	}
	ls l = (ls)malloc(sizeof(struct links));
	if(!l)
	{
		printf("create_h l failed\n");
		return NULL;
	}
	l->len = 0;
	l->next = NULL;
	q->front = l;
	q->rear = l;
	return q;
}
int insert(lq q,datatype e)
{
	if(!q)
	{
		printf("insert failed \n");
		return -1;
	}
	ls s = (ls)malloc(sizeof(struct links));
	if(!s)
	{
		printf("insert ls s failed\n");
		return -1;
	}
	s->data = e;
	s->next = NULL;
	q->rear->next = s;
	q->rear = s;
	q->front->len ++;
	return 0;
}


void output(lq q)
{
	if(!q || q->front == q->rear)
	{
		printf("output failed\n");
		return;
	}
	ls p = q->front;
	while(p->next)
	{
		p = p->next;
		printf("%d\t",p->data);
	
	}
	puts("");
}

int dequeue(lq q)
{
	if(!q || q->front == q->rear)
	{
		printf("dequeue failed\n");
		return -1;
	}
	ls s = q->front->next;
	if(q->rear == s) q->rear = q->front;
	int data = s->data;
	printf("dequeue data = %d\n",data);
	q->front->next = s->next;
	q->front->len --;
	free(s);
	s = NULL;
	return 0;
}

lq free_q(lq q)
{
	if(!q || q->rear == q->front)
	{
		printf("free_q failed \n");
		return NULL;
	}
	int len = q->front->len;
	for(int i = 0; i < len; i ++)
	{
		dequeue(q);
	}
	free(q->front);
	q->front = q->rear = NULL;
	free(q);
	q= NULL;
	printf("free_q success\n");
	return q;
		
}


//3.c
#include"3.h"

int main()
{
	lq q = create_h();
	datatype e;
	char select;
	while(1)
	{
		printf("input insert data: ");
		scanf("%d",&e);
		insert(q,e);

		printf("go on? y/n : ");
		scanf(" %c",&select);
		if(select == 'n')
			break;
	}
	output(q);
	dequeue(q);
	output(q);
	q = free_q(q);

	return 0;
}
Betty-yi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[算法和数据结构入门][Day6]笨办法实现使用队列求移动平均值
12-21
Day6队列中的移动平均值 给定一个整数数据流和一个窗口大小，根据滑动窗口的大小，计算其所有整数的移动平均值 队列，Python中的queue模块是对栈和队列的封装，可以直接调用类的属性和方法,队列类似于一条管道，...
【数据结构】Day31
08-03
在数据结构的学习中，表（List）是一种基础且重要的数据组织形式，它...理解这些基本概念和操作是深入学习更高级数据结构的基础，如栈、队列、树和图等。在实际编程中，正确处理指针和内存管理是避免程序崩溃的关键。
《三天学会C数据结构和算法》视频
07-23
资源名称：《三天学会C 数据结构和算法》视频资源目录：【】day01AM_数据结构介绍_节点【】day01PM_链表【】day02AM_链表_栈_队列【】day02PM_二叉树【】day03AM_二叉树_算法基础_二分法查找【】day03PM_排序算法_...
8.数据结构和算法基础 (1).pptx
11-02
3. **栈与队列**：栈是“后进先出”（LIFO）的数据结构，常用于函数调用、表达式求值等场景。队列是“先进先出”（FIFO）的数据结构，适用于任务调度、数据缓冲等。出队序列取决于入队顺序，例如，元素1、2、3、4...
数据结构经典面试之链表——C#和C++篇
qq_35320456的博客
06-21 670
链表是一种常见的基础数据结构，它由一系列节点组成，每个节点包含数据域和指向下一个节点的指针。链表与数组不同，它不要求节点在内存中连续存储，这使得链表在插入和删除操作时具有较高的效率
实现一个快速排序算法，并分析算法的时间复杂度。
m0_45127365的博客
06-21 571
在最好情况下，每次划分时都能将数组均匀地划分为两个部分，此时时间复杂度为O(nlogn)。在最坏情况下（每次划分都只将数组中的一个元素放到正确位置），时间复杂度为O(n^2)。平均时间复杂度为O(nlogn)。
【C语言】回调函数 和 部分库函数的用法以及模拟实现
2303_80828380的博客
06-18 1069
开学！！！
冒泡排序算法的C语言实现
m0_46566693的博客
06-24 415
冒泡排序算法的C语言实现
数据结构---树
GeiGe123的博客
06-21 932
树定义 1、n个节点组成的具有层次结构的集合 2、每个节点有0个或多个子节点 3、每个非根节点只有一个父节点 4、除根节点，每个子节点可以分成多个不相交的子树 概念定义： 节点深度：节点到根节点的路径长度，称为这个节点的深度 节点高度： 父节点： 子节点： 兄弟节点：拥有共同父节点 度：节点有多少个子节点称为这个节点的度 祖先： 后代： 森林：多个互不相交的树组合构成一个森林 树的分类： 无序树：树的任意节点的子节点无顺序关系 有序树：树的任意节点的子节点有顺序关系 二叉树：任意节点最多只有2个节点的树 代
数据结构——优先级队列(堆)Priority Queue详解
Yuan_o_的博客
06-22 751
Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的，本文主要介绍PriorityQueue//运行结果：1// 22. PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出 ClassCastException 异常。
【408考点之数据结构】算法和算法评价（时间空间复杂度）
gygkhd的博客
06-18 599
例如，时间复杂度为O(n)表示算法的运行时间随着输入规模n线性增长。常见的时间复杂度还有O(1)、O(log n)、O(n^2)等。例如，空间复杂度为O(1)表示算法只需要常量的额外空间，而空间复杂度为O(n)表示算法需要线性增长的存储空间。在实际应用中，选择算法时需要根据具体问题和资源限制，综合考虑时间和空间复杂度。通过理解算法的基本概念和效率度量，我们可以更好地设计和选择适合具体问题的算法，提高程序的运行效率。函数的空间复杂度为O(1)，因为只使用了一个额外的临时变量。，与输入数组的大小无关。
C++之模板（四）
CSDN_HZW的博客
06-18 263
【代码】C++之模板（四）
C++ day3
2301_81402136的博客
06-17 286
【代码】C++ day3。
【C++】类的六个默认成员函数
炸掉地球的博客
06-21 665
C++类的六个默认构造函数。
什么悬挂指针，如何避免（C/C++）
qq_35374791的博客
06-24 349
RAII 是 C++ 中一种重要的资源管理技术，它将资源的获取与对象的构造绑定在一起，并在对象销毁时自动释放资源。悬挂指针是指向已经被释放或者不再存在的内存区域的指针。当程序尝试使用这样的指针访问或修改已释放的内存时，会导致未定义行为，通常是程序崩溃或数据损坏。或使用智能指针来实现。在现代 C++ 编程中，推荐尽可能使用智能指针来管理动态分配的资源。总之，预防悬挂指针的关键在于确保指针在使用前不会指向无效的内存，这可以通过立即设置为。会在离开作用域时自动释放它所管理的内存，从而避免了悬挂指针的问题。
C语言中的内存分配方式（静态分配、动态分配）定义以及区别
2402_85246552的博客
06-17 332
这种分配方式主要用于局部变量，特别是那些大小在编译时无法确定，或者需要在程序运行时改变大小的变量。：malloc函数用于在堆（heap）上分配指定字节数的内存，并返回一个指向该内存区域的指针。内存分配发生在程序运行时，所以内存大小和生命周期可以在运行时动态改变。内存分配在程序编译时就已经确定，所以内存大小和生命周期都是固定的。静态分配的变量在函数调用时，它们的内存空间会在函数调用栈帧中分配，并在函数返回时释放。动态分配的变量的内存空间在堆上，函数调用时传递的是指针，所以函数调用的开销相对较小。
auto/范围for/nullptr(C++)
lim6ere的博客
06-17 850
auto主要用于类型推导，代替长类型auto在c语言使用时修饰变量，表示这个变量是具有自动存储器的局部变量，但是在实际中几乎不会使用。C++11赋予了他新的含义，auto作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。auto b = a;return 0;typeid().name()可用于打印类型。对于指针*可写可不写。但是对于引用，&必须加上。
【C++】二叉搜索树|Key模型|key_value模型|基本操作
最新发布
m0_67367079的博客
06-24 522
BST。每个节点包含一个键（key）和两个指针，分别指向其左子树和右子树。左子树上的所有节点的键值都小于其父节点的键值。右子树上的所有节点的键值都大于其父节点的键值。每个子树也是一棵二叉搜索树。每个节点包含三个部分：一个键（Key），一个值（Value），以及两个指向其子节点的指针（分别指向左子树和右子树）。
数据结构C语言day
08-27
综上所述，这些引用提供了关于数据结构的C语言代码示例，包括定义结构体、打印链表和打印节点的函数。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *2...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值