精华内容
下载资源
问答
  • 2019-03-13 18:57:53

    在这里插入图片描述

    更多相关内容
  • 队列图解

    2019-09-13 15:06:46
    转载于:https://my.oschina.net/architectliuyuanyuan/blog/3061330

    84f247c2793bf737afd23f129d82b205899.jpg

    f30642a7d54eab5dcc517efceba23935887.jpg

    转载于:https://my.oschina.net/architectliuyuanyuan/blog/3061330

    展开全文
  • 队列的一个使用场景 银行排队的案例: 队列介绍 队列是一个有序列表,可以用数组或是链表来实现。 遵循先入先出的原则。即:先存入队列的数据,要先取出。后存入的要后取出 示意图:(使用数组模拟队列示意图) 数组...

    队列的一个使用场景

    银行排队的案例:
    在这里插入图片描述

    队列介绍

    队列是一个有序列表,可以用数组或是链表来实现。
    遵循先入先出的原则。即:先存入队列的数据,要先取出。后存入的要后取出
    示意图:(使用数组模拟队列示意图)
    在这里插入图片描述

    数组模拟队列

    队列本身是有序列表,若使用数组的结构来存储队列的数据,则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。

    因为队列的输出、输入是分别从前后端来处理,因此需要两个变量 front及 rear分别记录队列前后端的下标,front 会随着数据输出而改变,而 rear则是随着数据输入而改变,如图所示:
    在这里插入图片描述

    当我们将数据存入队列时称为”addQueue”,addQueue 的处理需要有两个步骤:思路分析
    将尾指针往后移:rear+1 , 当front == rear 【空】
    若尾指针 rear 小于队列的最大下标 maxSize-1,则将数据存入 rear所指的数组元素中,否则无法存入数据。
    rear == maxSize - 1[队列满]

    代码实现
    问题分析并优化

    class ArrayQueue(arrMaxSize: Int) { val maxSize: Int = arrMaxSize
      val array = new Array[Int](arrMaxSize)
      var front: Int = -1
      var rear: Int = -1
    }
     //初始化
     val queue = new ArrayQueue(3)
    
    rear 是队列最后[含]
    front 是队列最前元素[不含]
    

    数组模拟队列

    出队列操作getQueue
    显示队列的情况showQueue
    查看队列头元素headQueue
    退出系统exit

    将原来的队列的查看队列头元素的代码写完.

    数组模拟环形队列

    对前面的数组模拟队列的优化,充分利用数组. 因此将数组看做是一个环形的。(通过取模的方式来实现即可)

    分析说明:
    尾索引的下一个为头索引时表示队列满,即将队列容量空出一个作为约定,这个在做判断队列满的时候需要注意 (rear + 1) % maxSize == front 满]
    rear == front [空]

    (cq.rear + cq.maxSize – cq.front) % cq.maxSize

    class CircleQueue {
      private int maxSize;
      private int[] arr; // 该数组存放数据,模拟队列
      private int front; // 指向队列头部
      private int rear; // 指向队列的尾部
      public CircleArrayQueue(int arrMaxSize) {
      	maxSize = arrMaxSize;
    	arr = new int[maxSize];
       } 
      public boolean isFull()  {
        //尾索引的下一个为头索引时表示队列满,即将队列容量空出一个作为约定(!!!)
        return (rear + 1) % maxSize == front; }
      public boolean isEmpty()  {
        this.tail == this.head }
    
       public void addQueue(int n) {
       if (isFull()) {
    	System.out.println("队列满,无法加入..");
    	return;}
    	arr[rear] = n;
    	rear = (rear + 1) % maxSize;}  
        public int getQueue() {
      	if (isEmpty()) {
    		throw new RuntimeException("队列空~");}
    		int value = arr[front];
    		front = (front + 1) % maxSize;
    		return value;}
      //计算队列有多个元素
      public int size()  {
        return (rear + maxSize - front) % maxSize;}}
    

    小结

    队列是有序列表
    front 初始化为-1, 表示队列的头,但是约定不包含头元素, 即指向队列的第一个元素的前一个位置.
    rear 初始化-1, 指向队列尾部,包含最后这个元素
    判断队列空,front == rear 表示空
    判断队列满, rear == maxSize -1

    队列图解

    在这里插入图片描述

    队列代码

    package datastructure
    
    import scala.io.StdIn
    
    /**
      * 环形队列
      * 如果不使用环形队列,则从队列中取出元素时不会释放队列的使用空间
      * @author cherry
      * @create 2019-09-17-22:45
      */
    class CircleArrayQueueDemo(arrMaxSize: Int) {
      val maxSize = arrMaxSize // 指定队列的大小
      val arr = new Array[Int](maxSize) // 队列中数据,存放在数组,即数组模拟队列
      //front 初始化为0, 表示队列的头,指向队列的第一个元素
      var front = 0
      //rear 初始化0, 指向队列最后这个元素的后一个位置
      var rear = 0
    
      //判断队列空
      def isEmpty(): Boolean = rear == front
    
      //判断满
      def isFull(): Boolean = (rear + 1) % maxSize == front
    
      //添加数据到队列
      def addQueue(num: Int): Unit = {
        if (isFull()) {
          println("队列满,不能加入")
          return
        }
        arr(rear) = num
        //将rear 后移
        rear = (rear + 1) % maxSize
      }
    
      //从队列中取出数据, 可能取得数据,可能取不到数据(异常)
      def getQueue(): Any = {
        if (isEmpty()) return new Exception("队列空,没有数据")
        //因为front指向队列的第一个元素
        val res = arr(front) //先将保存到临时变量
        front = (front + 1) % maxSize // front后移
        res //返回临时变量
      }
    
      //遍历显示队列, 动脑筋
      //思路
      // 1. 从front 开始打印,打印多少个元素
      // 2. 所以,需要统计出该队列有多少个有效元素
      def show(): Unit = {
        if (isEmpty()) {
          println("队列空")
          return
        }
        //这里使用%方式解决
        for (i <- front until front + size()) {
          printf("arr(%d)=%d \t", i % maxSize, arr(i % maxSize))
        }
      }
    
      //编写一个方法,统计当前有多少个元素
      def size(): Int = (rear + maxSize - front) % maxSize
    
      //查看队列的头元素,但是不取出
      def peek(): Any = {
        if (isEmpty()) return new Exception("队列空,无数据")
        arr(front) //front 不要动
      }
    
    
    }
    
    object CircleArrayQueueDemo {
      def main(args: Array[String]): Unit = {
        //测试一把
        val queue = new CircleArrayQueueDemo(4)
        //菜单演示
        var key = ""
    
        while (true) {
          print("请选择菜单:show: 显示队列;add : 添加数据;get : 获取数据;peek : 取出数据;exit: 退出程序:")
          println()
          key = StdIn.readLine()
          key match {
            case "show" => queue.show()
            case "add" =>
              println("请输入一个数")
              val num = StdIn.readInt()
              queue.addQueue(num)
            case "get" =>
              //对取回的值,进行判断
              val res = queue.getQueue()
              //如果是异常
              if (res.isInstanceOf[Exception]) {
                println(res.asInstanceOf[Exception].getMessage)
              } else {
                //Int
                printf("队列取出的值=%d", res)
              }
            case "peek" =>
              //查看头元素值,进行判断
              val res = queue.peek()
              //如果是异常
              if (res.isInstanceOf[Exception]) {
                println(res.asInstanceOf[Exception].getMessage)
              } else {
                //Int
                printf("队列当前头元素=%d", res)
              }
    
          }
        }
      }
    }
    

    测试代码
    在这里插入图片描述
    发现从数组队列中取出元素后还能再插入元素

    展开全文
  • title: 数据结构-队列 date: 2019-11-17 20:39:57 tags: 队列 1.应用场景 银行排队案例: 银行有若干窗口,有若干人进行排队,利用环形队列实现一个排队叫号的模拟过程: 2.队列介绍 队列: ​ 队列是一种特殊的...

    title: 数据结构-队列
    date: 2019-11-17 20:39:57
    tags:

    队列

    1.应用场景

    银行排队案例:

    银行有若干窗口,有若干人进行排队,利用环形队列实现一个排队叫号的模拟过程:

    2.队列介绍

    队列

    ​ 队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。

    普通队列没有什么实际的作用

    环形队列

    ​ 在循环队列中,当队列为空时,有front=rear,而当所有队列空间全占时,也有front=rear。为了区别这两种情况,规定循环队列最多只能MaxSize-1个队列元素,当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件时front=rear,而队列判满的条件front=(rear+1)%MaxSize。

    3.思路详解

    1. front指向队列的第一个元素,front的初始值为0,arr[front]就能取出第一个元素。

    2. rear的初值也为0,这样满足环形队列的队空条件

    3. 判断队空的条件:front=rear

    4. 判断队满的条件:front=(rear+1)%MaxSize。 图解:

      这个图是思路精华

    5. 队列中有效数据的个数:(rear +maxSize - front) % maxSize。通过数学一个个情景算算找找规律即可

    4.代码实现(参考尚硅谷)

    import java.util.Scanner;
    
    public class CircleArrayQueueDemo {
    
    	public static void main(String[] args) {
    		
    		//测试一把
    		System.out.println("测试数组模拟环形队列的案例~~~");
    		
    		// 创建一个环形队列
    		CircleArray queue = new CircleArray(4); //说明设置4, 其队列的有效数据最大是3
    		char key = ' '; // 接收用户输入
    		Scanner scanner = new Scanner(System.in);//
    		boolean loop = true;
    		// 输出一个菜单
    		while (loop) {
    			System.out.println("s(show): 显示队列");
    			System.out.println("e(exit): 退出程序");
    			System.out.println("a(add): 添加数据到队列");
    			System.out.println("g(get): 从队列取出数据");
    			System.out.println("h(head): 查看队列头的数据");
    			key = scanner.next().charAt(0);// 接收一个字符
    			switch (key) {
    			case 's':
    				queue.showQueue();
    				break;
    			case 'a':
    				System.out.println("输出一个数");
    				int value = scanner.nextInt();
    				queue.addQueue(value);
    				break;
    			case 'g': // 取出数据
    				try {
    					int res = queue.getQueue();
    					System.out.printf("取出的数据是%d\n", res);
    				} catch (Exception e) {
    					// TODO: handle exception
    					System.out.println(e.getMessage());
    				}
    				break;
    			case 'h': // 查看队列头的数据
    				try {
    					int res = queue.headQueue();
    					System.out.printf("队列头的数据是%d\n", res);
    				} catch (Exception e) {
    					// TODO: handle exception
    					System.out.println(e.getMessage());
    				}
    				break;
    			case 'e': // 退出
    				scanner.close();
    				loop = false;
    				break;
    			default:
    				break;
    			}
    		}
    		System.out.println("程序退出~~");
    	}
    
    }
    
    
    class CircleArray {
    	private int maxSize; // 表示数组的最大容量
    	//front 变量的含义做一个调整: front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素 
    	//front 的初始值 = 0
    	private int front; 
    	//rear 变量的含义做一个调整:rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
    	//rear 的初始值 = 0
    	private int rear; // 队列尾
    	private int[] arr; // 该数据用于存放数据, 模拟队列
    	
    	public CircleArray(int arrMaxSize) {
    		maxSize = arrMaxSize;
    		arr = new int[maxSize];
    	}
    	
    	// 判断队列是否满
    	public boolean isFull() {
    		return (rear  + 1) % maxSize == front;
    	}
    	
    	// 判断队列是否为空
    	public boolean isEmpty() {
    		return rear == front;
    	}
    	
    	// 添加数据到队列
    	public void addQueue(int n) {
    		// 判断队列是否满
    		if (isFull()) {
    			System.out.println("队列满,不能加入数据~");
    			return;
    		}
    		//直接将数据加入
    		arr[rear] = n;
    		//将 rear 后移, 这里必须考虑取模
    		rear = (rear + 1) % maxSize;
    	}
    	
    	// 获取队列的数据, 出队列
    	public int getQueue() {
    		// 判断队列是否空
    		if (isEmpty()) {
    			// 通过抛出异常
    			throw new RuntimeException("队列空,不能取数据");
    		}
    		// 这里需要分析出 front是指向队列的第一个元素
    		// 1. 先把 front 对应的值保留到一个临时变量
    		// 2. 将 front 后移, 考虑取模
    		// 3. 将临时保存的变量返回
    		int value = arr[front];
    		front = (front + 1) % maxSize;
    		return value;
    
    	}
    	
    	// 显示队列的所有数据
    	public void showQueue() {
    		// 遍历
    		if (isEmpty()) {
    			System.out.println("队列空的,没有数据~~");
    			return;
    		}
    		// 思路:从front开始遍历,遍历多少个元素
    		// 动脑筋
    		for (int i = front; i < front + size() ; i++) {
    			System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
    		}
    	}
    	
    	// 求出当前队列有效数据的个数
    	public int size() {
    		// rear = 2
    		// front = 1
    		// maxSize = 3 
    		return (rear + maxSize - front) % maxSize;   
    	}
    	
    	// 显示队列的头数据, 注意不是取出数据
    	public int headQueue() {
    		// 判断
    		if (isEmpty()) {
    			throw new RuntimeException("队列空的,没有数据~~");
    		}
    		return arr[front];
    	}
    }
    
    展开全文
  • 顺序队列与循环队列分别实现,顺序队列的假溢出
  • URLeisure的链队列“完美”复习资料。
  • 07队列,图文讲解极其易懂。

    千次阅读 2021-12-15 17:04:00
    队列 ·相关概念 ·队列图解 队列示意图 常见算法 1. 初始化,入队,出队图解: 2. 假溢出 解决假溢出方法: ·具体实现 队列的顺序表示: 队列的链式表示: 4.队列 ·相关概念 定义:只能在表尾进行插入操作,在表头...
  • 文章目录 循环队列概述(图解) 循环队列的基本操作 1.初始化 2.入队 3.出队 4.查看队头元素 5.队列长度 完整代码 总结 GitHub同步更新(已分类):Data_Structure_And_Algorithm-Review 公众号:URLeisure 的复习...
  • 图解优先队列

    2020-04-20 11:12:15
    优先队列不再遵循传统的队列先进先出的原则 最大优先队列:无论入队顺序如何,都是当前最大的元素优先出队。 最小优先队列:无论入队顺序如何都是当前最小的元素优先出队。 存储结构: 最大优先队列可以用...
  • 分类: 面试 数据结构 2013-03-12 12:...队列的链接存储结构——链队列  图解:     LinkQueue.h [cpp] view plaincopy //LinkQueue.h #ifndef LINKQUEUE_H #define LINKQUEUE_H temp
  • 图解C语言实现队列

    2021-07-10 14:24:23
    由于顺序队列的底层使用的是数组实现,因此要预先申请一块足够大的内存空间初始化队列,此外,遵循队列“先进先出,后进后出(FIFO)”原则,我们还需要定义一个队头指针top,和队尾指针rear,如图一所示。 图 1 顺序...
  • 环形队列的数组实现(Java)和原理详细图解 环形队列可用内存空间为maxSize-1,front指向队列头元素,rear指向队列尾元素后的一个空间。只入队时当front == rear时队列为空,front == rear+1时队列满。 图例 令...
  • 图解数据结构】队列全面总结

    千次阅读 多人点赞 2021-12-18 19:50:18
    定义:队列是允许在一端插入,另一端删除的线性表 队头(front):允许删除的一端 队尾(rear):允许插入的一端 特点:先进先出 三、队列的表示和实现 ...
  • 剑指offer 用两个栈实现队列 图解栈和队列的转换过程【简单易懂,代码可以直接运行】 栈和队列是两种常见的数据结构。栈的特点是先进后出,就像是压弹夹一样,最先压进去的子弹最后才能发出来。队列的特点的是先进先...
  • 数据结构——循环队列(GIF图解

    千次阅读 2019-12-17 10:29:20
    一、循环队列 数组队列的出队操作的复杂度是O(n),性能很差,解决方法就是使用循环队列(Loop Queue) 在循环队列中,需要对队为空和队为满的时候进行判断,为了区分队空和队满两个条件,需要浪费capacity一个空间...
  • 数据结构——链队列(GIF图解

    千次阅读 2019-12-20 19:35:01
    一、链队列 队列的链式存储结构,其实就是线性表的单链表,只不过它只能尾进头出而已,我们把它简称为链队列。为了操作上的方便,我们将队头指针指向队列的虚拟头结点的后一个结点,而队尾指针指向最后一个结点。 ...
  • 队列应当支持一般队列的支持的所有操作(push、pop、peek、empty): 实现 MyQueue 类: void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean ...
  • 【数据结构基础入门】栈和队列的概念、结构和接口实现
  • 队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队...
  • 队列与优先队列详解

    2021-07-25 22:02:31
    今天给大家(自己)讲讲队列和优先队列吧~ 首先讲讲什么是队列,一讲到队列就会想到栈(stack),栈是一种先进后出(FILO)的数据结构, 而队列,就是一种先进先出(FIFO)的数据结构。先进先出就不用我讲了吧~ 这里的话很多...
  • 转自... 队列的顺序存储结构——循环队列 循环队列的长度为(rear-front+QueueSize)%QueueSize 队空的条件: front=rear 队满的条件是: (rear+1)%QueueSize=front     图片详解:
  • 队列(queue) 队列 是 先进先出( FIFO,First In, First Out) 的线性表。在具体应用中通常用链表或者数组来实现,用数组实现的队列叫作 顺序队列 ,用链表实现的队列叫作 链式队列队列只允许在后端(rear)进行...
  • 循环队列详解

    千次阅读 2022-01-04 22:42:46
    简单易懂的循环队列
  • C++数据结构——队列

    2021-08-08 17:13:08
    C++数据结构——队列 参考博客:原文链接:https://blog.csdn.net/zichen_ziqi/article/details/80819939 数据结构图文解析之:队列详解与C++模板实现 C++ stl队列Queue用法介绍:删除,插入等操作代码举例 1、队列...
  • 队列的图文解析

    千次阅读 2019-05-13 18:48:04
    队列的介绍 队列(Queue),是一种线性存储结构。它有以下几个特点: (01) 队列中数据是按照"先进先出(FIFO, First-In-First-Out)"方式进出队列的。 (02) 队列只允许在"队首"进行删除操作,而在"队尾"进行插入...
  • 1. 队列简介 队列是一种抽象数据类型,具有先进先出的原则。 特性: 与堆栈(只有一个top指针)不同的是,队列有head和rear两个指针,分别指向队列的头和尾 有加入和删除两种基本操作,且在rear指针处加入元素,在...
  • } /** * 判断队列是否为空 * * @return the boolean */ public boolean isEmpty() { // 由图可知, rear = front 时,队列为空,注意 front 是一直成立的,并且 rear - front 也是成立的 return rear == front;...
  • 双端队列_01bfs——附详解典例

    千次阅读 多人点赞 2021-05-15 21:40:08
    这里用双端队列正是对这个地方的优化,将优先队列O(logn)的时间复杂度降到了O(1)!! 过程是这样的: 从起点开始,加入队列。 while队列非空,取队首元素,用这个节点更新其他节点。 如果可以更新的话: 1、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,290
精华内容 7,716
关键字:

队列图解