第四章 栈与队列2 (对列)

4.2 队列

4.2.1 队列的定义

队列简称队,它通栈一样,也是一种运算受限的线性表,其限制是仅允许在表的一端进行插入,而在表的另一端进行删除。在队列中把插入数据元素的一端称为队尾(rear),删除元素的一端称为队首(front)。向队尾插入元素称为进队或入队。从队列中删除元素称为离队或出队

队列是先进先出表(First In First Out,FIFO)。

队列的接口Queue:

 1 package com.datastructure.chapter04.interfaces;
 2
 3 import com.datastructure.chapter04.Exception.QueueEmptyException;
 4
 5 /**
 6  * @ClassName: Queue
 7  * @Description: 队列的接口
 8  * @author
 9  * @date 2018年3月16日 下午10:09:17
10  *
11  */
12 public interface Queue {
13
14      //返回队列打大小
15     public int getSize();
16
17     //判断队列是否为空
18     public boolean isEmpty();
19
20     //数据元素e入列
21     public void enqueue(Object e);
22
23     //队首元素出队
24     public Object dequeue() throws QueueEmptyException;
25
26     //取队首元素
27     public Object peek() throws QueueEmptyException;
28 }

队列为空的异常类:

1 package com.datastructure.chapter04.Exception;
2
3 @SuppressWarnings("serial")
4 public class QueueEmptyException extends RuntimeException {
5
6     public QueueEmptyException(String err) {
7         super(err);
8     }
9 }

4.2.2 队栈的顺序存储实现

  1 package com.datastructure.chapter04.interfaces;
  2
  3 import javax.swing.tree.ExpandVetoException;
  4
  5 import com.datastructure.chapter04.Exception.QueueEmptyException;
  6
  7 public class QueueArray implements Queue {
  8
  9     private static final int CAP = 7;//队列默认大小
 10
 11     private Object[] elements;//数据元素数组
 12
 13     private int capacity;//数组的大小elements.length
 14
 15     private int front;//队首指针,指向队首
 16
 17     private int rear;//队尾指针,指向队尾后一个位置
 18
 19     public QueueArray() {
 20         this(CAP);
 21     }
 22
 23     public QueueArray(int cap) {
 24         capacity = cap+1;
 25         elements = new Object[capacity];
 26         front = rear = 0;
 27     }
 28
 29     /* (非 Javadoc)
 30      * <p>Title: getSize</p>
 31      * <p>Description: 获得队列的长度</p>
 32      * @return
 33      * @see com.datastructure.chapter04.interfaces.Queue#getSize()
 34      */
 35     @Override
 36     public int getSize() {
 37         return (rear-front+capacity)%capacity;
 38     }
 39
 40     /* (非 Javadoc)
 41      * <p>Title: isEmpty</p>
 42      * <p>Description: 判断队列是否为空</p>
 43      * @return
 44      * @see com.datastructure.chapter04.interfaces.Queue#isEmpty()
 45      */
 46     @Override
 47     public boolean isEmpty() {
 48         return front == rear;
 49     }
 50
 51     /* (非 Javadoc)
 52      * <p>Title: enqueue</p>
 53      * <p>Description: 队列的入队</p>
 54      * @param e
 55      * @see com.datastructure.chapter04.interfaces.Queue#enqueue(java.lang.Object)
 56      */
 57     @Override
 58     public void enqueue(Object e) {
 59         if(getSize()==capacity-1) expandSpace();
 60         elements[rear] = e;
 61         rear = (rear+1)%capacity;
 62
 63     }
 64
 65     /**
 66      * @Title: expandSpace
 67      * @Description:  队列扩容
 68      * @param
 69      * @return void
 70      * @throws
 71      */
 72     private void expandSpace() {
 73         Object[] a =new Object[elements.length*2];
 74         int i = front; int j=0;
 75
 76         while(i!=rear){
 77             a[j++] = elements[i];
 78             i = (i+1)%capacity;
 79         }
 80         elements = a;
 81
 82         capacity = elements.length;
 83         front = 0;
 84         rear = j;//设置新的队首,队尾指针
 85     }
 86
 87     /* (非 Javadoc)
 88      * <p>Title: dequeue</p>
 89      * <p>Description: 队列的出队</p>
 90      * @return
 91      * @throws QueueEmptyException
 92      * @see com.datastructure.chapter04.interfaces.Queue#dequeue()
 93      */
 94     @Override
 95     public Object dequeue() throws QueueEmptyException {
 96         if(isEmpty())
 97             throw new QueueEmptyException("错误,队列为空");
 98         Object obj = elements[front];
 99         front = (front+1)%capacity;
100         return obj;
101     }
102
103     /* (非 Javadoc)
104      * <p>Title: peek</p>
105      * <p>Description: 获得队首元素</p>
106      * @return
107      * @throws QueueEmptyException
108      * @see com.datastructure.chapter04.interfaces.Queue#peek()
109      */
110     @Override
111     public Object peek() throws QueueEmptyException {
112         if(isEmpty())
113             throw new QueueEmptyException("错误,队列为空");
114         return elements[front];
115     }
116
117 }

以上有个循环数组的概念:就是将数组头和尾通过两个指针(front队首和rear队尾)来指向这两个位置,然后空队列,front=rear,满队列也是队尾和对首指向同一个位置。

顺序存储的队列时间复杂度T(n)=O(1);

4.2.3 队栈的链式存储实现

 1 package com.datastructure.chapter04.impl;
 2
 3 import com.datastructure.chapter04.Exception.QueueEmptyException;
 4 import com.datastructure.chapter04.interfaces.Queue;
 5
 6 public class QueueSLinked implements Queue {
 7
 8     private SLNode front;
 9
10     private SLNode rear;
11
12     private int size;
13
14     public QueueSLinked() {
15         front = new SLNode();
16         rear = front;
17         size = 0;
18     }
19
20
21     /* (非 Javadoc)
22      * <p>Title: getSize</p>
23      * <p>Description: 队列的长度</p>
24      * @return
25      * @see com.datastructure.chapter04.interfaces.Queue#getSize()
26      */
27     @Override
28     public int getSize() {
29         return size;
30     }
31
32     /* (非 Javadoc)
33      * <p>Title: isEmpty</p>
34      * <p>Description: 队列是否为空</p>
35      * @return
36      * @see com.datastructure.chapter04.interfaces.Queue#isEmpty()
37      */
38     @Override
39     public boolean isEmpty() {
40         return size == 0;
41     }
42
43     /* (非 Javadoc)
44      * <p>Title: enqueue</p>
45      * <p>Description: 入队</p>
46      * @param e
47      * @see com.datastructure.chapter04.interfaces.Queue#enqueue(java.lang.Object)
48      */
49     @Override
50     public void enqueue(Object e) {
51         SLNode p = new SLNode(e, null);//创建新结点
52         rear.setNext(p);//队尾的下一个是新入队的结点
53         rear = p;//移动队尾指针至新入队的结点
54         size++;//长度加1
55     }
56
57     /* (非 Javadoc)
58      * <p>Title: dequeue</p>
59      * <p>Description: 出队</p>
60      * @return
61      * @throws QueueEmptyException
62      * @see com.datastructure.chapter04.interfaces.Queue#dequeue()
63      */
64     @Override
65     public Object dequeue() throws QueueEmptyException {
66         if(size<=0)
67             throw new QueueEmptyException("错误:队列为空");
68         SLNode p = front.getNext();//j
69         front.setNext(p.getNext());//直接将队首指向下下一个结点,就将队首结点移除掉了
70         size--;
71         if(size<1) rear = front;//若队列为空,rear指向头结点
72         return p.getData();
73     }
74
75     /* (非 Javadoc)
76      * <p>Title: peek</p>
77      * <p>Description:取队首元素 </p>
78      * @return
79      * @throws QueueEmptyException
80      * @see com.datastructure.chapter04.interfaces.Queue#peek()
81      */
82     @Override
83     public Object peek() throws QueueEmptyException {
84         if(size<=0)
85             throw new QueueEmptyException("错误:队列为空");
86         return front.getNext().getData();
87     }
88
89 }

链式存储队列时间复杂度T(n)=O(1);

原文地址:https://www.cnblogs.com/huaxueyihao/p/8585890.html

时间: 2024-10-09 19:45:28

第四章 栈与队列2 (对列)的相关文章

第四章 栈与队列

一.栈的定义 栈(stack)是限定尽在表尾进行插入和删除操作的线性表. 我们把允许插入和删除的一端成为栈顶(top),另一端成为栈底(bottom),不含任何数据元素的栈称为空栈.栈又称为后进先出(LIFO)的线性表. 图示出栈入栈操作: 二.栈的抽象数据类型 图示栈的各项操作: 由于栈本身就是一个线性表,那么上一章我们讨论了线性表的顺序存储和链式存储,对于栈来说也是同样适用的. 三.栈的顺序存储结构及实现 来看一下栈的结构定义: 若存储栈的长度为StackSize,则栈顶位置top必须小于S

Java数据结构与算法(第四章栈和队列)

本章涉及的三种数据存储类型:栈.队列和优先级队列. 不同类型的结构 程序员的工具 数组是已经介绍过的数据存储结构,和其他结构(链表.树等等)一样,都适用于数据应用中作数据记录. 然而,本章要讲解的是数据结构和算法更多的是作为程序员的工具来运用.它们组要作为构思算法的辅助工具,而不是完全的数据存储工具.这些数据结构的生命周期比那些数据库类型的结构要短的多.在程序操作执行期间它们才被创建,通常它们去执行某项特殊的任务,当完成之后,它们就被销毁. 受限访问 在数组中,只要知道下标就可以访问数据项.或顺

《大话数据结构》--- 第四章 栈与队列

栈(Stack)是限定仅在表尾进行插入和删除操作的线性表. 把允许插入和删除的一端称为栈顶,另一端称为栈底,不含任何数据元素的栈称为空栈.栈又称为后进先出的线性表,简称LIFO结构. 栈的插入操作,叫做进栈,也称压栈.入栈. 栈的删除操作,叫做出栈,也称弹栈. 当两个栈一个占用内存可能太大 但内容较少 另一个占用内存可能有剩余 可以考虑使用一个数组来存两个栈,一个底端从下标0开始,另一个底端从下标n-1开始,只要两个栈不碰头 就可以实现空间的有效利用. 栈的链式存储结构称为栈链. 如果栈的使用过

第四章&#160;栈与队列(a)栈接口与实现

原文地址:https://www.cnblogs.com/ZHONGZHENHUA/p/10265879.html

第04章 栈和队列

栈 队列 优先级队列 本章涉及到的三种存储数据类型:栈 队列 优先级队列 本章涉及到的存储数据类型是算法构思的辅助工具,而不仅仅是存储数据的工具.数据结构的生命周期比较短,在程序结束时,对应的数据结构的生命周期随之结束. 栈 队列 优先级队列是比较抽象的数据结构,通过接口对三种数据结构进行定义和实现,而实现的过程对用户来说是屏蔽的. 栈 (后进先出) 栈只允许访问一个数据项,即最后插入的项,当最后一项被移除时,才能对倒数第二项进行操作,依次类推. 栈的操作有两种,入栈和出栈,push  pop.

数据结构看书笔记(四)--栈与队列

栈与队列 栈是限定尽在表尾进行插入和删除操作的线性表  队列是只允许在一端进行插入操作.而在另一端进行删除操作的线性表栈的定义: 栈(Stack)是限定仅在表尾进行插入和删除操作的线性表 其中允许插入的一端称为栈顶(top),另一端称为栈底(bottom),不含任何数据元素的栈称为空栈.栈又称为先进后出(Last In First Out)的线性表,简称为LIFO结构. 特殊之处在与限制了这个线性表的插入和删除位置只能是在栈顶.  栈的插入操作,叫做进栈,也称为压栈.入栈. 栈的删除操作,叫做出

数据结构期末复习第三章栈和队列

第三章:栈和队列 栈的特性:后进先出(LIFO) 1.  输入序列为ABC,可以变为CBA时,经过的栈操作为( B )A. push, pop, push, pop, push, popB. push, push, push, pop, pop, popC. push, push, pop, pop, push, popD. push, pop, push, push, pop, pop 解析: ABC经过push,push,push操作后,从栈顶到栈底元素为CBA,经过pop,pop,pop出

算法:(四)栈和队列

(一)栈和队列的基本性质 栈是先进后出的 队列是先进先出的 栈和队列在实现结构上可以有数组和链表两种形式 数组结构实现较容易 用链表结构较复杂,因为牵扯很多指针操作 (二)队列和栈的基本操作 pop操作(栈尾弹出一个元素) push操作(栈/队列尾加入一个元素) shift操作(队头弹出一个元素) 栈和队列的基本操作,都是时间复杂度都为O(1)的操作 (三)深度优先遍历(DFS)和宽度优先遍历(BFS) 深度优先遍历可以用栈实现 宽度优先遍历可以用队列实现 (四)双端队列和优先级队列 双端队列首

《数据结构》第3章-栈与队列的学习总结

我之前有接触过栈和队列,当时就觉得很好奇,那是以怎样的存储结构存储数据的呢?拨开重重迷雾,终于学到基础知识了. 学习<栈和队列>有两个星期了,有了前面两个章节的思维基础,我觉得栈和队列学习起来还是很好理解的,通过一些实际应用例子,让我有了更进一步的理解.现在我梳理一下知识,下面总结这一章我所学习到的东西. 一.栈(后进先出:LIFO) 1.顺序栈 这是顺序栈的存储结构: typedef struct { int *base;//栈底指针 int *top; //栈顶指针 int size; /