数据结构——队列

最新推荐文章于 2021-06-08 22:48:29 发布
最新推荐文章于 2021-06-08 22:48:29 发布
阅读量229 收藏 2
点赞数 3
分类专栏： # 数据结构 文章标签： 队列 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50675813/article/details/110715271
版权

真香！20张图揭开「队列」的迷雾，一目了然

循环队列
链队列
队列的应用

循环队列代码

#include<stdio.h>
typedef int ElemType;
typedef int QElemType;
typedef int Status;
#define TRUE  1
#define FALSE 0
#define  ERROR 0
#define  OK 1
#include<malloc.h> 
#include<stdlib.h>

//----------循环队列 --顺序存储结构-----------------------
#define  MAXQSIZE  100    // 最大队列长度+1
typedef  struct {
    ElemType   *base;   // 初始化的动态分配存储空间
    int   front;    // 头指针，若队列不空，指向队列头元素
    int   rear;   // 尾指针，若队列不空，指向队列尾元素的下一个位置
}  SqQueue;
void InitQueue(SqQueue &Q)
{    // 构造一个空队列Q
    Q.base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
    if(!Q.base) // 存储分配失败
        exit(0);
    Q.front = Q.rear = 0;
}
void DestroyQueue(SqQueue &Q)
{   // 销毁队列Q，Q不再存在
    if(Q.base)
        free(Q.base);
    Q.base = NULL;
    Q.front = Q.rear = 0;
}
int QueueLength(SqQueue &Q)
{
	return ((Q.rear-Q.front+MAXQSIZE)%MAXQSIZE);
}
Status EnQueue(SqQueue &Q, QElemType e)
{   // 插入元素e为Q的新的队尾元素
    if((Q.rear + 1) % MAXQSIZE == Q.front) // 队列满
        return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXQSIZE;
    return OK;
}
Status DeQueue(SqQueue &Q, QElemType &e)
{  // 若队列不空，则删除Q的队头元素，用e返回其值，
   // 并返回OK；否则返回ERROR
    if(Q.front == Q.rear) // 队列空
        return ERROR;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXQSIZE;
    return OK;
}
Status GetHead(SqQueue Q, QElemType &e)
{   // 若队列不空，则用e返回Q的队头元素，并返回OK；
    // 否则返回ERROR
    if(Q.front == Q.rear) // 队列空
        return ERROR;
    e = Q.base[Q.front];
    return OK;
}
Status QueueEmpty(SqQueue Q)
{
    // 若队列Q为空队列，则返回TRUE；否则返回FALSE
    if(Q.front == Q.rear) // 队列空的标志
        return TRUE;
    else
        return FALSE;
}
void traverse(SqQueue &Q)
{
	int x;
	x=Q.front;
	int num=QueueLength(Q);
	for(int i=0;i<num;i++)
	{
		printf("%d--",Q.base[(x++)%MAXQSIZE]);
	}
}

int main ()
{
	int n=1,e,q;
	int temp;
	int a;
	SqQueue P;
	InitQueue(P);
	printf("队列-----菜单\n"); 
printf("[ 1]：入队输入 \n[ 2]：出队输入 \n[ 3]：得到队首元素输入\n[ 4]：判断队是否为空 \n");
	printf("[ 5]： 销毁队 \n[ 6]:求循环队列的长度\n[ 7]:遍历循环队列\n");
	
	while(n)
	{
		printf("输入操作："); 
		scanf("%d",&a); 
		switch(a)
		{
			case 1: printf("入队操作,输入要入队的元素："); 
					scanf("%d",&e);
					EnQueue(P, e);
					break;
			case 2: printf("出队操作\n"); 
				   DeQueue(P, q);
				    printf("当前出队的元素的值为：%d\n",q);
					break;
			case 3: GetHead(P, temp);
				 	printf("输出队首元素为 %d \n",temp);
				 	break;
			case 4: if(QueueEmpty(P)) printf("当前队列为空\n");
			 			else printf("当前队列不空\n"); 
			 		break;
			case 5: printf("---正在销毁队列---\n");
			 		DestroyQueue(P);
			 		break;
			case 6:
						printf("队列的长度为%d \n",QueueLength(P));
					break;
			case 7:traverse(P);
					break;
			 		
		}
			
	}
	
 }

链队列：

#include<stdio.h>
typedef int ElemType;
typedef int QElemType;
typedef int Status;
#define TRUE  1
#define FALSE 0
#define  ERROR 0
#define  OK 1
#include<malloc.h> 
#include<stdlib.h>
typedef struct QNode
{  ElemType data;	  //存放队中元素
   struct QNode *next;  //指向下一个结点
} QNode, *QueuePtr;
typedef struct
{  QNode *front;	  //队头指针
   QNode *rear;	  //队尾指针
} LinkQueue;
void InitQueue(LinkQueue &Q)
{
    // 构造一个空队列Q
    if(!(Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode))))
        exit(0);
    Q.front->next = NULL;
}
void DestroyQueue(LinkQueue &Q)
{    // 销毁队列Q(无论空否均可)
    while(Q.front) {
        Q.rear = Q.front->next;
        free(Q.front);
        Q.front = Q.rear;
    }
}
void EnQueue(LinkQueue &Q, QElemType e)
{  // 插入元素e为Q的新的队尾元素
    QueuePtr p;
    if(!(p = (QueuePtr)malloc(sizeof(QNode)))) //存储分配失败
        exit(0);
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
}
Status DeQueue(LinkQueue &Q, QElemType &e)
{  // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，
   // 否则返回ERROR
    QueuePtr p;
    if(Q.front == Q.rear)
        return ERROR;
    p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;
    if(Q.rear == p)
        Q.rear = Q.front;
    free(p);
    return OK;
}
Status GetHead(LinkQueue Q, QElemType &e)
{  // 若队列不空，则用e返回Q的队头元素，并返回OK，
   // 否则返回ERROR
    QueuePtr p;
    if(Q.front == Q.rear)
        return ERROR;
    p = Q.front->next;
    e = p->data;
    return OK;
}

Status QueueEmpty(LinkQueue Q)
{  // 若Q为空队列，则返回TRUE，否则返回FALSE
    if(Q.front->next == NULL)
        return TRUE;
    else
        return FALSE;
}

int main ()
{
	int n=1,e,q;
	int temp;
	int a;
	LinkQueue P;
	InitQueue(P);
	printf("队列-----菜单\n"); 
	printf("1：入队输入 \n2：出队输入 \n3：得到队首元素输入\n4：判断队是否为空 \n5： 销毁队 \n");
	while(n)
	{
		printf("输入操作："); 
		scanf("%d",&a); 
		switch(a)
		{
			case 1: printf("入队操作,输入要入队的元素："); 
					scanf("%d",&e);
					EnQueue(P, e);
					break;
			case 2: printf("出队操作\n"); 
				   DeQueue(P, q);
				    printf("当前出队的元素的值为：%d\n",q);
					break;
			case 3: GetHead(P, temp);
				 	printf("输出队首元素为 %d \n",temp);
				 	break;
			case 4: if(QueueEmpty(P)) printf("当前队列为空\n");
			 			else printf("当前队列不空\n"); 
			 		break;
			case 5: printf("---正在销毁队列---\n");
			 		DestroyQueue(P);
			 		break;
			 		
		}
			
	}
	
 }

翻转前k个元素算法

#include<stdio.h>
typedef int ElemType;
typedef int QElemType;
typedef int Status;
#define TRUE  1
#define FALSE 0
#define  ERROR 0
#define  OK 1
#include<malloc.h> 
#include<stdlib.h>






// ------栈的顺序存储结构表示----------
#define STACK_INIT_SIZE 100 	// 存储空间初始分配量
#define STACK_INCREMENT 10 	// 存储空间分配增量
typedef int  ElemType;
typedef struct {
  ElemType *base; 	// 栈底指针
  ElemType *top; 	// 栈顶指针
  int stacksize; 	// 栈空间大小
} SqStack;


void InitStack(SqStack &S)
{
    // 构造一个空栈S
    if(!(S.base = (ElemType *)malloc(STACK_INIT_SIZE 
                                  * sizeof(ElemType))))
        exit(0);     // 存储分配失败
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
}

void DestroyStack(SqStack &S)
{
    // 销毁栈S，S不再存在
    free(S.base);
    S.base = NULL;
    S.top = NULL;
    S.stacksize = 0;
}

void Push(SqStack &S, ElemType e)
{
    if(S.top - S.base >= S.stacksize) { // 栈满，追加存储空间
        S.base = (ElemType *)realloc(S.base, (S.stacksize 
              + STACK_INCREMENT) * sizeof(ElemType));
        if(!S.base)
            exit(0);           // 存储分配失败
        S.top = S.base + S.stacksize;
        S.stacksize += STACK_INCREMENT;
    }
    *(S.top)++ = e;
}

Status Pop(SqStack &S, ElemType &e)
{
    // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；
    // 否则返回ERROR
    if(S.top == S.base)
        {
        	printf("此时栈为空，不可以再出栈\n");
			return ERROR;
		}
    e = *--S.top;
    
    
    return OK;
}

Status GetTop(SqStack S, ElemType &e)
{
    // 若栈不空，则用e返回S的栈顶元素，并返回OK；
    // 否则返回ERROR
    if(S.top > S.base) {
        e = *(S.top - 1);
        printf("输出栈顶元素为 %d \n",e);
        return OK;
    }
    else
    {
    	printf("此时栈为空，得不到栈顶元素\n");
		return ERROR;
	}
        
}

Status StackEmpty(SqStack S)
{
    // 若栈S为空栈，则返回TRUE，否则返回FALSE
    if(S.top == S.base)
        return TRUE;
    else
        return FALSE;
}






//----------循环队列 --顺序存储结构-----------------------
#define  MAXQSIZE  100    // 最大队列长度+1
typedef  struct {
    ElemType   *base;   // 初始化的动态分配存储空间
    int   front;    // 头指针，若队列不空，指向队列头元素
    int   rear;   // 尾指针，若队列不空，指向队列尾元素的下一个位置
}  SqQueue ;
void InitQueue(SqQueue &Q)
{    // 构造一个空队列Q
    Q.base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
    if(!Q.base) // 存储分配失败
        exit(0);
    Q.front = Q.rear = 0;
}
void DestroyQueue(SqQueue &Q)
{   // 销毁队列Q，Q不再存在
    if(Q.base)
        free(Q.base);
    Q.base = NULL;
    Q.front = Q.rear = 0;
}
Status EnQueue(SqQueue &Q, QElemType e)
{   // 插入元素e为Q的新的队尾元素
    if((Q.rear + 1) % MAXQSIZE == Q.front) // 队列满
        return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXQSIZE;
    return OK;
}
Status DeQueue(SqQueue &Q, QElemType &e)
{  // 若队列不空，则删除Q的队头元素，用e返回其值，
   // 并返回OK；否则返回ERROR
    if(Q.front == Q.rear) // 队列空
        return ERROR;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXQSIZE;
    return OK;
}
Status GetHead(SqQueue Q, QElemType &e)
{   // 若队列不空，则用e返回Q的队头元素，并返回OK；
    // 否则返回ERROR
    if(Q.front == Q.rear) // 队列空
        return ERROR;
    e = Q.base[Q.front];
    return OK;
}
Status QueueEmpty(SqQueue Q)
{
    // 若队列Q为空队列，则返回TRUE；否则返回FALSE
    if(Q.front == Q.rear) // 队列空的标志
        return TRUE;
    else
        return FALSE;
}

void Queue_traverse(SqQueue Q)
{
	int e; 
	while(QueueEmpty(Q)!=1)
	{e = Q.base[(Q.front++) % MAXQSIZE];
	printf("-%d",e);
	}
	printf("\n");
	
}
int main ()
{
	int n=1,e,q;
	int temp;
	int a;
	SqQueue P;
	InitQueue(P);
	printf("队列-----菜单\n"); 
	printf("[ 1]：入队输入 \n[ 2]：出队输入 \n[ 3]：得到队首元素输入\n[ 4]：判断队是否为空 \n[ 5]： 销毁队 \n");
	printf("[ 6]翻转队列的前k个元素\n[ 7]:遍历队列\n");
	while(n)
	{
		printf("输入操作："); 
		scanf("%d",&a); 
		switch(a)
		{
			case 1: printf("入队操作,输入要入队的元素："); 
					scanf("%d",&e);
					EnQueue(P, e);
					break;
			case 2: printf("出队操作\n"); 
				   DeQueue(P, q);
				    printf("当前出队的元素的值为：%d\n",q);
					break;
			case 3: GetHead(P, temp);
				 	printf("输出队首元素为 %d \n",temp);
				 	break;
			case 4: if(QueueEmpty(P)) printf("当前队列为空\n");
			 			else printf("当前队列不空\n"); 
			 		break;
			case 5: printf("---正在销毁队列---\n");
			 		DestroyQueue(P);
			 		break;
			case 6: printf("---翻转队列前k个元素---\n");
					printf("初始化队列入队元素个数n：");
					int x;
					scanf("%d",&x);
					 for(int i=0;i<x;i++)
					 {
					 	printf("输入入队列的元素值：");
						 scanf("%d",&e);
					 	EnQueue(P, e);
					 }
					
					printf("输入K:");
					int k;
					scanf("%d",&k);
					
					SqStack W;
					InitStack(W);
			 		for(int j=0;j<k;j++)
			 		{	DeQueue(P, q);
			 			Push(W, q);
					 }//将前k个压入栈中 
					 for(int j=0;j<k;j++)
			 		{	Pop(W, q);
					 	EnQueue(P, q);
			 			
					 }//将栈中的元素进入队列p中 
					 for(int j=0;j<x-k;j++)
			 		{	DeQueue(P, q);
					 	EnQueue(P, q);
			 			
					 }
					 Queue_traverse(P);
			 		break;
			case 7:Queue_traverse(P);
					break;
			 		
		}
			
	}
	
 }

在这里插入图片描述

943802606
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——队列 求队列长度 C语言
03-16
输入若干个整数, 以0结束, 利用入队的操作生成一个循环队列, 求该队列的长度。
第七周 【项目1 - 建立顺序环形队列算法库】
lilinxi_的博客
10-12 172
1.头文件：sqqueue.h，包含定义顺序环形队列数据结构的代码、宏定义、要实现算法的函数的声明/* * Copyright(c) 2017,烟台大学计算机学院 * All rights reserved. * 作 者:李琳汐 * 完成日期:2017 年 10 月 12日 * 版 本 号:v1.0 * * 问题描述:建设自己的专业基础设施算法库 */ #ifndef SQ
超清晰-数据结构之队列
MClink的博客
12-16 1203
前言：毕业后忙于工作，较少花时间在基础上，突然想起某位大佬的名言，当你不知道该学什么的时候，就去看看基础，是的，技术的范畴确实太大了，我们很容易就会迷茫，不管是哪门语言的开发者，不管你学的是什么武功，内功精髓本质上还是一样的，大学以来，我一直对递归和栈的使用处于一种半知半觉的状态，何为半知半觉，就是我能说出它的概念以及简单的应用，但是问细下去，便没办法了，这篇文章我想先来说说我对队列的理解,下一...
[编程题]构造队列
It_BeeCoder的博客
03-30 420
一、题目小明同学把1到n这n个数字按照一定的顺序放入了一个队列Q中。现在他对队列Q执行了如下程序：while(!Q.empty()) //队列不空，执行循环 { int x=Q.front(); //取出当前队头的值x Q.pop(); //弹出当前队头 Q.push(x); ...
数据结构：队列
BJM‘s blog.
06-07 201
ADT Queue{ 数据对象：D={ai|ai∈ElemSet, i=1,2, …,n, n≥0} 数据关系：R1={|ai-1,ai∈D, i=1,2, …,n }             约定a1为队列头，an为队列尾。 基本操作：     InitQueue( &Q )       操作结果：构造一个空队列Q。     DestroyQueue (
数据结构——队列的应用.doc
07-11
数据结构中的队列是一种线性数据结构，它遵循“先进先出”（FIFO, First In First Out）的原则。在本实验中，我们主要探讨了队列的应用，特别是在实现杨辉三角输出上的应用。 首先，我们需要理解循环队列。循环队列...
算法和数据结构——队列.pdf
08-07
队列是一种基础且重要的数据结构，它遵循“先进先出”（FIFO，First In First Out）的原则。在队列中，元素的插入（入队）发生在队尾，而删除（出队）则发生在队头。这个概念可以类比于现实生活中人们排队购物的情景...
数据结构实验——队列子系统
最新发布
07-31
在这个实验中，我们专注于队列，一种线性数据结构，它的主要特点在于数据的先进先出（FIFO）原则。队列通常被比喻为排队等待服务的人群，最先到达的人最先接受服务，而后来的人则需等待。 实验的目标是掌握队列的...
数据结构——堆栈和队列
02-06
总的来说，这个压缩包提供了关于数据结构——堆栈和队列的C语言实现，以及额外的数字转换和字符串处理功能。这些基础知识对于理解和编写高效的计算机程序至关重要。通过学习和理解这些内容，开发者能够更好地解决...
数据结构——队列的实现
10-26
队列是一种重要的线性数据结构，其工作原理类似于现实生活中的排队等候，遵循“先进先出”（FIFO）的原则。本篇文章将深入探讨队列的逻辑结构，以及如何在实际应用中实现队列。 队列的基本概念： 1. 队头：队列的...
图解数据结构（使用Python）——队列
12-20
【队列】是一种基本的数据结构，它遵循“先进先出”（FIFO，First In First Out）的原则。在队列中，元素的添加（入队）发生在队尾，而删除（出队）则发生在队首。与之相比，栈遵循“后进先出”（LIFO，Last In ...
数据结构入门——队列的实现.rar
04-02
在这个"数据结构入门——队列的实现.rar"的压缩包中，我们主要关注的是队列这一基础但重要的数据结构。队列，正如其名，模拟了现实生活中的排队现象，遵循“先进先出”（FIFO, First In First Out）原则。这意味着最...
Java数据结构与算法02——队列
12-21
本篇文章将深入探讨队列这一基本的数据结构，并通过Java实现一个简单的数组模拟队列，以帮助读者理解其工作原理。 队列是线性数据结构的一种特殊形式，它遵循“先进先出”（First In First Out，简称FIFO）的原则。...
C/C++语言实现数据结构之单链表（带头结点）
M.JH的博客
04-20 312
单链表相关知识 用C语言简单实现 #include<stdio.h> #include<stdlib.h> typedef int ElemType; //让链表存储数据为int，如果想泛化能力更强，可以采用C++的模板技术 typedef struct Node { ElemType data; Node* next; }*PNode; //初始化链表 bool InitPNode(PNode& L) { L = (Node*)malloc(sizeof(Nod
c语言一个队列实现
hehainan_86的专栏
09-13 4128
队列是c语言中一个重要的数据结构之一，下面就是实现队列建立、插入、删除、清空、销毁等操作的代码。 头文件 Queue.h #ifndef QUEUE_H_ #define QUEUE_H_ typedef int Item; typedef struct node { Item data; struct node* next; }Node,*PNode; typedef struct
数据结构二叉排序树创建，插入，查找（C语言）
weixin_44565532的博客
06-08 835
#include<stdio.h> #include <stdlib.h> typedef int ElemType; //二叉排序树节点 typedef struct BSTNode{ int key; struct BSTNode *lchild,*rchild; }BSTNode,*BSTree; //在二叉排序树中查找值为key的结点 BSTNode *BST_Search(BSTree T,int key){ while(T!=NULL && key
队列的实现（完整代码+详细注释版）【数据结构】
小賀のBlog
08-02 3246
注释详细完整且健壮的两种方式实现队列的代码： 顺序队列 // // main.c // SequenceQueue // // Created by Eason on 2020/8/2. // Copyright © 2020 Eason. All rights reserved. // #include <stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 21 /
栈的溢出与数据结构——栈与队列解析
“栈的溢出-数据结构栈与队列” 在计算机科学中，栈和队列是两种基础且重要的数据结构，它们在程序设计中扮演着至关重要的角色。栈（Stack）和队列（Queue）都是线性结构，但它们的操作规则有所不同，这使得它们在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值