队列queue的实现

已于 2022-02-14 06:53:47 修改
阅读量297 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 队列
于 2022-02-14 06:47:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44341293/article/details/122917364
版权

顺序表实现

##list.c
#include <stdio.h>
#include <stdlib.h>
typedef int data_t;

typedef struct list{
	data_t *data; //保存数据的空间
	int size;   //容器能保存的元素个数
	int last; //保存最后一个有效元素的下标
}list_t;
/*返回创建好的 空顺序表 的地址*/

list_t *creat_list(int size)
{
	list_t *p;
	p = malloc(sizeof(list_t) + (sizeof(data_t) * size));//申请空间
	p->data = (data_t *)(p + 1);
	p->size = size;
	p->last = -1;  //初始化 结构内部相应内容

	return p;
}
/*
 * p： 顺序表的地址
 * index：插入的下标位置
 * data：插入的数据
 *
 * return：成功返回0 ；失败返回-1
 * */
int ins_index_list(list_t *p,int index,const data_t *data)
{
	//1.将插入位置的数据向下移动
	//  1.1 移动最后一个 到下一个位置   data[last + 1] = data[last];
	//  1.2 移动倒数第二个             
	//  1.3 。。。。
	//
	//2.写入数据到对应位置
	//3. last ++
	
	int i;
	if(p->size - 1 == p->last) // 如果容器满 直接退出
		return -1;
	if(index < 0 || index > p->last + 1)
		return -2;

	for(i = p->last;i >= index;i --){
		p->data[i + 1] = p->data[i];
	}

	p->data[index] = *data;
	p->last ++; // (*p).last

	return 0;
}

int del_index_list(list_t *p,int index)
{
	//1.移动删除位置之下的数据
	//   1.1 index + 1 位置的数据到 index
	//   1.2 index + 2              index + 1
	//   ....
	//2.laint main(int argc, const char *argv[])
	
	int i;
	if(-1 == p->last)  //如果为空，则退出
		return -1;
	if(index < 0 || index > p->last)
		return -2;

	for(i = index;i < p->last;i ++){
		p->data[i] = p->data[i + 1];
	}
	p->last --; //p->last // (*p).last
	
	return 0;
}

int get_index_list(list_t *p,int index,data_t *databuf)
{
	if(-1 == p->last)  //如果为空，则退出
		return -1;
	if(index < 0 || index > p->last)
		return -2;

	*databuf = p->data[index];

	return 0;
}

int change_index_list(list_t *p,int index,const data_t *newdata)
{
	if(-1 == p->last)  //如果为空，则退出
		return -1;
	if(index < 0 || index > p->last)
		return -2;

	p->data[index] = *newdata;

	return 0;
}
/*如果为满 返回 真1；非满 返回假0*/
int is_full_list(list_t *p)
{
	return (p->size - 1) == p->last;
}

int is_empty_list(list_t *p)
{
	return -1 == p->last;
}

int locate_list(list_t *p,const data_t *data)
{
	int i;

	if(NULL == p || NULL == data)
		return -2;

	for(i = 0;i <= p->last;i ++){
		if(*data == p->data[i])
			return i;
	}

	return -1;
}

int clean_list(list_t *p)
{
	p->last = -1;
	return 0;
}

int dis_list(list_t *p)
{
	free(p);
	
	return 0;
}

void print_list(list_t *p)
{
	int i;
	for(i = 0;i <= p->last;i ++){// 打印数据集合里的内容
		printf("%d ",p->data[i]);
	}
	printf("\n");
	printf("last:%d\n",p->last);//打印
	//最后一个元素位置
	return ;
}

##list.h
#ifndef __LIST_H__
#define __LIST_H__

typedef int data_t;

typedef struct list{
	data_t *data; //保存数据的空间
	int size;   //容器能保存的元素个数
	int last; //保存最后一个有效元素的下标
}list_t;
extern list_t *creat_list(int size);
extern int ins_index_list(list_t *p,int index,const data_t *data);
extern int del_index_list(list_t *p,int index);
extern int change_index_list(list_t *p,int index,const data_t *newdata);
extern int get_index_list(list_t *p,int index,data_t *databuf);
extern int is_full_list(list_t *p);
extern int is_empty_list(list_t *p);
extern int locate_list(list_t *p,const data_t *data);
extern int clean_list(list_t *p);
extern int dis_list(list_t *p);
extern void print_list(list_t *p);

#endif

##main.c
#include <stdio.h>
#include "list.h"

typedef struct list queue_list_t;

queue_list_t *creat_queue_list(int size)
{
	return creat_list(size);
}

int out_queue_list(queue_list_t *p,data_t *databuf)
{

	get_index_list(p,0,databuf);
	del_index_list(p,0);

	return 0;
}

int in_queue_list(queue_list_t *p,const data_t *data)
{
	ins_index_list(p,p->last + 1,data);

	return 0;
}


int main(int argc, const char *argv[])
{
	queue_list_t *p;
	int i;
	data_t buf;
	p = creat_queue_list(8);


	for(i = 0;i < 6;i ++){
		in_queue_list(p,&i);
	}

	i = 6;
	while(i --){
		buf = -1;
		out_queue_list(p,&buf);
		printf("out:%d\n",buf);
	}

	return 0;
}

链表实现

#include <stdio.h>        
#include <stdlib.h>
//链表队列，尾插头删

typedef int data_t;
typedef struct linkqueue_node{
	data_t data;
	struct linkqueue_node *next;
}linkqueue_node_t;

typedef struct linkqueue{
	linkqueue_node_t *head;
	linkqueue_node_t *tail;
}linkqueue_t;

linkqueue_t *creat_linkqueue_old()
{
	linkqueue_t *p;
	linkqueue_node_t *head;
	head = malloc(sizeof(linkqueue_node_t));

	head->next = NULL;
	
	p = malloc(sizeof(linkqueue_t));
	p->head = head;
	p->tail = head;

	return p;
}

linkqueue_t *creat_linkqueue()
{
	linkqueue_t *p;

	p = malloc(sizeof(linkqueue_t));
	p->head =  malloc(sizeof(linkqueue_node_t));
	p->tail = p->head;
	
	p->head->next = NULL;

	return p;
}

int in_linkqueue(linkqueue_t *p,const data_t *data)
{
	//1.执行链表尾部插入
	linkqueue_node_t *newnode;
	newnode = malloc(sizeof(linkqueue_node_t));
	newnode->data = *data;

	newnode->next = NULL;//p->tail->next; // 

	p->tail->next = newnode;
	//2.记录新的尾结点地址
	p->tail = newnode;

	return 0;
}

int out_linkqueue(linkqueue_t *p,data_t *databuf)
{

	if(NULL == p->head->next)
		return -1;

	//1.执行头部删除，并拷贝数据
	linkqueue_node_t *temp;
	temp = p->head->next;
	p->head->next = temp->next;
	
	*databuf = temp->data;

	free(temp);
	//2.判断 链表是否为空
	//  2.1 如果为空，纠正tail
	if(NULL == p->head->next)
		p->tail = p->head;

	return 0;
}

int get_head_linkqueue(linkqueue_t *p,data_t *databuf)
{
	if(NULL == p->head->next)
		return -1;

	*databuf = p->head->next->data;

	return 0;
}


void print_link(linkqueue_t *p)
{
	linkqueue_node_t *head;
	head = p->head; //注意：p->head 是p指向的堆区上的变量

	while(NULL != head->next){
		head = head->next;
		printf("%d ",head->data);
	}
	printf("\n");

	return ;
}


int main(int argc, const char *argv[])
{

	linkqueue_t *p;
	data_t buf;
	int i;

	p = creat_linkqueue();
	for(i = 0;i < 10;i ++)
		in_linkqueue(p,&i);

	//out_linkqueue(p,&buf);

	print_link(p);

	i = 13;
	while(i --){
		buf = -1;
		out_linkqueue(p,&buf);
		printf("out:%d\n",buf);
	}

	print_link(p);
	for(i = 0;i < 10;i ++)
		in_linkqueue(p,&i);
	print_link(p);

	return 0;
}

循环队列

#include <stdio.h>
#include <stdlib.h>
//循环队列
typedef int data_t;
typedef struct queue{
	data_t *data;
	int size;
	int head;
	int tail;
}queue_t;

queue_t *creat_queue(int size) //传递 可以容纳的数据个数
{ 
	queue_t *p;
	p = malloc(sizeof(queue_t));
	p->data = malloc(sizeof(data_t) * (size + 1));
	p->size = size + 1; // 保存真实的数组元素个数,实际空间大小

	p->head = 0;
	p->tail = 0;

	return p;
}

int in_queue(queue_t *p,const data_t *data)
{
	//容错：当队列满 ，直接退出   （tail + 1）% size == head
	//1.向尾部写入数据
	//2.tail ++
	if((p->tail + 1) % p->size == p->head)
		return -1;

	p->data[p->tail] = *data;

	p->tail = (p->tail + 1) % p->size;

	return 0;
}

int out_queue(queue_t *p,data_t *databuf)
{
	//容错：当队列空   head == tail
	if(p->head == p->tail)
		return -1;

	//1.读取头部数据
	//2.head ++

	*databuf = p->data[p->head];
	p->head = (p->head + 1) % p->size;

	return 0;
}

int get_length_queue(queue_t *p)
{
	return (p->size + (p->tail - p->head)) % p->size;
}


int clean_queue(queue_t *p)
{
	p->head = 0;
	p->tail = 0;
	return 0;
}

void print_queue(queue_t *p)
{
	int i;

	for(i = p->head;i != p->tail;
			i = (i + 1 ) % p->size)
	{
		printf("%d ",p->data[i]);
	}
	printf("\n");

	return ;
}



int main(int argc, const char *argv[])
{
	
	queue_t *p;
	int i;
	data_t buf;
	
	p = creat_queue(8);

	for(i = 0;i < 10;i ++){
		in_queue(p,&i);
	}
	print_queue(p);
	
	i = 5;
	while(i --){
		buf = -1;
		out_queue(p,&buf);
		printf("out:%d\n",buf);
	}

	for(i = 250;i < 256;i ++){
		in_queue(p,&i);
	}
	print_queue(p);

	i = 10;
	while(i --){
		buf = -1;
		out_queue(p,&buf);
		printf("out:%d\n",buf);
	}

	print_queue(p);
	return 0;
}
foreverwlh
关注
专栏目录
环形队列实现源码(c++)+通信开发必用
07-11
环形队列实现源码(c++)实现代码，做单片机或PC上位机通信程序开发经常用的数据结构，非常有用，本人已经用在多个项目中。
在qt上实现qq的客户端（附源码）
一个小菜鸡的学习之路
10-14 3905
最近做了一个qq的项目，在qt上实现qq的客户端，在vs上实现qq的服务器，先让大家看看效果图吧 登录模块，按下登录后会连接服务器 登录后的好友列表，会显示所有的在线好友 有新好友上线会自动更新好友列表 双方进行聊天，互相收到消息 群聊功能，一个人发送消息其他在线的人都会收到 #ifndef CHATWIDGET_H #define CHATWIDGET_H #include <QWidget> #include <QPushButton&g...
环形队列简单实现
Amour恋空的博客
03-23 829
环形队列
环形数组以及高效环形数组的qt实现
jijie_ming的博客
05-04 671
8. 由于head和tail的移动是循环的,因此可以一直追加和取出数据,实现循环利用数组空间。所以,环形数组是实现高性能循环缓冲区或队列的一种非常理想的结构,这也是spdlog选用它来实现日志缓冲的主要原因。7. 取出数据时,从head指针位置取数据,然后head指针移动。2. 使用两个指针来表示环形数组中数据的首尾,分别是head指针和tail指针。3. head指针指向环形数组的首部数据,tail指针指向环形数组的尾部数据。4. 数组中从head指针到tail指针的数据是有效数据,其余为空闲空间。
上位机开发笔记：环形缓冲区
dingxiaoxv的博客
12-05 2024
环形缓冲区(Ring buffer/Circular buffer)或称环形队列，是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。比如对通信中接收到的数据进行处理，当数据量太大或者处理速度跟不上接收速度时，就会将之前还未处理的数据覆盖掉，即出现丢包的现象。此时，使用环形缓冲区就可以有效解决这一问题。
python队列queue模块详解
09-20
`_init(maxsize)`内部使用了Python的`collections.deque`双端队列实现，这使得在两端添加或删除元素非常高效。 `queue`模块为了保证线程安全，使用了互斥锁（`mutex`）和条件变量。互斥锁（`self.mutex`）确保任何...
ruby线程实现生产者消费者问题示例(队列Queue实现线程同步)
01-20
代码如下:require “thread” puts “ProAndCon” queue = Queue.new #用队列Queue实现线程同步 producer = Thread.new do 10.times do |i| sleep rand(i) # 让线程睡眠一段时间 queue << i puts “#...
qt 环形队列FIFO 处理接收数据
LWLGZY的博客
06-19 3575
#ifndef __PROTOCOLBUFF_H #define __PROTOCOLBUFF_H #include "stdint.h" /* fifo buff for data receive */ class FifoClass { private: /* buff */ unsigned char buffData[1024 * 2 ]; /* valid data start and end piont */ unsigned char *pStart, *.
用Qt 实现循环队列，达到数据缓冲机制
最新发布
cs821984831的博客
12-22 1850
生产者就是兔子，消费者就是乌龟，然后缓存就是环形跑道, 生产者向缓存不断写数据，消费者不断的读数据，保证数据的高效稳定。3. 队列的特性：队列遵循先进后出的原则。队列的理解上,可以想象为一根左右开口的水管, 从左边进水，右边出水。2. 队列的分类：循环队列(单向的顺序表)，双向队列(双向链表)，优先队列(有顺序的完全二叉树)。1. 队列的定义：一端插入元素, 另一端删除元素的线性表。(3). 根据数据类型读取相应的包大小。2.兔子跑完一圈时的处理, 缓存临界的处理。3.多线程数据的安全处理。
【数据结构】队列（Queue）的实现 -- 详解
Elena's Blog
07-29 2019
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有：进行操作的一端称为。：进行操作的一端称为。
qt中QQueue的用法
Littlehero_121的博客
08-28 9567
以下是一些总结，关于QQueue的容器： 头文件：#include<QQueue> 1、在头文件中： #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include <QQueue> namespace Ui { class MainWindow; } typede...
QT队列的使用（QQueue）
MCJ的博客
01-27 1万+
头文件#include<QQueue> /*定义一个队列 <>中的类型也可以是自己定义的结构体烈性*/ QQueue<uint8_t> queue; /*入队列*/ queue.enqueue(128); /*出队列*/ uint8_t num = queue.dequeue(); 　　　　 /*队列判空，返回boo类型*/ queue.isEmpty(); /*队列元素个数，返回队列中还有多少..
队列（Queue）的实现及分析
weixin_62226325的博客
01-16 2847
1.队列的介绍： 1) 队列是一个有序列表，可以用数组或是链表来实现。 2) 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 3) 我们把向队列中插入元素的过程称为入队(Enqueue)，删除元素的过程称为出队(Dequeue)并把允许入队的一端称为队尾，允许出的的一端称为队头，没有任何元素的队列则称为空队。其一般结构如下： 2.常用关于队列的操作： package com.zejian.structures.Queue; /** * Created by zeji
【数据结构】队列的实现
qq_48479056的博客
03-24 924
E poll();E peek();//定义链表的头，尾E val;Node next;/*** /入队列：链表的尾插*/@Override//产生新节点//如果链表为空，此时新节点就是头和尾//如果链表不为空，此时size++;/*** /出队列：出的是链表中的头结点*/@Overridesize--;return val;/*** 查看队首元素*/@Override/*** 重写ToString方法*/@Override。
QT循环队列实时处理数据（二）
热门推荐
Universe
05-21 1万+
QT的项目中，需要实时处理通过socket获取的数据，并且实时处理，保证数据不会丢失，这个循环队列的方式，简单，高效是一个不错的选择！
vue工具（封装本地存储相关的操作模块）
weixin_46611729的博客
12-25 192
/** * 本地存储相关的操作模块 */ /** * 写入数据 */ export const setItem = (key, data) => { // 如果存入的是对象、数组类型的数据 if (typeof data === 'object') { // 将数据转换为json字符串格式 data = JSON.stringify(data) } window.localStorage.setItem(key, data) } /** * 读取数据 *
QT实现基于QIODevice的线程安全环形队列
萧海的博客
09-19 940
QT实现基于QIODevice的线程安全环形队列. /****************************************************************************** Copyright (C) 2017-2018 Zhang Fei <1158114251@qq.com> This class inherits the QIODevice class. This class implements a lock-free rin
使用stl中的单端队列queue实现栈
06-11
可以使用两个单端队列queue来实现栈的功能。 具体实现如下： 1. 定义一个类Stack，成员变量为两个queue<int>类型的队列，分别为queue1和queue2。 2. 实现push函数，将元素插入到queue1中。 3. 实现pop函数，先将queue1中的元素全部转移到queue2中，直到queue1中只剩下一个元素。将这个元素弹出，再将queue2中的元素转移到queue1中。 4. 实现top函数，与pop函数类似，但是不弹出元素。 5. 实现empty函数，判断queue1和queue2是否都为空。 下面是完整的代码实现： ```c++ #include <queue> using namespace std; class Stack { public: void push(int x) { q1.push(x); } int pop() { int size = q1.size(); for (int i = 0; i < size - 1; i++) { q2.push(q1.front()); q1.pop(); } int top = q1.front(); q1.pop(); swap(q1, q2); return top; } int top() { int size = q1.size(); for (int i = 0; i < size - 1; i++) { q2.push(q1.front()); q1.pop(); } int top = q1.front(); q1.pop(); q2.push(top); swap(q1, q2); return top; } bool empty() { return q1.empty() && q2.empty(); } private: queue<int> q1, q2; }; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

foreverwlh

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

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

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

打赏作者

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

抵扣说明：

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

余额充值