数据结构 (七) 线性表_队列

最新推荐文章于 2024-06-11 23:41:51 发布
最新推荐文章于 2024-06-11 23:41:51 发布
阅读量1.2k 收藏
点赞数
分类专栏： 数据结构_C语言实现 文章标签： 数据结构 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fioman_GYM/article/details/124381348
版权

文章目录

一. 队列的基本概念

  1. 队列是一种特殊的受限制的线性表
  2. 队列只允许在一端进行插入操作,在另外一端进行删除操作的线性表
  3. 队列是一种先进先出(First In First Out),FIFO.允许插入的一端为队尾,允许删除的一端为队头.
  4. 队列不允许在中间部位进行操作,删除的时候,总是从队头删除,插入的时候插入到队尾.

二. 队列的顺序存储实现

  1. 使用一块连续的内存空间来实现队列的存储
  2. 我们使用列表来实现一个队列

SeqQueue.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define QUEUE_MAX 1024
#define SEQ_QUEUE_TRUE 1
#define	SEQ_QUEUE_FALSE 0

typedef struct SeqQueue
{
	void *data[QUEUE_MAX];
	int size;
}SeqQueue;


// 初始化队列
SeqQueue *init_seq_queue();

// 入队
void push_seq_queue(SeqQueue* q, void * data);

// 出队
void  pop_seq_queue(SeqQueue *q);

// 获取队首元素
void *front_seq_queue(SeqQueue *q);

// 获取队尾元素
void *back_seq_queue(SeqQueue *q);

// 判断队列是否为空
int is_empty(SeqQueue *sq);

// 获取队列的大小
int get_size_seq_queue(SeqQueue *q);

// 清空队列
void clear_seq_queue(SeqQueue *q);

// 销毁队列
void destroy_seq_queue(SeqQueue *q);

SeqQueue.c

#include "SeqQueue.h"
// 初始化队列
SeqQueue *init_seq_queue()
{
	SeqQueue *q = (SeqQueue *)malloc(sizeof(SeqQueue));
	if (q != NULL)
	{
		for (int i = 0; i < QUEUE_MAX; i++)
		{
			q->data[i] = NULL;
		}
		q->size = 0;
	}
	return q;
}

// 入队
void push_seq_queue(SeqQueue* q, void *data)
{
	// 放到队尾部
	if (data != NULL && q != NULL && q->size < QUEUE_MAX)
	{
		q->data[q->size] = data;
		q->size++;
	}
}

// 出队
void  pop_seq_queue(SeqQueue *q)
{
	if (q != NULL && q->size > 0)
	{
		for (int i = 0; i < q->size - 1; i++)
		{
			// 后面的元素全部前移
			q->data[i] = q->data[i + 1];
		}
		// 最后一个节点置空
		q->data[q->size - 1] = NULL;
		q->size--;
	}
}

// 获取队首元素
void *front_seq_queue(SeqQueue *q)
{
	if (q != NULL && q->size > 0)
	{
		return q->data[0];
	}
	return NULL;
}

// 获取队尾元素
void *back_seq_queue(SeqQueue *q)
{
	if (q != NULL && q->size > 0)
	{
		return q->data[q->size - 1];
	}
	return NULL;
}

// 判断队列是否为空
int is_empty(SeqQueue *q)
{
	if (q != NULL)
	{
		return q->size == 0 ? SEQ_QUEUE_TRUE : SEQ_QUEUE_FALSE;
	}
	return SEQ_QUEUE_FALSE;
}

// 获取队列的大小
int get_size_seq_queue(SeqQueue *q)
{
	if (q != NULL)
	{
		return q->size;
	}
	return -1;
}

// 清空队列
void clear_seq_queue(SeqQueue *q)
{
	if (q != NULL)
	{
		for(int i = 0;i <q->size;i++)
		{
			q->data[i] = NULL;
		}
		q->size = 0;
	}
}

// 销毁队列
void destroy_seq_queue(SeqQueue *q)
{
	if (q != NULL)
	{
		free(q);
	}
}

测试代码

#include "SeqQueue.h"

int main()
{
	// 创建一个队列
	SeqQueue *q = init_seq_queue();
	// 往队列中添加5个数
	// 入队 1,2,3,4,5
	int arr[5] = { 1,2,3,4,5 };
	for (int i = 0; i < 5; i++)
	{
		//push_seq_queue(q,(void *)&i);// 想一下这行代码为啥是错误的
		push_seq_queue(q, (void *)&(arr[i]));
	}
	// 查看栈大小
	printf("5个数据入队之后的大小: %d\n", q->size);
	printf("队头: %d, 队尾: %d\n", *(int *)front_seq_queue(q), *(int *)back_seq_queue(q));
	// 出队,然后并按照出队顺序打印
	/*for (int i = 0; i < q->size; i++)
	{
		printf("第 %d 个出队的数据为: %d\n", i + 1, *(int *)front_seq_queue(q));
		pop_seq_queue(q);
	}*/
	// 上面这个打印会有问题,想想是为了什么?
	// 因为在出栈的时候q->size的大小是变动的,所以你本意q->size是5打印五次,但是打着打着q->size变小了

	// 可以使用while循环出栈打印
	int index = 1;
	while (q->size > 0)
	{
		printf("第 %d 个出队的数据为: %d\n", index, *(int *)front_seq_queue(q));
		pop_seq_queue(q);
		index++;
	}

	// 全部出队之后,看看栈是否为空,如果为空,再添加两个元素
	if (is_empty(q))
	{
		push_seq_queue(q, (void *)(&arr[0]));
		push_seq_queue(q, (void *)(&arr[1]));
		printf("入队两个之后队列大小: %d,队头: %d,队尾: %d\n", q->size, *(int *)front_seq_queue(q),*(int*)back_seq_queue(q));
		// 清空队列,然后查看大小
		clear_seq_queue(q);
		printf("清空之后大小为: %d\n", q->size);
	}
	else
	{
		printf("出错了,全部都出队了,队列不为空!");
	}

	// 销毁队列
	destroy_seq_queue(q);

	system("pause");
	return 0;
}

结果:

三. 队列的链式存储

  1. 使用链表来实现队列
  2. 单向链表实现队列
  3. 链表的最后一个节点是队尾
  4. 链表的第一个节点是队头
  5. 插入的时候,就正常插入,插入到链表的尾部,也就是队尾
  6. 取出的时候,在头部取出,这样就保证了先进先出.
  7. 注意头节点的设计,一开始的头节点是指向NULL

头文件 LinkQueue.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LINK_QUEUE_TRUE 1
#define LINK_QUEUE_FALSE 0

typedef struct LinkNode
{
	struct LinkNode *next;
	void *data;
} LinkNode;

typedef struct LinkQueue
{
	LinkNode *head;
	int size;
}LinkQueue;

// 初始化
LinkQueue *init_link_queue();

// 入队
void push_link_queue(LinkQueue *q, void *node);

// 出队
void pop_link_queue(LinkQueue *q);

// 获取队头节点
void *front_link_queue(LinkQueue *q);

// 获取队尾节点
void *back_link_queue(LinkQueue *q);

// 获取队列大小
int get_size_link_queue(LinkQueue *q);

// 判断队列是否为空
int is_empty(LinkQueue *q);

// 清空队列
void clear_link_queue(LinkQueue *q);

// 销毁队列
void destroy_link_queue(LinkQueue *q);

实现部分: LinkQueue.c

#include "LinkQueue.h"
// 初始化
LinkQueue *init_link_queue()
{
	LinkQueue *q = (LinkQueue *)malloc(sizeof(LinkQueue));
	LinkNode *node = (LinkNode *)malloc(sizeof(LinkNode));
	if (q != NULL && node != NULL)
	{
		node->data = NULL;
		node->next = NULL;
		q->head = node;
		q->size = 0;
	}
	return q;
}

// 入队,插入到尾部
void push_link_queue(LinkQueue *q, void *data)
{
	// 入队
	if (q != NULL && data != NULL)
	{
		// 创建新的节点
		LinkNode *newNode = (LinkNode *)malloc(sizeof(LinkNode));
		if (newNode != NULL)
		{
			newNode->data = data;
			newNode->next = NULL;
		}
		// 遍历节点,找到最后一个节点
		LinkNode *pCurrent = q->head; // 头节点
		while (pCurrent->next != NULL)
		{
			pCurrent = pCurrent->next;
		}
		pCurrent->next = newNode;
		q->size++;
	}

}

// 出队,删除第一个节点
void pop_link_queue(LinkQueue *q)
{
	if (q != NULL && q->size > 0)
	{
		// 要删除的节点
		LinkNode *nodeDel = q->head->next;
		q->head->next = nodeDel->next;
		free(nodeDel);
		q->size--;
	}
	
}

// 获取队头数据,也就是获取第一个节点
void *front_link_queue(LinkQueue *q)
{
	if (q != NULL && q->size > 0)
	{
		LinkNode *nodeTemp = q->head->next;
		return nodeTemp->data;
	}
	return NULL;
}

// 获取队尾数据
void *back_link_queue(LinkQueue *q)
{
	if (q != NULL && q->size > 0)
	{
		LinkNode *nodeLast = q->head->next;
		while (nodeLast->next != NULL)
		{
			nodeLast = nodeLast->next;
		}
		return nodeLast->data;
	}
	return NULL;
}

// 获取队列大小
int get_size_link_queue(LinkQueue *q)
{
	if (q != NULL)
	{
		return q->size;
	}
	return -1;
}

// 判断队列是否为空
int is_empty(LinkQueue *q)
{
	if (q != NULL)
	{
		return q->size == 0 ? LINK_QUEUE_TRUE : LINK_QUEUE_FALSE;
	}
	return LINK_QUEUE_TRUE;
}

// 清空队列
void clear_link_queue(LinkQueue *q)
{
	if (q != NULL)
	{
		q->size = 0;
		q->head->next = NULL;
	}
}

// 销毁队列
void destroy_link_queue(LinkQueue *q)
{
	if (q != NULL)
	{
		LinkNode *pCurrent = q->head;
		while (pCurrent->next != NULL)
		{
			free(pCurrent->next);
			pCurrent = pCurrent->next;
		}
		free(q);
	}
}

测试代码

#include"LinkQueue.h"
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	// 队列初始化和入队
	LinkQueue *q = init_link_queue();
	int arrLen = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < arrLen; i++)
	{
		push_link_queue(q, (void *)&(arr[i]));
	}
	printf("入队后队列大小: %d,队头: %d,队尾: %d\n", get_size_link_queue(q),*(int*)front_link_queue(q),*(int*)back_link_queue(q));

	int temp;
	int index = 1;
	// 然后是出队
	while (q->size > 0)
	{
		temp = *(int *)front_link_queue(q);
		printf("第 %d 次出队的数据: %d\n", index, temp);
		pop_link_queue(q);
	}
	// 如果队列是空,再存放两个数据1,2
	if (is_empty(q))
	{
		push_link_queue(q, (void *)&arr[0]);
		push_link_queue(q, (void *)&arr[1]);
		printf("存入两个数之后,队列大小: %d,队头: %d,队尾: %d\n", get_size_link_queue(q), *(int *)front_link_queue(q), *(int *)back_link_queue(q));

	}
	else
	{
		printf("出错,全部出队之后,队列不为空!");
	}

	// 清空队列
	clear_link_queue(q);
	printf("清空之后队列大小: %d\n", get_size_link_queue(q));

	destroy_link_queue(q);

	system("pause");
	return 0;
}

结果:

Fioman_Hammer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构循环队列（创建、入队、出队、取对头元素、遍历）
Algorithm_Soul
06-12 1万+
/* *循环队列的创建 *循环队列的初始化 *创建一个一维数组 *操作 出队 入队 判对列空 对列满 *创建数据域结构体 *创建循环队列的结构体 *求循环队列的长度 */ #include<stdio.h> #include<stdlib.h> #include<time.h> #include<string.h> #define OK 1 #def...
数据结构之线性表（数组实现）
huheqing的博客
05-18 427
#ifndef LIST_H #define LIST_Hclass List{ public: List(){} List(int size); ~List(); void ClearList(); bool ListEmpty(); int ListLength(); bool GetElem(int i, int &e); int
操作系统3 ————PCB和进程控制
热门推荐
冰炭不投day的博客
02-02 1万+
操作系统3 ————进程控制块（PCB）详解 一.目录 操作系统3 ————进程控制块（PCB）详解 一.目录 二. 进程控制块 1.概述 2.进程控制块中的信息 3.进程控制块的作用 4.进程控制块的组织方式 三.Linux的进程控制块 1.概述 2.task_struct数据结构简述 四.Unix的进程控制块 1.概述 2.进程表项（Proc表） 3.U区 4.系统区表 ...
线性表--队列
看，好自为之的博客！！！
01-22 2412
队列的简介与应用
队列详解及java实现
weixin_30501857的博客
01-06 136
导读 　　栈和队列是有操作限制的线性表。 目录 1、队列的概念、特点、存储结构。 2、栈队列的java实现。 概念 　　队列是一种在一端进行插入，而在另一端进行删除的线性表。1、队列的插入端称为队尾；队列的删除端称为队头。（好比火车进隧道）2、队列的插入操作称为入队（push），删除操作称为出队（pop）。 特点 　　队列就像一列进入隧道的火车，隧道就是队列，火车车厢就是元素，进入...
数据结构（线性表、栈与队列、树、图）
fly_Xiaoma的博客
06-10 2952
一、线性表 线性表是最常用且最简单的一种数据结构，它是n个数据元素的有限序列。 实现线性表的方式一般有两种： 使用数组存储线性表的元素，即用一组连续的存储单元依次存储线性表的数据结构 使用链表存储线性表的元素，即用一组任意的存储单元存储线性表的数据元素（存储单元可以是连续的，也可以是不连续的） 数组实现 数组是一种大小固定的数据结构，对线性表的所有操作都可以通过数组来实现。虽然数组一旦创...
数据结构-线性表（一）
清风笛竹
06-05 156
线性表定义：零个或多个数据元素的有限序列。序列:代表线性表的元素是有序列的。有限元素：线性表的元素个数是有限的一：线性表数据定义线性表定义是一个C++的结构体，在结构体里面是一个固定长度的数组，和记录线性表的元素的个数所以，线性表结构定义如下：typedef struct sqList{ int data[100]; int length; };二：线性表的初始化为了方便理解，这里...
数据结构实验报告 线性表 串 队列 栈.doc
04-01
大学数据结构课实验报告
数据结构中线性表，队列和栈
01-07
包含了数据结构中的线性表，队列和栈的具体代码，如有错误可以联系我，我可以进行修改。
数据结构：线性表、链表、队列、栈、串
11-24
包含数据结构中线性表、链表、队列、栈、串等几种结构的常见操作，以及顺序和链式存储过程
数据结构_线性表总结
04-23
线性表 栈 队列 串
软件基础_2018_12+第五章数据结构+栈_队列1
08-03
第四章 数据结构4.1 基本概念4.2 线性表4.3 栈和队列4.3.1 栈4.3.2 顺序栈4.3.3 链接栈4.3.4 队列4.3.5 顺序队列4.3.6
栈和队列
dai_的专栏
02-17 3424
2种特殊的线性表，栈和队列 1. 栈（LIFO，后进先出）: a) 操作示意图：push()操作与pop()操作 b)栈的顺序存储结构：进栈/出栈操作均在数组尾部，时间复杂度=O(1); i.缺陷：数组长度固定，长度不够时需扩容，消耗资源。 c)两栈共享空间：2个相同类型的栈，且空间需求呈相反关系。 d)栈的链式存储结构：保存栈顶指针，出栈与入栈的时间复杂度=O
数据结构之循环队列（SeqQueue）源码
数据结构学习心得
03-16 2890
SeqQueue.h文件#pragma once #include&lt;assert.h&gt; #include&lt;iostream&gt; #define defaultSize 20 template&lt;class T&gt; class SeqQueue { public: SeqQueue(int sz = defaultSize); //默认构造函数，构建一...
数据结构中 线性表，栈，队列，算法之间的联系与区别
qq_35810838的博客
11-25 3453
一。链表为什么需要         在程序中，经常需要将一种（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录他们，传进传出函数等。一组元素可能发生变化（像增加或删除元素。）        对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种意义的信息，或者表示数据之间的某种关系。        这样的...
线性表、链表、栈、队列的关系
奋斗的程序猿的博客
05-16 1万+
程序员在编程实战操作面前有两个拦路虎，第一个是用递归的思想去解决问题，第二个是数据结构与算法的应用。对于递归，由于其神奇的薄面纱总是然我们觉得难以理解，而大多数递归解法还是需要承担一定的计算负担的，因此我觉得能理解其思想与用法固然好，但是实在无法理解也只能慢慢适应。而对于第二个难题，数据结构与算法基本上每一个程序员都需要了解，因为，算法是解答一个问题的基本逻辑，如果你可以证明这个逻辑是正确的，那接下来的问题就是应该采用什么样的数据结构来保证你的程序能有最高的执行效率，即比较好的时间复杂性，同样内存空间消耗也
SeqQueue--顺序循环队列
大数据实验室
03-28 2986
看完复仇看了看队列。花了半小时来编写、调试。写完博客再去温习下枪火 /* ** File name: SeqQueue.h ** Author: ZhouFeng ** Date: 2012/03/27 */ #ifndef SEQ_QUEUE_H #define SEQ_QUEUE_H #define BOOL int #define ERROR 0 #define SUCCESS 1
数据结构（DS）C语言版：学习笔记（二）：数据类型与抽象数据类型
最新发布
她与剑意皆失的博客
06-11 772
数据类型就是一组性质相同的值的集合以及定义于这个值集合上的一组操作的总称。数据类型=值的集合+值集合上的一组操作C语言中基本数据类型：整型：int 长整型：long int 短整型：short int 浮点型（单精度）：float 浮点型（双精度）：double 字符型：char 布尔型：bool不同类型的变量，其所能取的值的范围不同，所能进行的操作不同。例如：bool类型的值为：true、false。可进行的操作：与、或、非...作用：约束变量或常量的取值范围；约束
Python基础教程（十一）：数据结构汇总梳理
菜鸟小码的博客
06-11 1212
本文将深入探讨Python中的主要数据结构类型，包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set），并通过具体案例来展示它们的应用场景。
数据结构c语言线性表
10-26
C语言中的线性表是一种常见的数据结构，它是由一组相同数据类型的元素组成的有限序列。线性表中的元素按照线性的顺序排列，每个元素都有一个前驱和一个后继，除了第一个元素没有前驱，最后一个元素没有后继。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值