数据结构与算法-----队列篇

队列

1.基本特征:先进先出

2.基本操作:从后端(rear)压入(push),从前端(front)弹出(pop)

3.实现要点:初始化空间、从后端指针压入,从前端指针弹出, 循环使用,判空判满

实践1

:使用C++语言实现队列类并进行数据示例演示

#include <iostream>
using namespace std;
class Queue {
public:
    // 构造函数中分配内存空间
    Queue (size_t size) :
        m_data (new int[size]), m_size (size),
        m_rear (0), m_front (0), m_count (0) {}
    // 析构函数中释放内存空间
    ~Queue (void) {
        if (m_data) {
            delete[] m_data;
            m_data = NULL;
        }
    }
    // 压入
    void push (int data) {
        if (full ())
            throw OverFlow ();
        if (m_rear >= m_size)
            m_rear = 0;
        m_count++;
        m_data[m_rear++] = data;
    }
    // 弹出
    int pop (void) {
        if (empty ())
            throw UnderFlow ();
        if (m_front >= m_size)
            m_front = 0;
        m_count--;
        return m_data[m_front++];
    }
    // 判空
    bool empty (void) {
        return ! m_count;
    }
    // 判满
    bool full (void) {
        return m_count >= m_size;
    }
private:
    // 上溢异常
    class OverFlow : public exception {
    public:
        const char* what (void) const throw () {
            return "队列上溢!";
        }
    };
    // 下溢异常
    class UnderFlow : public exception {
    public:
        const char* what (void) const throw () {
            return "队列下溢!";
        }
    };
    int*   m_data;  // 数组
    size_t m_size;  // 容量
    size_t m_rear;  // 后端
    size_t m_front; // 前端
    size_t m_count; // 计数
};
int main (void) {
    try {
        Queue queue (5);
        queue.push (10);
        queue.push (20);
        queue.push (30);
        queue.push (40);
        queue.push (50);
//      queue.push (60);
        cout << queue.pop () << endl; // 10
        queue.push (60);
        cout << queue.pop () << endl; // 20
        cout << queue.pop () << endl; // 30
        queue.push (70);
        queue.push (80);
        cout << queue.pop () << endl; // 40
        cout << queue.pop () << endl; // 50
        cout << queue.pop () << endl; // 60
        while (! queue.empty ())
            cout << queue.pop () << endl;
//      queue.pop ();
    }
    catch (exception& ex) {
        cout << ex.what () << endl;
        return -1;
    }
    return 0;
}

输出结果

实践2

:借用本博客目录【数据结构与算法】分类中博文《数据结构与算法—–堆栈篇》中的Stack类实现队列类并进行数据示例演示

#include <iostream>
using namespace std;
class Stack {
public:
    // 构造函数中分配内存空间
    Stack (size_t size = 10) :
        m_data (new int[size]), m_size (size),
        m_top (0) {}
    // 析构函数中释放内存空间
    ~Stack (void) {
        if (m_data) {
            delete[] m_data;
            m_data = NULL;
        }
    }
    // 压入
    void push (int data) {
        if (full ())
            throw OverFlow ();
        m_data[m_top++] = data;
    }
    // 弹出
    int pop (void) {
        if (empty ())
            throw UnderFlow ();
        return m_data[--m_top];
    }
    // 判空
    bool empty (void) {
        return ! m_top;
    }
    // 判满
    bool full (void) {
        return m_top >= m_size;
    }
private:
    // 上溢异常
    class OverFlow : public exception {
    public:
        const char* what (void) const throw () {
            return "堆栈上溢!";
        }
    };
    // 下溢异常
    class UnderFlow : public exception {
    public:
        const char* what (void) const throw () {
            return "堆栈下溢!";
        }
    };
    int*   m_data; // 数组
    size_t m_size; // 容量
    size_t m_top;  // 栈顶
};
class Queue {
public:
    Queue (size_t size) :
        m_stack1 (size), m_stack2 (size) {}
    void push (int data) {
        m_stack1.push (data);
    }
    int pop (void) {
        if (m_stack2.empty ())
            while (! m_stack1.empty ())
                m_stack2.push (m_stack1.pop ());
        return m_stack2.pop ();
    }
    bool empty (void) {
        return m_stack1.empty() && m_stack2.empty();
    }
    bool full (void) {
        return m_stack1.full ();
    }
private:
    Stack m_stack1;
    Stack m_stack2;
};
int main (void) {
    try {
        Queue queue (10);
        for (int i = 0; ! queue.full (); i++)
            queue.push (i);
//      queue.push (10);
        while (! queue.empty ())
            cout << queue.pop () << endl;
//      queue.pop ();
    }
    catch (exception& ex) {
        cout << ex.what () << endl;
        return -1;
    }
    return 0;
}

输出结果:

时间: 2024-10-09 22:50:40

数据结构与算法-----队列篇的相关文章

javascript数据结构与算法---队列

队列是一种列表,不同的是队列只能在队尾插入元素,在队首删除元素.队列用于存储按顺序排列的数据,先进先出,这点和栈不一样(后入先出).在栈中,最后入栈的元素反而被优先处理.我们现在可以把队列想象对我们去餐馆吃饭的情景,很多人排队吃饭,排在最前面的人先打饭.新来的人只能在后面排队.直到轮到他们为止. 一:对队列的操作 队列有2种主要的操作,向队尾中插入新元素enqueue()方法和删除队列中的队首的元素的dequeue()方法,另外我们还有一个读取队头的元素,这个方法我们可以叫front()方法.该

JavaScript数据结构和算法----队列

前言 队列和栈很像,只是用了不同的原则.队列是遵循先进先出(FIFO)原则的一组有序的的项,队列在尾部添加新元素,从顶部移除元素.最新添加的元素必须必须排队在队列的,末尾.可以想象食堂排队买饭的样子. 一.创建队列 1.创建一种数据结构来保存队列里面的数据,这里选择数组 2.声明一些栈的方法 enqueue(element(s)) : 添加一个或一些元素到队列的末尾 dequeue() : 移除队列第一个的元素(就是排队在最前面的),同时返回被移除的元素. front() : 返回队列第一个的元

数据结构与算法-----总结篇

一.数据结构 程序设计=数据结构+算法 1.逻辑结构 1)集合:元素之间没有联系. 2)线性结构:元素之间存在前后顺序. 3)树形结构:元素之间存在一对多的父子关系. 4)图状结构:元素之间存在多对多的映射关系. 2.物理结构 1)顺序结构:用连续的空间存放数据元素. 优点:便于随机访问. 缺点:空间利用率低,插入删除不方便. 2)链式结构:用不连续的空间存放数据元素,每个数据元素中处理存放数据意外,还要存放下一个元素的地址. 优点:空间利用率高,插入删除方便. 缺点:随机访问不方便. 3.逻辑

python数据结构与算法——队列

队列结构可以使用数组来模拟,只需要设定头和尾的两个标记 参考自<啊哈> 1 # 按书中的代码会出现索引越界的问题(书中申请了超量的空间) 2 # 尝试令tai初始为len(q)-1则不会出错但少了最后一位 3 # 通过异常处理,捕获出界异常则直接跳出循环 4 def queue_demo1(q): 5 newq = [] 6 head = 0 7 tail = len(q) # 记录队列最后一位 8 9 while head < tail : 10 newq.append(q[head]

16. C#数据结构与算法 -- 队列

什么是队列,所谓的队列是队列(Queue)是插入操作限定在表的尾部而其它操作限定在表的头部进行的,线性表.把进行插入操作的表尾称为队尾(Rear),把进行其它操作的头部称为队头(Front).当对列中没有数据元素时称为空对列(Empty Queue).队列通常记为:Q= (a1,a2,-,an),Q是英文单词queue的第 1 个字母.a1为队头元素,an为队尾元素.这n个元素是按照a1,a2,-,an的次序依次入队的,出对的次序与入队相同,a1第一个出队,an最后一个出队.所以,对列的操作是按

[数据结构与算法] : 队列

头文件 1 typedef int ElementType; 2 3 #ifndef _QUEUE_H_ 4 #define _QUEUE_H_ 5 6 struct QueueRecord; 7 typedef struct QueueRecord *Queue; 8 9 int IsEmpty(Queue Q); 10 int IsFull(Queue Q); 11 Queue CreateQueue(int MaxElements); 12 void DisposeQueue(Queue

js数据结构与算法——队列

<script> //创建一个队列 function Queue(){ let items = []; //向队尾添加一个新的项 this.enqueue = function(element){ items.push(element) } //移除队列第一个项,并返回被移除的元素 dequeue this.dequeue = function(){ return items.shift(); } this.front = function(){ return items[0]; } this

数据结构与算法-----链表篇

链表 1.基本特征:由一系列内存中不连续的节点组成,每个节点除了保存数据以外,还需要保存其前后节点的地址--双向链表. 2.基本操作 1)追加 2)插入 3)删除 4)遍历 5)伪随机访问 示例:使用C++实现双向链表类,并演示结果: #include <iostream> using namespace std; class List { public: // 构造函数中初始化为空链表 List (void) : m_head (NULL), m_tail (NULL) {} // 析构函数

数据结构与算法-----堆栈篇

堆栈 1.基本特征:后进先出 2.基本操作:压入(push),弹出(pop) 3.实现要点:初始化空间.栈顶指针.判空判满 实践:使用C++语言实现堆栈类,进行示例演示并且根据此堆栈类实现进制的转换. #include <iostream> using namespace std; class Stack { public: // 构造函数中分配内存空间 Stack (size_t size = 10) : m_data (new int[size]), m_size (size), m_to