C语言数据结构之链队列的基本操作

目录
  • 1.队列的定义
  • 2.队列的表示和实现
    • (1) 初始化操作
    • (2)销毁队列
    • (3) 入队操作
    • (4) 出队操作
    • 附录完整代码:
  • 总结

1.队列的定义

队列 (Queue)是另一种限定性的线性表,它只允许在表的一端插入元素,而在另一端删除元素,所以队列具有先进先出(Fist In Fist Out,缩写为FIFO)的特性。在队列中,允许插入的一端叫做队尾(rear),允许删除的一端则称为队头(front)。 假设队列为q=(a1,a2,…,an),那么a1就是队头元素,an则是队尾元素。队列中的元素是按照a1、a2、…、an的顺序进入的, 退出队列也必须按照同样的次序依次出队,也就是说,只有在a1、a2、…、an-1都离开队列之后,an才能退出队列。

2.队列的表示和实现

链队列可以定义如下:

#define  TRUE    1
#define  FALSE  0
typedef struct QNode{
        QElemType  data;
        struct QNode *next;
}QNode, *QueuePtr;
typedef struct{
        QueuePtr  front;
        QueuePtr  rear;
}LinkQueue;

(1) 初始化操作

Status InitQueue(LinkQueue &Q)
{
       Q.front = Q.rear = (Queueptr) malloc(sizeof(QNode));
       if(!Q.front) exit ( OVERFLOW);
       Q.front ->next = NULL;
       return OK;
}

(2)销毁队列

Status DestroyQueue(LinkQueue &Q)
{
        while(Q.front) {
	Q.rear = Q.front->next;
	free (Q.front);
	Q.front = Q.rear;
        }
        return OK;
}

(3) 入队操作

Status EnQueue (LinkQueue &Q, QelemType e)
{
        p= (QueuePtr) malloc(sizeof(QNode));
        if (!p) exit ( OVERFLOW);
        p->data = e;  p->next = NULL;
        Q.rear -> next =p;
        Q.rear = p;
        return OK;
}

(4) 出队操作

Status DeQueue (LinkQueue &Q, QelemType &e)
{
        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;
}

附录完整代码:

#include<iostream>
using namespace std;
#define OK 1
#define FALSE 0

typedef int QElemType;
typedef int Status;

typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
    QueuePtr font;
    QueuePtr near;
}LinkQueue;

Status InitQueue(LinkQueue &Q)
{
    Q.font=(QueuePtr)malloc(sizeof(QNode));
    if(!Q.font) exit(FALSE);
    Q.font->next=NULL;
    Q.near=Q.font;
    return OK;
}
Status QueueEmpty(LinkQueue Q)
{
    if(Q.font->next) return OK;
    return FALSE;
}
Status EnQueue(LinkQueue &Q,QElemType e)
{
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    p->data=e;
    Q.near->next = p;
    Q.near = Q.near->next;
    p->next = NULL;
    return OK;
}
Status DeQueue(LinkQueue &Q,QElemType &e)
{
    if(!Q.font->next) return FALSE;
    QueuePtr p;
    p=Q.font->next;
    e=p->data;
    Q.font->next=p->next;
    if(Q.near==p) Q.near=Q.font;   //当是最后一个元素时,Q.font=NULL,Q.near=Q.font
    free(p);
    return OK;
}
Status ClearQueue(LinkQueue &Q)
{
    QueuePtr p;
    p=Q.font->next;
    QueuePtr q;
    while(p)
    {
        q=p;
        p=p->next;
        Q.font->next=p;
        free(q);
    }
    Q.near=Q.font;
    return OK;
}
void menu()
{
    cout<<"初始化队列:1"<<endl;
    cout<<"入队:2"<<endl;
    cout<<"出队:3"<<endl;
    cout<<"清空队列:4"<<endl;
    cout<<"退出:5"<<endl;
}
int main()
{
    LinkQueue Q;
    while(true)
    {
        int n;
        menu();
        scanf("%d",&n);
        int e=-1;
        switch(n)
        {
            case 1:
                InitQueue(Q);
                continue;
            case 2:
                printf("请输入一个元素");
                scanf("%d",&e);
                EnQueue(Q,e);
                continue;
            case 3:
                DeQueue(Q,e);
                printf("\n出队元素%d\n",e);
                continue;
            case 4:
                ClearQueue(Q);
                printf("清空成功\n");
                continue;
            default:
                break;
        }
        if(n==5)break;
    }

}

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • C语言实现链队列

    记录一下C语言实现的链队列代码,供大家参考,具体内容如下 #include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef int ElemType; //链队列的结点定义 typedef struct node{ ElemType val; struct node* next; }QueueNode; //链队列的定义,包含队头指针和队尾指针 typedef struct queue { QueueNod

  • C语言实现链队列代码

    本文实例为大家分享了C语言实现链队列的具体代码,供大家参考,具体内容如下 #include <stdio.h> /* 队列的结构体 */ typedef int DataType; #define NODE_LEN sizeof(NODE) /* 队列的节点 */ typedef struct stNode { DataType data; struct stNode* next; }NODE; /* 队列 */ typedef struct stQueue { NODE* head; //队

  • C语言单链队列的表示与实现实例详解

    1.概述: C语言的队列(queue),是指先进先出(FIFO, First-In-First-Out)的线性表.在具体应用中通常用链表或者数组来实现.队列只允许在后端(称为rear)进行插入操作,在前端(称为front)进行删除操作. 而单链队列使用链表作为基本数据结果,因此不存在伪溢出的问题,队列长度也没有限制.但插入和读取的时间代价会比较高 2.实例代码: /* 单链队列--队列的链式存储结构 */ typedef struct QNode { QElemType data; struct

  • C语言实现链队列基本操作

    队列的链式存储结构实现,相比于循环队列实现要复杂一些,但是没有队满的限制. 头文件声明 #include <stdio.h> #include <stdlib.h> /** * 队列的链式存储实现 * [带头结点的单链表] * [-类似于链栈,队列的链式存储实现也不会出现队满的情况] */ //数据类型 typedef int ElemType; //定义节点 typedef struct SqQueueNode { ElemType data;//数据域 struct SqQue

  • C语言版实现链队列

    本文实例为大家分享了C语言实现链队列的具体代码,供大家参考,具体内容如下 源文件部分:  指针没学好的同学很难看懂^_^,有点乱,希望对大家有点帮助. #include<stdio.h> #include<malloc.h> #include<stdlib.h> #include<string.h> typedef int Elemtype; #include"LQueue.h" int main() { Deque head; inst

  • C语言数据结构之链队列的基本操作

    目录 1.队列的定义 2.队列的表示和实现 (1) 初始化操作 (2)销毁队列 (3) 入队操作 (4) 出队操作 附录完整代码: 总结 1.队列的定义 队列 (Queue)是另一种限定性的线性表,它只允许在表的一端插入元素,而在另一端删除元素,所以队列具有先进先出(Fist In Fist Out,缩写为FIFO)的特性.在队列中,允许插入的一端叫做队尾(rear),允许删除的一端则称为队头(front). 假设队列为q=(a1,a2,-,an),那么a1就是队头元素,an则是队尾元素.队列中

  • C语言数据结构链表队列的实现

    C语言数据结构链表队列的实现 1.写在前面 队列是一种和栈相反的,遵循先进先出原则的线性表. 本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码. 分解代码没有包含在内的代码如下: #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 typedef int QElemtype; typedef int status; 2.代码分解 2.1对队列和节点的结构定义 typedef struct

  • C语言数据结构系列队列篇

    目录 一.队列(Queue) 0x00队列的概念 0x01队列的结构 二.队列的定义 0x00链式队列 0x02 接口函数 三.队列的实现 0x00队列初始化(QueueInit) 0x01销毁队列(QueueDestroy) 0x02判断队列是否为空(HeapIsEmpty) 0x03入队(QueuePush) 0x04出队(QueuePop) 0x05 返回队头数据(QueueFront) 0x06 返回队尾数据(QueueBack) 0x07 求队列大小(QueueSize) 0x08完整

  • C语言数据结构之队列的定义与实现

    目录 一.队列的性质 二.队列的结构 三.代码实现 头文件 功能函数 一.队列的性质 上次我们学习栈,了解到栈储存释放数据的方式是:先进后出 而队列与其相反,队列是:先进先出,后进后出. 二.队列的结构 多个链表节点 + 头尾指针   (链表式队列) 链表节点负责存储数据:头节点 负责定位先进的起始数据,方便先出: 尾节点负责记录尾部数据,方便确定队列当前状态. 三.代码实现 头文件 这里方便统一调用,将头尾指针定义成一个结构体 . #include<stdio.h> #include<

  • C语言 数据结构之链表实现代码

    前言 最近在复习数据结构的相关知识,感觉在初学的时候还是有很多东西没有掌握,不过现在终于算是搞得比较有头绪了,所以就在写出来和大家一起分享! 什么是链表 简单的说,链表就是由多个结点离散分配,彼此通过指针相连,每个结点只有一个前驱结点和后继结点.首节点无前驱结点,为结点无后继结点的一种存储结构. 链表的结构 头结点:链表的第一个有效结点前面的结点,头结点并不存放有效数据,也就是数据域为空,加头结点的主要目的是为了方便链表的操作. 首节点:链表的第一个有效结点,结点包含数据域和指针域. 尾结点:尾

  • C语言数据结构之队列算法详解

    目录 一.前言 二.基本概念 三.顺序队列 四.链队列 五.循环队列 六.总结与提高 一.前言 队列在程序设计中经常出现,如:操作系统中的排队问题. 这篇文章主要介绍了队列的基本概念.性质,顺序.链.循环三种不同的方法实现队列,顺序和循环队列在算法中比较常用 二.基本概念    定义:队列是允许在一端插入,另一端删除的线性表 队头(front):允许删除的一端 队尾(rear):允许插入的一端 特点:先进先出 三.顺序队列 动态图: 算法讲解:  图解:入队,rear++,出队,front++

  • C语言数据结构系列篇二叉树的遍历

    目录 前言: Ⅰ. 定义二叉树 0x00二叉树的概念(回顾) 0x00定义二叉树 0x01 手动创建二叉树 Ⅱ. 二叉树的遍历 0x00关于遍历 0x01二叉树前序遍历 0x02二叉树中序遍历 0x03二叉树后序遍历 0x04层序遍历 前言: 学习二叉树的基本操作前,需要先创建一颗二叉树,然后才能学习其相关的基本操作,考虑到我们刚刚接触二叉树,为了能够先易后难地进行讲解,我们将暂时手动创建一颗简单的二叉树,用来方便大家学习.等二叉树结构了解的差不多后,后期我们会带大家研究二叉树地真正的创建方式.

  • C利用语言实现数据结构之队列

    目录 一.链队列 二.链队的表示 三.链队的基本操作 1. 链队的初始化 2. 链队的销毁 3. 入队 4. 出队 四.顺序队列 五.循环队列 1. 初始化 2. 求队列长度 3. 入队 4. 出队 前言: 队列在生活中也比较常见,例如购物排队--新来的成员总是加入队尾,每次离开的成员总是队列头上的. 队列按存储方式可以分为两种:顺序队列和链队列. 一.链队列 链式队列中每个元素定义成一个结点,含数据域与指针域(指向下一结点),并设头尾指针.用图表示就是. 二.链队的表示 前面的链式结构,总是使

  • c语言数据结构之栈和队列详解(Stack&Queue)

    目录 简介 栈 一.栈的基本概念 1.栈的定义 2.栈的常见基本操作 二.栈的顺序存储结构 1.栈的顺序存储 2.顺序栈的基本算法 3.共享栈(两栈共享空间) 三.栈的链式存储结构 1.链栈 2.链栈的基本算法 3.性能分析 四.栈的应用——递归 1.递归的定义 2.斐波那契数列 五.栈的应用——四则运算表达式求值 1.后缀表达式计算结果 2.中缀表达式转后缀表达式 队列 一.队列的基本概念 1.队列的定义 2.队列的常见基本操作 二.队列的顺序存储结构 1.顺序队列 2.循环队列 3.循环队列

  • C++语言数据结构 串的基本操作实例代码

    C语言数据结构 串的基本操作实例代码 输出结果: 实现代码: #include<iostream> using namespace std; typedef int Status; #define Max 20 #define OK 1 #define ERROR 0 #define OVERLOE -2 typedef struct//堆分配表示串 { char *ch; int length; }HString; //====================================

随机推荐