数据结构：队列的顺序存储结构【转】

本文转载自：http://blog.csdn.net/jnu_simba/article/details/8841657

队列（Queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。是一种先进先出的线性表（FIFO）。允许插入的一端称为队尾，允许删除的一端称为队头。我们在《栈的顺序存储结构》中发现，栈操作的top指针在Push时增大而在Pop时减小，栈空间是可以重复利用的，而队列的front、rear指针都在一直增大，虽然前面的元素已经出队了，但它所占的存储空间却不能重复利用。但大多数程序并不是这样使用队列的，一般情况下出队的元素就不再有保存价值了，这些元素的存储空间应该回收利用，由此想到把队列改造成环形队列（Circular Queue）：把queue数组想像成一个圈，front和rear指针仍然是一直增大的，当指到数组末尾时就自动回到数组开头，就像两个人围着操场赛跑，沿着它们跑的方向看，从front到rear之间是队列的有效元素，从rear到front之间是空的存储位置，如果front追上rear就表示队列空了，如果rear追上front就表示队列的存储空间满了。故一般我们将其实现为循环队列，当出队列时就不需要全部进行移动，只需要修改队头指针，也可以解决“假溢出”的问题。

示例程序：（改编自《大话数据结构》）

C++ Code


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124 		 
#include<iostream>
using namespace std;

#define MAXSIZE 20

typedef int ElemType;

typedef struct
{
    ElemType data[MAXSIZE];
    int front; /* 头指针 */
    int rear; /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
    int count; //元素个数
} SqQueue;

bool InitQueue(SqQueue &Sq)
{
    cout << "Init Queue ..." << endl;
    Sq.front = 0;
    Sq.rear = 0;
    Sq.count = 0;
    return true;
}

bool ClearQueue(SqQueue &Sq)
{
    cout << "Clear Queue ..." << endl;
    Sq.front = 0;
    Sq.rear = 0;
    Sq.count = 0;
    return true;
}

bool QueueEmpty(SqQueue &Sq)
{
    return Sq.count == 0; /* 队列空的标志 */
}

bool QueueFull(SqQueue &Sq)
{
    return Sq.count == MAXSIZE;
}

int QueueLength(SqQueue &Sq)
{
    if (QueueFull(Sq))
        return MAXSIZE;

/* 队列的当前长度 */
    return (Sq.rear - Sq.front + MAXSIZE) % MAXSIZE;
}
/* 返回头元素 */
bool GetHead(SqQueue &Sq, ElemType *pe)
{
    if (QueueEmpty(Sq))
        return false;
    else
    {
        *pe = Sq.data[Sq.front];
        cout << "Get Head Item " << *pe << endl;
        return true;
    }
}

bool EnQueue(SqQueue &Sq, ElemType Elem)
{
    /* 队列满 */
    if (QueueLength(Sq) == MAXSIZE)
        return false;
    cout << "EnQueue Item " << Elem << endl;
    Sq.data[Sq.rear] = Elem;/* 将元素赋值给队尾 */
    Sq.rear = (Sq.rear + 1) % MAXSIZE;/* rear指针向后移一位置， */
    /* 若到最后则转到数组头部 */
    Sq.count++;
    return true;
}

bool DeQueue(SqQueue &Sq, ElemType *pe)
{
    if (QueueEmpty(Sq))
        return false;
    *pe = Sq.data[Sq.front];/* 将队头元素赋值给*pe */
    cout << "DeQueue Item " << *pe << endl;
    Sq.front = (Sq.front + 1) % MAXSIZE;/* front指针向后移一位置， */
    /* 若到最后则转到数组头部 */

Sq.count--;
    return true;
}

bool QueueTraverse(SqQueue &Sq)
{
    if (QueueEmpty(Sq))
    {
        cout << "Queue is empty" << endl;
        return false;
    }

cout << "Queue Traverse ..." << endl;
    for (int i = 0;  i < Sq.count; i++)
        cout << Sq.data[i + Sq.front] << ‘ ‘;
    cout << endl;
    return true;
}

int main(void)
{
    SqQueue Sq;
    InitQueue(Sq);
    for (int i = 0; i < 20; i++)
        EnQueue(Sq, i);
    QueueTraverse(Sq);
    if (!QueueEmpty(Sq))
        cout << "Queue Length: " << QueueLength(Sq) << endl;
    int result;
    GetHead(Sq, &result);
    DeQueue(Sq, &result);
    DeQueue(Sq, &result);
    if (!QueueEmpty(Sq))
        cout << "Queue Length: " << QueueLength(Sq) << endl;
    QueueTraverse(Sq);

return 0;
}

输出为：

单是顺序存储，若不是循环队列，算法的时间性能是不高的，但循环队列也面临着数组可能溢出的问题。

注：上述用 Use a fill count to distinguish the two cases. 的方法实现循环队列。常用的还有 Always keep one slot open. 也就是多申请一个不用的元素

位置，那么判断满时  (cb->end + 1) % cb->size == cb->start;  判断空时 cb->end == cb->start;

参考：

《大话数据结构》

《Data Structures》

时间： 2024-10-25 00:08:25

数据结构：队列的顺序存储结构【转】的相关文章

数据结构 - 队列静态顺序存储结构

队列的基本概念 1 队列的基本概念 队列(Queue):也是运算受限的线性表.是一种先进先出(First In First Out ,简称FIFO)的线性表.只允许在表的一端进行插入,而在另一端进行删除. 队首(front) :允许进行删除的一端称为队首. 队尾(rear) :允许进行插入的一端称为队尾. 例如:排队购物.操作系统中的作业排队.先进入队列的成员总是先离开队列. 队列中没有元素时称为空队列.在空队列中依次加入元素a1, a2, -, an之后,a1是队首元素,an是队尾元素.显然退

队列的顺序存储结构和链式存储结构

队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表(在队尾进行插入操作,在对头进行删除操作). 与栈相反,队列是一种先进先出(First In First Out, FIFO)的线性表. 与栈相同的是,队列也是一种重要的线性结构,实现一个队列同样需要顺序表或链表作为基础. 队列的链式存储结构 队列既可以用链表实现,也可以用顺序表实现.跟栈相反的是,栈一般我们用顺序表来实现,而队列我们常用链表来实现,简称为链队列. typedef struct QNode { ElemT

队列（顺序存储结构）

队列:具有一定操作约束的线性表,只能在一端作插入.删除,与堆栈类似 具有先入先出的特性(First In First Out) 同理,分顺序存储结构.链式存储结构两种形式 队列(顺序存储结构) 通常由一个一维数组和一个队列头元素变量front和一个队列尾元素变量rear组成 加入一个元素rear加1,删除一个元素front加1 空的时候front=rear,但是填满时front/rear也相等,这时便不利于区分:为此通常采用加1求余的方式,同时构成循环队列 1)判断是否为空:front == r

队列的顺序存储结构

还是直接上代码 package com.sbtufss.test; import java.util.Arrays; /** * 所谓的顺序存储结构,实际上就是用数组来存储队列的元素 * @author sbtufss * */ public class ArrayQueue<T> { private int tLenght=3;//数组的大小,或者每次增加的大小 //初始化能存放tLenght个元素的数组 private Object[] t=new Object[tLenght]; pri

数据结构(03)_顺序存储结构线性表

本节我们基于前面实现的数据结构类模板基础,继续完成基于顺序存储结构的线性表的实现,话不多说,继承关系图如下: 14.线性表的本质和操作 14.1.线性表的表现形式 零个多多个数据元素组成的集合 数据元素在位置上是有序排列的 数据元素的个数是有限的 数据元素的类型必须相同 14.2.线性表的抽象定义.性质 线性表是具有相同类型的n(>=)个数据元素的有限序列,(a0, a1, a2... an-1),其中ai是表项,n是表长度.性质: a0为线性表的第一个元素,只有一个后继 an-1为线性表的最后

数据结构——线性表顺序存储结构

 关于线性表 线性表是零个或者多个数据元素的集合.它主要有以下三个特征: 1:线性表的数据元素之间是有顺序的. 2:线性表中数据元素个数是有限的. 3:线性表中数据元素数据类型是相同的. 关于线性表的操作,主要有 创建线性表.销毁线性表.清空线性表.将元素插入线性表.将元素从线性表中删除.获取线性表中某个位置的元素.获取线性表的长度. 线性表主要有两种存储结构: 1:线性表的顺序存储结构,c语言中的数组及采用这种方式. 2:线性表的链式存储结构. 关于顺序存储结构 定义: 是指用一段地址连续的内

数据结构 - 线性表顺序存储结构

线性表 线性表是一种典型的线性结构.其基本特点是线性表中的数据元素是有序且是有限的.在这种结构中: ① 存在一个唯一的被称为"第一个"的数据元素: ② 存在一个唯一的被称为"最后一个"的数据元素: ③ 除第一个元素外,每个元素均有唯一一个直接前驱: ④ 除最后一个元素外,每个元素均有唯一一个直接后继. 线性表(Linear List) :是由n(n≧0)个数据元素(结点)a1,a2, -an组成的有限序列.该序列中的所有结点具有相同的数据类型. 线性表中的数据元素

数据结构|-完全二叉树的顺序存储结构的实现

对于一个完全二叉树,假设它有n个结点,对结点进行从1开始编号,对任一结点i满足下面 它的双亲是结点 i/2 (除了i=1的情况) 左孩子是 2i 右孩子是 2i+1 如果2i>n 说明无左孩子 2i+1>n 说明无右孩子 一般的树来说是一对多的关系,使用顺序结构存储起来比较困难,但是二叉树是一种特殊的树,每个结点最多有两个子节点,并且子节点有左右之分,并且兄弟,父亲,孩子可以很方便的通过编号得到,所以我们使用顺序存储结构使用二叉树的存储. using System; using System.

队列的顺序存储结构（循环队列）（C语言实现）

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 #define OK 1 5 #define ERR 2 6 #define TRUE 1 7 #define FALSE 0 8 #define MAXSIZE 4 //定义队列的最大长度 9 10 typedef int status; //定义函数返回的状态,OK & ERR 11 typedef char datatype; //定义队列中每个元素的数据类型,这里暂定为字符