詳細分析棧和隊列的數據結構的實現過程（Java 實現）
棧和隊列的數據結構的實現過程（Java 實現）
棧的數據結構的實現
棧的基礎知識回顧
-
棧是一種線性結構。html
-
相比數組，棧對應的操做是數組的子集。java
- 也就是棧可基於數組實現，能夠將棧當作一種特殊的數組。
-
棧只能從一端添加元素，也只能從一端取出元素，這一端稱爲棧頂。算法
-
棧是一種 後進先出 (LIFO: Last In First Out) 的數據結構。數組
棧的常見應用
-
撤銷（Undo）操做
網絡 -
程序調用的系統棧
數據結構
基於數組的棧的實現
對於棧這種數據結構，實現起來是十分簡單的，這裏實現如下幾個操做：app
-
入棧：void push(E element)
dom -
出棧: E pop()
ide -
查看棧頂元素: E peek()
函數 -
獲取棧中元素個數: int getSize()
-
判斷棧是否爲空: boolean: isEmpty()
對於代碼的具體實現，可讓其支持多態性。因此能夠設計一個接口 Stack 定義上面這 5 個棧支持的操做，再設計一個類 ArrayStack 來實現這個接口。
對於 ArrayStack 這個類，實質上是基於以前實現的動態數組類 Array 來實現的一個數組棧。由於對於棧而言，棧對應的操做是數組的子集。能夠把棧當成一個數組來看待。
對於 Array 類的具體實現過程，可查看另外一篇 文章 。
具體代碼設計
在編寫棧的具體代碼以前，先往工程中導入以前實現的動態數組類 Array，該類代碼可從以前的文章中查閱, 由於要基於該類來實現數組棧。
ArrayStack 類的實現:
由於在 Array 類中已經實現了不少操做數組的方法。因此對於 ArrayStack 類實現接口中的方法時，只需複用 Array 類中的方法便可。
基於 Array 類實現 ArrayStack 類也有一些好處：
和 Array 同樣擁有了動態伸縮容量的功能，咱們不須要關心棧的容量是否夠用，由於容量會動態地進行擴大和縮小。
對於一些非法變量的判斷直接複用了 Array 類中的代碼，不須要重複編寫。
同時，也能夠爲 ArrayStack 類添加一個接口中沒有的方法 getCapacity 提供給用戶獲取棧的容量。這個方法是這個類中特有的。
在實現 peek 方法以前，能夠在 Array 類中擴展兩個新方法用於獲取數組末尾和數組首部的元素，方便在 ArrayStack 類和後續隊列的實現中直接複用。
/**
* 獲取數組的最後一個元素
*
* @return 返回數組的最後一個元素
*/
public E getLast() {
return get(size - 1);
}
/**
* 獲取數組的第一個元素
*
* @return 返回數組的第一個元素
*/
public E getFirst() {
return get(0);
}
Stack 接口類代碼以下:
/**
* 定義棧的基本操做的接口
* 支持泛型
*
* @author 踏雪尋梅
* @date 2020/1/8 - 19:20
*/
public interface Stack<E> {
/**
* 獲取棧中元素個數
*
* @return 棧中若是有元素,返回棧中當前元素個數;棧中若是沒有元素返回 0
*/
int getSize();
/**
* 判斷棧是否爲空
*
* @return 棧爲空,返回 true;棧不爲空,返回 false
*/
boolean isEmpty();
/**
* 入棧
* 將元素 element 壓入棧頂
*
* @param element 入棧的元素
*/
void push(E element);
/**
* 出棧
* 將當前棧頂元素出棧並返回
*
* @return 返回當前出棧的棧頂元素
*/
E pop();
/**
* 查看當前棧頂元素
*
* @return 返回當前的棧頂元素
*/
E peek();
}
ArrayStack 類代碼實現以下：
/**
* 基於以前實現的動態數組類 Array 實現的數組棧類 ArrayStack
* 一樣支持泛型
*
* @author 踏雪尋梅
* @date 2020/1/8 - 19:26
*/
public class ArrayStack<E> implements Stack<E> {
/**
* 動態數組 array
* 基於 array 實現棧的操做
*/
private Array<E> array;
/**
* 構造函數
* 建立一個容量爲 capacity 的數組棧
*
* @param capacity 要建立的棧的容量,由用戶指定
*/
public ArrayStack(int capacity) {
array = new Array<>(capacity);
}
/**
* 默認構造函數
* 建立一個默認容量的數組棧
*/
public ArrayStack() {
array = new Array<>();
}
@Override
public int getSize() {
// 複用 array 的 getSize() 方法便可
return array.getSize();
}
@Override
public boolean isEmpty() {
// 複用 array 的 isEmpty() 方法便可
return array.isEmpty();
}
/**
* 獲取棧的容量
* ArrayStack 特有的方法
*
* @return 返回棧的容量
*/
public int getCapacity() {
// 複用 array 的 getCapacity() 方法便可
return array.getCapacity();
}
@Override
public void push(E element) {
// 將數組的末尾做爲棧頂,複用 array 的 addLast() 方法實現
array.addLast(element);
}
@Override
public E pop() {
// 將數組的末尾做爲棧頂,複用 array 的 removeLast() 方法將棧頂元素出棧並返回
return array.removeLast();
}
@Override
public E peek() {
// 將數組的末尾做爲棧頂,複用 array 的 getLast() 方法獲取棧頂元素
return array.getLast();
}
/**
* 重寫 toString 方法返回數組棧的信息
*
* @return 返回數組棧的當前信息
*/
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append("ArrayStack: ");
result.append("size: ").append(array.getSize()).append(" ");
result.append("capacity: ").append(array.getCapacity()).append(" ");
result.append("bottom -> [ ");
for (int i = 0; i < array.getSize(); i++) {
result.append(array.get(i));
// 若是不是最後一個元素
if (i != array.getSize() - 1) {
result.append(", ");
}
}
result.append(" ] <- top");
return result.toString();
}
}
對於 toString 中的遍歷棧中元素，只是爲了方便查看棧中是否如咱們設計的同樣正確地添加了元素。
對於用戶而言，除了棧頂元素，其餘的元素是不須要知道的，而且用戶也只能操做棧頂元素，不能操做除了棧頂元素以外的其餘元素，這也是棧這個數據結構的特色。
測試:
/**
* 測試 ArrayStack
*
* @author 踏雪尋梅
* @date 2020/1/8 - 16:49
*/
public class Main {
public static void main(String[] args) {
ArrayStack<Integer> stack = new ArrayStack<>();
for (int i = 0; i < 10; i++) {
// 入棧
stack.push(i);
// 打印入棧過程
System.out.println(stack);
}
// 進行一次出棧
stack.pop();
// 查看出棧後的狀態
System.out.println(stack);
// 查看當前棧頂元素
Integer topElement = stack.peek();
System.out.println("當前棧頂元素： " + topElement);
// 判斷棧是否爲空
System.out.println("當前棧是否爲空: " + stack.isEmpty());
}
}
測試結果:
基於數組的棧簡單的時間複雜度分析
對於實現的這 5 個操做，經過以前文章中對 Array 類的分析能夠很快地得出他們的時間複雜度，分別以下：
-
void push(E element)：O(1) 均攤
- 複用了 array 的方法，因此可能觸發 resize 方法進行伸縮容量，因此時間複雜度是均攤的。
-
E pop()：O(1) 均攤
- 複用了 array 的方法，因此可能觸發 resize 方法進行伸縮容量，因此時間複雜度是均攤的。
-
E peek()：O(1)
-
int getSize()：O(1)
-
boolean isEmpty()：O(1)
關於棧的一個算法應用：括號匹配
題目描述:
給定一個只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判斷字符串是否有效。
有效字符串需知足：
左括號必須用相同類型的右括號閉合。
左括號必須以正確的順序閉合。
注意空字符串可被認爲是有效字符串。
示例 1:
輸入: "()"
輸出: true
示例 2:
輸入: "()[]{}"
輸出: true
示例 3:
輸入: "(]"
輸出: false
示例 4:
輸入: "([)]"
輸出: false
示例 5:
輸入: "{[]}"
輸出: true
來源：力扣（LeetCode）
連接：https://leetcode-cn.com/problems/valid-parentheses
著做權歸領釦網絡全部。商業轉載請聯繫官方受權，非商業轉載請註明出處。
題目分析
可以使用棧來解決
思路：
- 逐一遍歷給定字符串中的括號。
-
若是括號是一個左括號，就將其壓入棧中。
-
若是遇到右括號，此時將棧頂的左括號出棧查看是否能夠和這個右括號匹配。
-
若是能夠匹配，則繼續剩餘的判斷。
- 若是全部括號匹配成功後，那麼此時棧應該是空棧，說明給定字符串是有效的。
-
若是不能夠匹配，則說明這個字符串是無效的。
-
-
經過以上分析能夠得出：棧頂元素反映了在嵌套的層次關係中，最近的須要匹配的元素。
思路圖示:
-
有效的括號字符串圖示
-
無效的括號字符串圖示
題解代碼:
-
方法一: 使用 java 的 util 包中內置的 Stack 類解決。
import java.util.Stack; /** * 括號匹配解決方案 * 方法一：使用 java 的 util 包中內置的 Stack 類解決 * * @author 踏雪尋梅 * @date 2020/1/8 - 21:52 */ public class Solution { public boolean isValid(String s) { Stack<Character> stack = new Stack<>(); // 遍歷給定字符串 for (int i = 0; i < s.length(); i++) { // 查看括號 char c = s.charAt(i); // 若是括號是左括號,入棧 if (c == '(' || c == '[' || c == '{') { stack.push(c); } else { // 括號是右括號,查看是否和棧頂括號相匹配 if (stack.isEmpty()) { // 若是此時棧是空的,說明前面沒有左括號,字符串是右括號開頭的,匹配失敗,字符串無效 return false; } // 棧非空,將當前棧頂括號出棧保存到變量中進行匹配判斷 char topBracket = stack.pop(); // 匹配失敗的狀況,如下狀況若爲發生則進行下一次循環依次判斷 if (c == ')' && topBracket != '(') { return false; } if (c == ']' && topBracket != '[') { return false; } if (c == '}' && topBracket != '{') { return false; } } } // for 循環結束後,若是棧中還有字符,說明有剩餘的左括號未匹配,此時字符串無效,不然字符串有效 // 即 isEmpty() 返回 true 表示匹配成功;返回 false 表示匹配失敗 return stack.isEmpty(); } }-
提交結果
-
-
方法二：使用本身實現的 ArrayStack 類解決
須要注意的是要在 Solution 中添加本身實現的 Array 類、Stack 接口、ArrayStack 類做爲內部類才能使用本身實現的數組棧來解決。
/** * 括號匹配解決方案 * 方法二：使用本身實現的 ArrayStack 類解決 * * @author 踏雪尋梅 * @date 2020/1/8 - 22:25 */ public class Solution { public boolean isValid(String s) { Stack<Character> stack = new ArrayStack<>(); // 遍歷給定字符串 for (int i = 0; i < s.length(); i++) { // 查看括號 char c = s.charAt(i); // 若是括號是左括號,入棧 if (c == '(' || c == '[' || c == '{') { stack.push(c); } else { // 括號是右括號,查看是否和棧頂括號相匹配 if (stack.isEmpty()) { // 若是此時棧是空的,說明前面沒有左括號,字符串是右括號開頭的,匹配失敗,字符串無效 return false; } // 棧非空,將當前棧頂括號出棧保存到變量中進行匹配判斷 char topBracket = stack.pop(); // 匹配失敗的狀況,如下狀況若爲發生則進行下一次循環依次判斷 if (c == ')' && topBracket != '(') { return false; } if (c == ']' && topBracket != '[') { return false; } if (c == '}' && topBracket != '{') { return false; } } } // for 循環結束後,若是棧中還有字符,說明有剩餘的左括號未匹配,此時字符串無效,不然字符串有效 // 即 isEmpty() 返回 true 表示匹配成功;返回 false 表示匹配失敗 return stack.isEmpty(); } private class Array<E> { ...（該類中的代碼此處省略） } private interface Stack<E> { ...（該類中的代碼此處省略） } private class ArrayStack<E> implements Stack<E> { ...（該類中的代碼此處省略） } }-
提交結果
-
隊列的數據結構的實現
隊列的基礎知識回顧
-
隊列也是一種線性結構。
-
相比數組，隊列對應的操做是數組的子集。
- 也就是說，隊列是可基於數組實現的，能夠將隊列當作一個特殊的數組。
-
隊列只能從一端（隊尾）添加元素，只能從另外一端（隊首）取出元素。
- 其實和現實生活中的排隊差很少，隊頭的人離去，新來的人排在隊尾。
-
隊列是一種先進先出 (FIFO：First In First Out) 的數據結構。
基於數組的隊列的實現
對於隊列這種數據結構，實現起來是十分簡單的，這裏實現如下幾個操做：
-
入隊：void enqueue(E element)
-
出隊: E dequeue()
-
查看隊首元素: E getFront()
-
獲取隊列元素個數: int getSize()
-
判斷隊列是否爲空: boolean isEmpty()
對於代碼的具體實現，和上面實現的棧同樣也可讓實現的隊列支持多態性。因此在此設計一個接口 Queue 定義上面這 5 個隊列支持的操做，再設計一個類 ArrayQueue 來實現這個接口。
對於 ArrayQueue 這個類，實質上也是基於以前實現的動態數組類 Array 來實現的。
具體代碼設計
在編寫數組隊列的具體代碼以前，先往工程中導入以前實現的動態數組類 Array，由於要基於該類來實現數組隊列，不過在以前實現棧的時候已經導入過了。
Queue 接口類的實現:
/**
* 定義隊列的基本操做的接口
* 支持泛型
*
* @author 踏雪尋梅
* @date 2020/1/9 - 16:52
*/
public interface Queue<E> {
/**
* 獲取隊列中元素個數
*
* @return 隊列中若是有元素,返回隊列中當前元素個數;隊列中若是沒有元素返回 0
*/
int getSize();
/**
* 判斷隊列是否爲空
*
* @return 隊列爲空,返回 true;隊列不爲空,返回 false
*/
boolean isEmpty();
/**
* 入隊
* 將元素 element 添加到隊尾
*
* @param element 入隊的元素
*/
void enqueue(E element);
/**
* 出隊
* 將隊首的元素出隊並返回
*
* @return 返回當前出隊的隊首的元素
*/
E dequeue();
/**
* 查看當前隊首元素
*
* @return 返回當前的隊首元素
*/
E getFront();
}
ArrayQueue 類的實現:
由於在 Array 類中已經實現了不少操做數組的方法。因此對於 ArrayQueue 類實現接口中的方法時，一樣只須要複用 Array 類中的方法便可。
一樣，基於 Array 類實現 ArrayQueue 類也有相對應的好處：
和 Array 同樣擁有了動態伸縮容量的功能，咱們不須要關心隊列的容量是否夠用，由於容量會動態地進行擴大和縮小。
對於一些非法變量的判斷直接複用了 Array 類中的代碼，不須要重複編寫。
同時，也能夠爲 ArrayQueue 類添加一個接口中沒有的方法 getCapacity 提供給用戶獲取隊列的容量。這個方法是這個類中特有的。
ArrayQueue 類代碼實現以下：
/**
* 基於以前實現的動態數組類 Array 實現的數組隊列類 ArrayQueue
* 一樣支持泛型
*
* @author 踏雪尋梅
* @date 2020/1/10 - 18:17
*/
public class ArrayQueue<E> implements Queue<E> {
/**
* 動態數組 array
* 基於 array 實現隊列的操做
*/
private Array<E> array;
/**
* 構造函數
* 建立一個容量爲 capacity 的數組隊列
*
* @param capacity 要建立的隊列的容量,由用戶指定
*/
public ArrayQueue(int capacity) {
array = new Array<>(capacity);
}
/**
* 默認構造函數
* 建立一個默認容量的數組隊列
*/
public ArrayQueue() {
array = new Array<>();
}
/**
* 獲取隊列的容量
* ArrayQueue 特有的方法
*
* @return 返回隊列的容量
*/
public int getCapacity() {
// 複用 array 的 getCapacity() 方法便可
return array.getCapacity();
}
@Override
public int getSize() {
// 複用 array 的 getSize() 方法便可
return array.getSize();
}
@Override
public boolean isEmpty() {
// 複用 array 的 isEmpty() 方法便可
return array.isEmpty();
}
@Override
public void enqueue(E element) {
// 將數組的末尾做爲隊尾,複用 array 的 addLast() 方法實現
array.addLast(element);
}
@Override
public E dequeue() {
// 將數組的首部做爲隊首,複用 array 的 removeFirst() 方法將隊首元素出隊並返回
return array.removeFirst();
}
@Override
public E getFront() {
// 複用 array 的 getFirst() 方法獲取隊首元素
return array.getFirst();
}
/**
* 重寫 toString 方法返回數組隊列的信息
*
* @return 返回數組隊列的當前信息
*/
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append("ArrayQueue: ");
result.append("size: ").append(array.getSize()).append(" ");
result.append("capacity: ").append(array.getCapacity()).append(" ");
result.append("front -> [ ");
for (int i = 0; i < array.getSize(); i++) {
result.append(array.get(i));
// 若是不是最後一個元素
if (i != array.getSize() - 1) {
result.append(", ");
}
}
result.append(" ] <- tail");
return result.toString();
}
}
對於 toString 中的遍歷隊列中的元素，只是爲了方便查看隊列中是否如咱們設計的同樣正確地添加了元素。
對於用戶而言，除了隊首元素，其餘的元素是不須要知道的，由於通常來講業務操做都是針對隊首元素的，剩餘的元素都在排隊等待中。而且用戶只能操做隊首元素和隊尾元素，從隊尾進入新數據從隊首離開老數據，不能操做除了隊首元素和隊尾元素以外的其餘元素，這也是隊列這個數據結構的特色。
測試:
/**
* 測試 ArrayQueue
*/
public static void main(String[] args) {
ArrayQueue<Integer> queue = new ArrayQueue<>();
// 判斷隊列是否爲空
System.out.println("當前隊列是否爲空: " + queue.isEmpty());
for (int i = 0; i < 10; i++) {
// 入隊
queue.enqueue(i);
// 顯示入隊過程
System.out.println(queue);
// 每入隊 4 個元素就出隊一次
if (i % 4 == 3) {
// 出隊
queue.dequeue();
// 顯示出隊過程
System.out.println("\n" + queue + "\n");
}
}
// 判斷隊列是否爲空
System.out.println("當前隊列是否爲空: " + queue.isEmpty());
// 獲取隊首元素
Integer front = queue.getFront();
System.out.println("當前隊列隊首元素爲: " + front);
}
測試結果:
基於數組的隊列的簡單時間複雜度分析
對於實現的這 5 個操做，經過以前的 Array 類的分析能夠很快地得出他們的時間複雜度，分別以下：
-
void enqueue(E element)：O(1) 均攤
- 複用了 array 的方法，因此可能觸發 resize 方法進行伸縮容量，因此時間複雜度是均攤的。
-
E dequeue()：O(n)
-
在出隊的時候，當把隊首的元素移出去以後，剩下的元素都要往前移動一個位置。
-
因此，對於當前實現的基於數組的隊列，若是要放的數據量很大的話，好比 100 萬、1000 萬的數據量的時候，進行出隊操做的時候時間性能消耗會很大。
- 對於這種狀況，可以使用循環隊列來解決。
-
-
E getFront()：O(1)
-
int getSize()：O(1)
-
boolean isEmpty()：O(1)
循環隊列的實現
數組隊列出隊時的缺陷分析:
在前面的基於數組的實現中，隊列在出隊時剩餘的元素都會往前移動一個位置，若是數據量很大時進行出隊將會耗費不少的時間去移動元素。而若是不移動，前面就會存在沒有使用的數組空間。因此這是數組隊列存在的侷限性。
數組隊列出隊圖示:
改進分析:
對於改進這一缺陷，可使用兩個變量來記錄隊首和隊尾的位置，分別爲 front、tail。
對於 front，指向的是隊列的第一個元素所在的位置，而 tail 指向的則是新元素入隊時應該要放置的位置。
這樣記錄後，當元素出隊後，只要維護 front 指向的位置就能夠了，此時就不須要像以前那樣將全部元素都往前移動一個位置了，這樣時間複雜度就是 O(1) 級別的了。而當元素入隊時，只須要維護 tail 將其從新指向下一個元素入隊時應該要放置的位置便可。
因此循環隊列的實現思路可以下逐一分析:
-
初始時，隊列爲空，front 和 tail 都指向 0，即 front == tail 表示隊列爲空，元素個數 size 的值也爲 0，表示當前元素個數爲 0。
-
當元素入隊時，維護 tail 將其指向下一個元素入隊時應該要放置的位置，即當前隊尾元素的後一個位置。
-
當元素出隊時，維護 front 將其指向出隊後的隊列中的第一個元素。
-
當元素入隊到 tail 的值不能再加一且隊列空間未滿的時候，維護 tail 將其指向剩餘空間中的第一個位置，使隊列中的元素像處於一個環中同樣進行循環。
-
例如如下狀況
-
此時可暫時得出元素入隊時更改 tail 的值的公式：
(tail + 1) % capacity
-
當 tail 的值再加一就等於 front 的值時，此時隊列還剩餘一個空間（此處這個剩餘的空間設計爲不記在隊列容量中，是額外添加的），這時候表示隊列爲滿，不能再入隊，即 (tail + 1) % (capacity + 1) == front 表示隊列滿（capacity + 1 == data.length）。
-
此時若再入隊，就會讓 front 和 tail 相等，因爲front == tail 表示隊列爲空，此時隊列又不爲空，會產生矛盾。因此在循環隊列中額外添加一個空間用來判斷隊列是否已滿。具體過程以下圖所示：
-
綜上可總結出關於循環隊列的四個公式
-
front == tail 表示隊列爲空。
-
(tail + 1) % data.length == front 表示隊列爲滿。
- 或 (tail + 1) % (capacity + 1) == front
-
元素入隊時更改 tail 的值的公式：(tail + 1) % data.length。
-
由於已經設定了在隊列中額外添加一個空間用於判斷隊列是否已滿，因此更改 tail 時須要模的是隊列底層數組的長度，而不是模隊列的容量。可參照下圖理解：
-
-
同理，可得出元素出隊時更改 front 的值得公式：(front + 1) % data.length。
-
-
具體代碼設計
代碼實現:
經過以上分析，可設計循環隊列 LoopQueue 類的代碼以下：
/**
* 循環隊列類 LoopQueue
* 支持泛型
*
* @author 踏雪尋梅
* @date 2020/1/10 - 21:35
*/
public class LoopQueue<E> implements Queue<E> {
/**
* 存放循環隊列元素的底層數組
*/
private E[] data;
/**
* 隊首索引
* 指向隊列隊首元素所在的索引
*/
private int front;
/**
* 隊尾索引
* 指向新元素入隊時應該要放置的索引
*/
private int tail;
/**
* 循環隊列當前元素個數
*/
private int size;
/**
* 構造函數
* 構建一個容量爲 capacity 的循環隊列
*
* @param capacity 要建立的循環隊列的容量,由用戶指定
*/
public LoopQueue(int capacity) {
// 由於在循環隊列中額外添加了一個空間用來判斷隊列是否已滿,因此構建 data 時多加了一個空間
data = (E[]) new Object[capacity + 1];
// 循環隊列初始化
front = 0;
tail = 0;
size = 0;
}
/**
* 默認構造函數
* 構建一個容量爲 10 的循環隊列
*/
public LoopQueue() {
this(10);
}
/**
* 獲取循環隊列的容量
*
* @return 返回循環隊列的容量
*/
public int getCapacity() {
// 由於在循環隊列中額外添加了一個空間用來判斷隊列是否已滿,因此返回時將數組長度的值減一
return data.length - 1;
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
// front == tail 表示隊列爲空,返回 true;不然返回 false
return front == tail;
}
/**
* 將循環隊列的容量更改成 newCapacity
*
* @param newCapacity 循環隊列的新容量
*/
private void resize(int newCapacity) {
E[] newData = (E[]) new Object[newCapacity + 1];
// 將 data 的全部元素按順序 (front ~ tail) 轉移到 newData 的 [0, size - 1] 處
for (int i = 0; i < size; i++) {
// 在將元素轉移到擴容後的空間時,兩個數組的 i 的值不必定對應
// 因此取 data 的數據時須要將 i 進行偏移：(i + front) % data.length
newData[i] = data[(i + front) % data.length];
}
// 將 data 指向擴容後的隊列
data = newData;
// 從新設定隊首、隊尾索引的值,由於上處將 data 的全部元素按順序 (front ~ tail) 轉移到 newData 的 [0, size - 1] 處
front = 0;
tail = size;
}
@Override
public void enqueue(E element) {
// 入隊前先查看隊列是否已滿,data.length <==> getCapacity() + 1
if ((tail + 1) % data.length == front) {
// 隊列滿時進行擴容
resize(getCapacity() * 2);
}
// 入隊
data[tail] = element;
// 維護 tail
tail = (tail + 1) % data.length;
// 維護 size
size++;
}
@Override
public E dequeue() {
// 出隊前查看隊列是否爲空
if (isEmpty()) {
// 隊列爲空,拋出一個非法參數異常說明空隊列不能出隊
throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
}
// 保存出隊元素,以返回給用戶
E dequeueElement = data[front];
// 出隊
// 將原隊首元素置空,防止對象遊離
data[front] = null;
// 維護 front
front = (front + 1) % data.length;
size--;
// 當出隊到隊列元素個數少到必定程度時,進行減容
if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
resize(getCapacity() / 2);
}
// 返回出隊元素給用戶
return dequeueElement;
}
@Override
public E getFront() {
// 查看隊首元素前查看隊列是否爲空
if (isEmpty()) {
// 隊列爲空,拋出一個非法參數異常說明隊列是空隊列
throw new IllegalArgumentException("Queue is empty.");
}
// 返回隊首元素給用戶
return data[front];
}
/**
* 重寫 toString 方法返回循環隊列的信息
*
* @return 返回循環隊列的當前信息
*/
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append(String.format("LoopQueue: size = %d, capacity = %d\n", size, getCapacity()));
result.append("front -> [ ");
for (int i = front; i != tail; i = (i + 1) % data.length) {
result.append(data[i]);
// 若是不是最後一個元素
if ((i + 1) % data.length != tail) {
result.append(", ");
}
}
result.append(" ] <- tail");
return result.toString();
}
}
測試:
/**
* 測試 LoopQueue
*/
public static void main(String[] args) {
LoopQueue<Integer> queue = new LoopQueue<>();
// 判斷隊列是否爲空
System.out.println("當前隊列是否爲空: " + queue.isEmpty());
for (int i = 0; i < 10; i++) {
// 入隊
queue.enqueue(i);
// 顯示入隊過程
System.out.println(queue);
// 每入隊 3 個元素就出隊一次
if (i % 3 == 2) {
// 出隊
queue.dequeue();
// 顯示出隊過程
System.out.println("\n" + queue + "\n");
}
}
// 判斷隊列是否爲空
System.out.println("當前隊列是否爲空: " + queue.isEmpty());
// 獲取隊首元素
Integer front = queue.getFront();
System.out.println("當前隊列隊首元素爲: " + front);
}
測試結果:
對於循環隊列的代碼，由於使用了 front 和 tail 指向隊首和隊尾，因此很差再複用 Array 類的代碼，不過一樣的是底層依舊是基於泛型數組實現的，只不過使用了循環隊列的一些公式使其能循環存取數據，而且也和以前實現的 Array、ArrayStack、ArrayQueue 類同樣實現了動態伸縮容量的功能，讓用戶再也不擔憂容量夠不夠使用的問題。
循環隊列的簡單時間複雜度分析
對於循環隊列，由於使用了 front 來指向隊首，因此相比以前的數組隊列，能夠很快的得出在出隊的時候的時間複雜度是 O(1) 級別的。
又由於在代碼實現中一樣實現了自動伸縮容量，因此在入隊和出隊的時候可能會觸發 resize 方法進行擴大容量和減小容量，經過以前的 Array 類的分析，對於入隊和出隊時的時間複雜度 O(1) 一樣能夠得出是均攤的。因此對於循環隊列中的 5 個基本操做，時間複雜度以下：
-
void enqueue(E element)：O(1) 均攤
-
E dequeue()：O(1) 均攤
-
E getFront()：O(1)
-
int getSize()：O(1)
-
boolean isEmpty()：O(1)
數組隊列和循環隊列間的比較
實現到此，棧和隊列的基本數據結構都實現完成了，最後再編寫一些代碼來實際測試一下數組隊列和循環隊列之間的效率差別。
測試代碼:
import java.util.Random;
/**
* 測試 ArrayQueue 和 LoopQueue 的效率差距
*
* @author 踏雪尋梅
* @date 2020/1/8 - 16:49
*/
public class Main {
public static void main(String[] args) {
// 測試數據量
int opCount = 100000;
// 測試數組隊列所須要的時間
ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
double arrayQueueTime = testQueue(arrayQueue, opCount);
System.out.println("arrayQueueTime: " + arrayQueueTime + " s.");
// 測試循環隊列所須要的時間
LoopQueue<Integer> loopQueue = new LoopQueue<>();
double loopQueueTime = testQueue(loopQueue, opCount);
System.out.println("loopQueueTime: " + loopQueueTime + " s.");
// 計算二者間的差距
double multiple = arrayQueueTime / loopQueueTime;
System.out.println("在這臺機器上,對於 " + opCount + " 的數據量,loopQueue 用時比 arrayQueue 用時大約快 " + multiple + " 倍.");
}
/**
* 測試使用隊列 queue 運行 opCount 個 enqueue 和 dequeue 操做所須要的時間,單位: 秒
*
* @param queue 測試的隊列
* @param opCount 測試的數據量
* @return 返回整個測試過程所須要的時間,單位: 秒
*/
private static double testQueue(Queue<Integer> queue, int opCount) {
long startTime = System.nanoTime();
// 用於生成隨機數入隊
Random random = new Random();
// opCount 次 enqueue
for (int i = 0; i < opCount; i++) {
// 入隊
queue.enqueue(random.nextInt(Integer.MAX_VALUE));
}
// opCount 次 dequeue
for (int i = 0; i < opCount; i++) {
// 出隊
queue.dequeue();
}
long endTime = System.nanoTime();
// 將納秒單位的時間轉換爲秒單位
return (endTime - startTime) / 1000000000.0;
}
}
在以上代碼中：
-
對於數組隊列而言，入隊時單次操做是 O(1) 的，而 opCount 次入隊是 O(n) 的；出隊時單次操做是 O(n) 的，而 opCount 次出隊則是 O(n2) 的；因此對於整個 testQueue 方法，數組隊列的時間複雜度是 O(n2) 級別的。
-
對於循環隊列而言，入隊時和出隊時單次操做都是均攤複雜度 O(1) 的，因此 opCount 次入隊和出隊則是 O(n) 的，因此對於整個 testQueue 方法，循環隊列的時間複雜度是 O(n) 級別的。
-
因此，能夠預估：隨着 n 的值愈來愈大，數組隊列的時間消耗會比循環隊列大許多。
測試結果:
最後，從結果中，能夠看出循環隊列的入隊和出隊操做所用的時間消耗比數組隊列的快了很大的倍數。固然，隨着機器配置的不一樣，測試結果可能也會不一樣，但可以驗證循環隊列比數組隊列快就能夠了。
若有寫的不足的，請見諒，請你們多多指教。
- 1. 詳細分析鏈表的數據結構的實現過程（Java 實現）
- 2. Python實現隊列、棧數據結構
- 3. 【數據結構】用隊列實現棧
- 4. 【數據結構】用數組實現隊列（分析與實現）
- 5. 兩個隊列實現棧，兩個棧實現隊列詳細解析
- 6. Java僅用隊列結構實現棧結構和僅用棧結構實現隊列結構【高頻考點】
- 7. java數據結構和算法(05)兩個棧實現隊列
- 8. 數據結構之棧和隊列及其Java實現
- 9. Java關於數據結構的實現：表、棧與隊列
- 10. 數據結構之堆棧和隊列在python中的實現
- 更多相關文章...
- • 現實生活中的 XML - XML 教程
- • Swift 析構過程 - Swift 教程
- • ☆基於Java Instrument的Agent實現
- • TiDB 在摩拜單車在線數據業務的應用和實踐
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Appium入門
- 2. Spring WebFlux 源碼分析(2)-Netty 服務器啓動服務流程 --TBD
- 3. wxpython入門第六步（高級組件）
- 4. CentOS7.5安裝SVN和可視化管理工具iF.SVNAdmin
- 5. jedis 3.0.1中JedisPoolConfig對象缺少setMaxIdle、setMaxWaitMillis等方法，問題記錄
- 6. 一步一圖一代碼，一定要讓你真正徹底明白紅黑樹
- 7. 2018-04-12—（重點）源碼角度分析Handler運行原理
- 8. Spring AOP源碼詳細解析
- 9. Spring Cloud（1）
- 10. python簡單爬去油價信息發送到公衆號