数据结构专题之队列

最新推荐文章于 2022-08-12 11:04:45 发布
最新推荐文章于 2022-08-12 11:04:45 发布
阅读量271 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hetengjiao523/article/details/103006637
版权

介绍

在数组中，可以通过索引访问随机元素。
在队列和栈中，可以顺序处理数据

队列：先入先出的数据结构

先入先出的数据结构（FIFO）

在这里插入图片描述
在先入先出数据结构中，将首先处理添加到队列中的第一个元素
队列是典型的先入先出数据结构。插入操作也称为入队，新元素始终被添加在队列的末尾，删除操作也称为出队，只能移除第一个元素

入队

在这里插入图片描述

出队

在这里插入图片描述

队列的实现
动态数组和头索引

为了实现队列，可以使用动态数组和指向队列头部的索引。

如上所述，队列应支持两种操作：入队和出队。入队会向队列追加一个新元素，而出队会删除第一个元素。 所以需要一个索引来指出起点。

C++实现
#include <iostream>

class MyQueue {
    private:
        // store elements
        vector<int> data;       
        // a pointer to indicate the start position
        int p_start;            
    public:
        MyQueue() {p_start = 0;}
        /** Insert an element into the queue. Return true if the operation is successful. */
        bool enQueue(int x) {
            data.push_back(x);
            return true;
        }
        /** Delete an element from the queue. Return true if the operation is successful. */
        bool deQueue() {
            if (isEmpty()) {
                return false;
            }
            p_start++;
            return true;
        };
        /** Get the front item from the queue. */
        int Front() {
            return data[p_start];
        };
        /** Checks whether the queue is empty or not. */
        bool isEmpty()  {
            return p_start >= data.size();
        }
};

int main() {
    MyQueue q;
    q.enQueue(5);
    q.enQueue(3);
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
    q.deQueue();
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
    q.deQueue();
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
}
Java实现
class MyQueue {
	// store elements
	private List<Integer> data;
	// a pointer to indicate the start position
	private int p_start;

	public MyQueue() {
		data = new ArrayList<>();
		p_start = 0;
	}

	/** Insert an element into the queue. Return true if the operation is successful. */
	public boolean enQueue(int x) {
		data.add(x);
		return true;
	}

	/** Delete an element from the queue. Return true if the operation is successful. */
	public boolean deQueue() {
		if (isEmpty()) {
			return false;
		}
		p_start++;
		return true;
	}

	/** Get the front item from the queue. */
	public int Front() {
		return data.get(p_start);
	}

	/** Checks whether the queue is empty or not. */
	public boolean isEmpty() {
		return p_start >= data.size();
	}
}
循环队列

使用动态数组和指向头部的索引来实现队列很简单，但在某些情况下效率很低。 随着起始指针的移动，浪费了越来越多的空间。 当我们有空间限制时，这将是难以接受的。
让我们考虑一种情况，即我们只能分配一个最大长度为 5 的数组。当我们只添加少于 5 个元素时，我们的解决方案很有效。 例如，如果我们只调用入队函数四次后还想要将元素 10 入队，那么我们可以成功。

但是我们不能接受更多的入队请求，这是合理的，因为现在队列已经满了。但是如果我们将一个元素出队呢？
实际上，在这种情况下，我们应该能够再接受一个元素。
在这里插入图片描述
因此，可以使用固定大小的数组和两个指针来指示起始位置和结束位置。 目的是重用之前提到的被浪费的存储。

在循环队列中，我们使用一个数组和两个指针（head 和 tail）。 head 表示队列的起始位置，tail 表示队列的结束位置。

C++实现
class MyCircularQueue {
private:
    vector<int> data;
    int head;
    int tail;
    int size;
public:
    /** Initialize your data structure here. Set the size of the queue to be k. */
    MyCircularQueue(int k) {
        data.resize(k);
        head = -1;
        tail = -1;
        size = k;
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    bool enQueue(int value) {
        if (isFull()) {
            return false;
        }
        if (isEmpty()) {
            head = 0;
        }
        tail = (tail + 1) % size;
        data[tail] = value;
        return true;
    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    bool deQueue() {
        if (isEmpty()) {
            return false;
        }
        if (head == tail) {
            head = -1;
            tail = -1;
            return true;
        }
        head = (head + 1) % size;
        return true;
    }
    
    /** Get the front item from the queue. */
    int Front() {
        if (isEmpty()) {
            return -1;
        }
        return data[head];
    }
    
    /** Get the last item from the queue. */
    int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return data[tail];
    }
    
    /** Checks whether the circular queue is empty or not. */
    bool isEmpty() {
        return head == -1;
    }
    
    /** Checks whether the circular queue is full or not. */
    bool isFull() {
        return ((tail + 1) % size) == head;
    }
};

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * bool param_1 = obj.enQueue(value);
 * bool param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * bool param_5 = obj.isEmpty();
 * bool param_6 = obj.isFull();
 */
Java实现
class MyCircularQueue {
    private int[] data;
    private int head;
    private int tail;
    private int size;
    
    /** Initialize your data structure here. Set the size of the queue to be k. */
    public MyCircularQueue(int k) {
        data = new int[k];
        head = -1;
        tail = -1;
        size = k;
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    public boolean enQueue(int value) {
        if(isFull()) {
            return false;
        }
        if(isEmpty()) {
            head = 0;
        }
        tail = (tail + 1) % size;
        data[tail] = value;
        return true;
    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    public boolean deQueue() {
        if(isEmpty()) {
            return false;
        }
        if(head == tail) {
            head = -1;
            tail = -1;
            return true;
        }
        head = (head + 1) % size;
        return true;
    }
    
    /** Get the front item from the queue. */
    public int Front() {
        if(isEmpty()) {
            return -1;
        }
        return data[head];
    }
    
    /** Get the last item from the queue. */
    public int Rear() {
        if(isEmpty()) {
            return -1;
        }
        return data[tail];
    }
    
    /** Checks whether the circular queue is empty or not. */
    public boolean isEmpty() {
        return head == -1;
    }
    
    /** Checks whether the circular queue is full or not. */
    public boolean isFull() {
        return (tail + 1) % size == head;
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * boolean param_1 = obj.enQueue(value);
 * boolean param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * boolean param_5 = obj.isEmpty();
 * boolean param_6 = obj.isFull();
 */
队列的应用

大多数流行语言都提供内置的队列库，因此我们无需重新发明轮子。
队列有两个重要的操作，入队和出队。
下面贴出内置队列库及其常见操作的一些示例：

C++
#include <iostream>

int main() {
    // 1. Initialize a queue.
    queue<int> q;
    // 2. Push new element.
    q.push(5);
    q.push(13);
    q.push(8);
    q.push(6);
    // 3. Check if queue is empty.
    if (q.empty()) {
        cout << "Queue is empty!" << endl;
        return 0;
    }
    // 4. Pop an element.
    q.pop();
    // 5. Get the first element.
    cout << "The first element is: " << q.front() << endl;
    // 6. Get the last element.
    cout << "The last element is: " << q.back() << endl;
    // 7. Get the size of the queue.
    cout << "The size is: " << q.size() << endl;
}
Java
// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        // 1. Initialize a queue.
        Queue<Integer> q = new LinkedList();
        // 2. Get the first element - return null if queue is empty.
        System.out.println("The first element is: " + q.peek());
        // 3. Push new element.
        q.offer(5);
        q.offer(13);
        q.offer(8);
        q.offer(6);
        // 4. Pop an element.
        q.poll();
        // 5. Get the first element.
        System.out.println("The first element is: " + q.peek());
        // 7. Get the size of the queue.
        System.out.println("The size is: " + q.size());
    }
}
队列和广度优先搜索
概述

广度优先搜索（BFS）的一个常见应用是找出从根结点到目标结点的最短路径
在这里插入图片描述

  • 结点的处理顺序
    第一轮中，处理根结点
    第二轮中，处理根结点旁边的结点
    第三轮中，处理距离根结点两步的结点

    与树的层序遍历类似，越是接近根结点的结点将越早地遍历
    如果在第 k 轮中将结点 x 添加到队列中，则根结点与 x 之间的最短路径的长度恰好是 k。也就是说，第一次找到目标结点时，已经处于最短路径中。

  • 队列的入栈和出栈顺序
    如上面的动画所示，我们首先将根结点排入队列。然后在每一轮中，我们逐个处理已经在队列中的结点，并将所有邻居添加到队列中。值得注意的是，新添加的节点不会立即遍历，而是在下一轮中处理。

    结点的处理顺序与它们添加到队列的顺序是完全相同的顺序，即先进先出（FIFO）。这就是我们在 BFS 中使用队列的原因。

广度优先搜索模板

使用 BFS 的两个主要方案：遍历或找出最短路径

在特定问题中执行 BFS 之前确定结点和边缘非常重要。通常，结点将是实际结点或是状态，而边缘将是实际边缘或可能的转换。

模板一
/**
 * Return the length of the shortest path between root and target node.
 */
int BFS(Node root, Node target) {
    Queue<Node> queue;  // store all nodes which are waiting to be processed
    int step = 0;       // number of steps neeeded from root to current node
    // initialize
    add root to queue;
    // BFS
    while (queue is not empty) {
        step = step + 1;
        // iterate the nodes which are already in the queue
        int size = queue.size();
        for (int i = 0; i < size; ++i) {
            Node cur = the first node in queue;
            return step if cur is target;
            for (Node next : the neighbors of cur) {
                add next to queue;
            }
            remove the first node from queue;
        }
    }
    return -1;          // there is no path from root to target
}
  1. 如代码所示，在每一轮中，队列中的结点是等待处理的结点。
  2. 在每个更外一层的 while 循环之后，我们距离根结点更远一步。变量 step 指示从根结点到我们正在访问的当前结点的距离。
模板二

有时，确保我们永远不会访问一个结点两次很重要。否则，我们可能陷入无限循环。如果是这样，我们可以在上面的代码中添加一个哈希集来解决这个问题。这是修改后的伪代码：

/**
 * Return the length of the shortest path between root and target node.
 */
int BFS(Node root, Node target) {
    Queue<Node> queue;  // store all nodes which are waiting to be processed
    Set<Node> used;     // store all the used nodes
    int step = 0;       // number of steps neeeded from root to current node
    // initialize
    add root to queue;
    add root to used;
    // BFS
    while (queue is not empty) {
        step = step + 1;
        // iterate the nodes which are already in the queue
        int size = queue.size();
        for (int i = 0; i < size; ++i) {
            Node cur = the first node in queue;
            return step if cur is target;
            for (Node next : the neighbors of cur) {
                if (next is not in used) {
                    add next to queue;
                    add next to used;
                }
            }
            remove the first node from queue;
        }
    }
    return -1;          // there is no path from root to target
}

有两种情况你不需要使用哈希集：

  1. 你完全确定没有循环，例如，在树遍历中；
  2. 你确实希望多次将结点添加到队列中。
资深糖分大叔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之队列
无心的博客
02-01 644
文章来源：http://blog.seclibs.com/数据结构之队列/ 上一篇文章说了一种“功能受限”的顺序表——栈，现在再来说一个 “功能受限”的顺序表 ——队列（queue）。 队列也是一个常用的数据结构，在大部分资源有限的情况下，当没有空闲资源的时候，基本上都是使用队列这种数据结构来实现请求排队的。 队列，顾名思义，就是排的一条队，比如在买票的时候排的一条队伍，先来的先买，后来的后买，不...
数据结构——队列
jishublog
07-30 84
概述 队列：只允许在一段进行插入删除操作，而在另一端进行删除操作的线性表。 队列是一种先进先出(FIFO)的线性表，允许插入的一端为队尾，允许插入的一端为队头。 循环队列 头尾相接的顺序存储结构为循环队列。 为防止溢出，通常保留一个空闲单元在队满时。 队满的条件： (队尾 + 1) %队列长度 = 队头 通用的队长值为： (队尾 - 队头 + 队列长度) % 队列...
数据结构-使用javascript讲解数据结构之队列.zip
最新发布
02-12
在这个专题中，我们重点关注的是使用JavaScript语言来讲解的数据结构之一：队列。队列是一种线性数据结构，其操作特性类似于现实生活中的排队等候，遵循“先进先出”（FIFO）的原则。 在JavaScript中，队列可以通过...
数据结构严蔚敏宣讲专题培训课件.ppt
12-21
严蔚敏教授的专题培训课件主要涵盖了数据结构的基本概念、逻辑结构、存储方式以及与其相关的编程考虑。 首先，数据结构是关于数据的组织方式，它是解决问题的基础。在计算机科学中，数据结构不仅仅是关于数据的简单...
专题3-简单数据结构1
08-08
在本专题中，我们探讨了三个基于简单数据结构的编程问题，涉及到链表、队列和栈。以下是这些问题的详细解析： 1. **链表合并与排序**： 题目要求将两个链表合并并进行排序。这里虽然没有直接使用链表结构，但可以...
数据结构专题
09-26
本专题涵盖了数据结构的基础知识，系统地讲解了多种重要数据结构及其应用，非常适合初学者和教育者作为学习与教学资源。 1. **线性表**（DS-Ch2-线性表.ppt）：线性表是最基础的数据结构，它由相同类型的元素按线性...
数据结构面试专题.docx
11-15
- **队列**：是先进先出（FIFO）的数据结构，通常用于多线程环境中的任务调度。 - **链表**：非连续存储，通过指针连接元素，支持高效插入和删除，但查找效率相对较低。 - **树**：包括二叉树、红黑树、B+树等，...
数据结构 队列
不远远方
03-10 162
1、核心思想： 类似于栈，不同的是队列中第一个插入的数据项会最先移除，即先进先出。 队头取数据，队尾存数据。 2、实现队列 public class TestQueue { public static void main(String[] args) { Queue queue=new Queue(5); System.out.println(q...
数据结构-队列
littesss的博客
06-15 552
一.顺序队列SeqQueue 1.顺序队列结构类型的成员：ElemType * base 、int front、int rear、size_t capacity,分别是base指针，头位置，尾位置，容量。和顺序表操作大致一样，只不过队列只能尾部插入，头部删除，只能使用一次，没多大的实际意义。 2.顺序队列的结构类型表示 3，出栈只需front++； 4.清理和摧毁函数
数据结构： 队列
小键233
02-10 373
声明：本文为学习数据结构与算法分析(第三版) Clifford A.Shaffer 著的学习笔记，代码有参考该书的示例代码。 队列队列是一种受限制的线性表。 队列元素只能从队尾插入（称为入队 ，enqueue），只能从队首删除（称为出队，dequeue）。由于队列的特性，队列被称为“FIFO”线性表（先进先出） 队列的实现可以有两种方式，即顺序队列和链式队列。 队列的ADT如下：templat
数据结构 -- 队列
sdjn_lyn的博客
02-04 168
队列也是一种特殊的线性表，特殊在于只允许在一端插入元素，在另一端删除元素，所以队列有先进先出的特性 队列的可以分为普通队列和带有优先级的队列 术语 队头：允许删除元素的一端 队尾：允许插入元素的一端 入队：向队列中插入元素操作 出队：从队列中删除元素操作 普通队列 #ifndef QUEUE_H_ #define QUEUE_H_ #include <tools/base/noncopya...
数据结构_队列
weixin_43853178的博客
08-12 771
队列类似于日常生活中的排队，它也是一种特殊的线性表。队列和栈有相反的逻辑，但是却属于同类结构。
数据结构——队列操作
AYuan for Java
01-04 114
线性表 /*q.f中的数据域不存内容，q.rear的数据域中是有内容的*/ #include<stdio.h> #include<stdlib.h> typedef struct Node{ int data; struct Node *next; }Node; typedef struct Queue{ Node *f,*r; }Q; void init(Q *q)...
数据结构队列的各种操作
umgsai的专栏
08-10 506
#include"stdio.h"  #include"stdlib.h"  typedef int ElementType;  typedef struct Queue  {      int rear,front;      ElementType *elements;      int MaxSize;  }Queue;  void InitQueue(Queue *Q,int sz)//初
数据结构——栈(Stack)和队列(Queue)
_Y__X_的博客
01-07 517
文章目录栈和队列1.栈的定义1.1栈的顺序存储结构1.2基于动态数组实现的顺序栈2.队列的定义2.1队列的链式存储结构2.2基于单链表实现的链队列 栈和队列 1.栈的定义 栈(stack)是限定仅在表尾进行插入和删除操作的线性表。 我们把允许数据插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，不含任何数据元素的栈称为空栈。栈又称为后进先出(Last In First Out)的线性表。 1.1栈的顺序存储结构 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组
cspj数据结构专题
08-17
关于CSPJ数据结构专题，我可以为您提供一些相关的信息。CSPJ（C/C++ Software Professional Junior）是由CSDN开发的一套C/C++软件工程师认证考试体系。在数据结构专题方面，CSPJ可能涉及到以下内容： 1. 线性表：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值