前言
棧
概念
什麼是棧？
**棧 **：是一種特殊的線性表，只能在一端進行操作
入棧：往棧中新增元素的操作，一般叫做push
出棧：從棧中移除元素的操作，一般叫做pop，出棧（彈出棧頂元素）
注意：這裡說的"棧"與記憶體中的"棧空間"是兩個不同的概念
棧的結構
相比於陣列和連結串列而言，棧同樣是儲存相同型別資料的線性資料結構，只不過棧的受限性比較大，比如說：棧只有一端是開放的（棧頂），所有的資料操作都是在這一端進行的，基於這個特性，有了所謂的"後進先出(Last In First Out, LIFO)"的特點，其他 3 面是封閉的，所以棧除了棧頂元素，棧中的其他元素都是未知的，棧同時也做不到隨機訪問。
圖示棧結構：
後進先出：
棧的設計
看到前面的棧結構圖，是不是很熟悉，事實上，棧除了三面封閉的特性，其他的是和之前寫過的線性資料結構一致的，所以棧的內部實現可以直接利用以前學過的資料結構實現，動態陣列DynamicArray，連結串列LinkedList都是可以的，沒有讀過前面的編寫動態陣列DynamicArray，連結串列LinkedList的文章的可以先去看看，動手編寫—動態陣列（Java實現) 以及 動手編寫-連結串列（Java實現)
但是我們編寫的Stack棧類，並不是直接去繼承這些類，因為這樣子會暴露動態陣列DynamicArray，連結串列LinkedList的一些原有方法，例如隨機訪問，隨機插入，刪除等等，這樣都會使得棧失去特性。採用組合模式的方式能夠解決這一點，畫一下類圖關係：
棧的介面設計
1、屬性：
private List<E> list;—— 利用基於List介面的線性表實現類設計棧
2、介面方法：
int size();—— 檢視當前棧元素的數量boolean isEmpty();—— 判斷棧是否為空public void push(E element);—— 入棧，新增元素public E pop();—— 出棧，刪除尾部元素public E top();—— 添獲取棧頂元素void clear();—— 清除棧元素
完成設計後，是具體的方法編碼實現，因為是利用動態陣列DynamicArray，連結串列LinkedList實現的棧，呼叫的都是封裝好的方法，這裡就不細講了
編碼實現
public class Stack<E> extends DynamicArray<E>{
//利用動態陣列實現棧
private List<E> list = new DynamicArray<>();
//利用連結串列實現棧
//private List<E> list = new DynamicArray<>();
/**
* 檢視棧元素數量
* @return
*/
public int size() {
return list.size();
}
/**
* 判斷棧是否為空
* @return
*/
public boolean isEmpty() {
return list.isEmpty();
}
/**
* 入棧，新增元素
* @param element
*/
public void push(E element){
list.add(element);
}
/**
* 出棧，刪除尾部元素
*/
public E pop(){
return list.remove(list.size() - 1);
}
/**
* 獲取棧頂元素
* @return
*/
public E top(){
return list.get(list.size() - 1);
}
/**
* 清空棧元素
*/
public void clear() {
list.clear();
}
}
小結
棧的應用
1、雙棧實現瀏覽器的前進和後退
2、軟體的撤銷（Undo）、恢復（Redo）功能
佇列
概念
什麼是佇列？
佇列：與前面棧不同的一點是，棧只能在棧頂一端操作元素，而佇列能在首尾兩端進行操作，佇列同樣是一種特殊的線性表
入隊：只能從隊尾（rear）新增元素，一般叫做enQueue
出隊：只能從隊頭（front）移除元素，一般叫做deQueue
佇列的結構
相比於陣列、連結串列及棧而言，佇列同樣是儲存相同型別資料的線性資料結構，只不過佇列的受限性比棧小一點，但比陣列、連結串列大，比如說：佇列只能在隊尾一端新增資料，隊頭移除元素，基於這個特性，有了所謂的"先進先出的原則，First In First Out，FIFO"的特點，其他 2 面在結構設計上是封閉的，所以佇列除了隊頭元素，佇列中的其他元素都是未知的，當然隊尾元素也是可見的，但是我們一般只在隊尾進行元素新增操作，所以也不會開放這個方法，佇列同時也做不到隨機訪問。
圖示佇列結構：
佇列的設計
佇列和陣列、連結串列、以及棧都是線性表結構，所以我們沒有必要去做一些重複的操作，利用之前寫好的動態陣列DynamicArray，連結串列LinkedList都是可以實現的，同樣利用棧也是可以實現佇列的，但是這裡我們是用雙向連結串列Both_LinkedList實現。
在前面動手編寫-連結串列（Java實現)一文講到，雙向連結串列的頭結點與尾結點有first與last指標指向，這對於佇列在隊頭、隊尾操作元素是十分方便的，當然是用動態陣列或者單向連結串列也是可以的，只是陣列在隊頭刪除元素會使得後面的元素結點往前移動，而單向連結串列在隊尾新增元素時，指標head需要遍歷到尾部結點，這兩者都會造成複雜度的增加，所以選擇雙向連結串列更好
同樣的，但是我們編寫的Queue佇列並不直接接去繼承這些類，依舊採用組合的方式實現，畫一下類圖關係
佇列的介面設計
1、屬性：
private List<E> list;—— 利用基於List介面的線性表實現類設計佇列
2、介面方法：
int size();—— 檢視當前佇列元素的數量boolean isEmpty();—— 判斷佇列是否為空public void enQueue(E element);—— 入隊，新增元素public E deQueue();—— 出隊，刪除頭部元素public E front();—— 添獲取隊頭元素void clear();—— 清除佇列元素
完成設計後，是具體的方法編碼實現，因為是利用雙向連結串列Both_LinkedList實現的佇列，呼叫的都是封裝好的方法，這裡不細講
編碼實現
雙向連結串列實現佇列：
public class Queue<E> {
//利用雙向連結串列封裝好的方法實現佇列
private List<E> list = new Both_LinkedList<>();
/**
* 獲取佇列元素數量
* @return
*/
public int size() {
return list.size();
}
/**
* 判斷當前佇列是否為空
* @return
*/
public boolean isEmpty() {
return list.isEmpty();
}
/**
* 入隊，從隊尾新增元素
* @param element
*/
public void enQueue(E element) {
list.add(element);
}
/**
* 出隊，從隊頭移除元素
* @return
*/
public E deQueue() {
return list.remove(0);
}
/**
* 獲取隊頭元素
* @return
*/
public E front() {
return list.get(0);
}
/**
* 清空佇列元素
*/
public void clear() {
list.clear();
}
}
雙棧實現佇列：
public class QueueByStack<E> {
//定義兩個棧，inStack用於隊尾入隊，outStack用於隊頭出隊
private Stack<E> inStack,outStack;
//使用建構函式初始化
public QueueByStack() {
this.inStack = new Stack<>();
this.outStack = new Stack<>();
}
/**
* 獲取佇列元素數量
* @return
*/
public int size() {
return inStack.size() + outStack.size();
}
/**
* 判斷當前佇列是否為空
* @return
*/
public boolean isEmpty() {
return inStack.isEmpty() && outStack.isEmpty();
}
/**
* 入隊，從隊尾新增元素
* @param element
*/
public void enQueue(E element) {
inStack.push(element);
}
/**
* 出隊，從隊頭新增元素
* @return
*/
public E deQueue() {
checkOutStack();
return outStack.pop();
}
/**
* 獲取隊頭元素
* @return
*/
public E front() {
checkOutStack();
return outStack.top();
}
/**
* 清空棧元素
*/
public void clear() {
inStack.clear();
outStack.clear();
}
/**
* 檢查outStack是否為空，如果不為空，等著出隊
* 如果為空，且inStack不為空，將inStack中的
* 元素出棧，入棧到outStack，然後準備出隊
*/
private void checkOutStack() {
if (outStack.isEmpty()) {
while (!inStack.isEmpty()) {
outStack.push(inStack.pop());
}
}
}
}
雙端佇列
概念
雙端佇列：是能在頭尾兩端新增、刪除的佇列
結構圖示：
設計
雙端佇列Deque與佇列Queue在實現關係上沒有區別，同樣是基於雙向連結串列Both_LinkedList，使用組合模式實現的
雙向佇列的介面設計
1、屬性：
private List<E> list;—— 利用基於List介面的線性表實現類設計佇列
2、介面方法：
int size();—— 檢視當前佇列元素的數量boolean isEmpty();—— 判斷佇列是否為空public void enQueueRear(E element);—— 入隊，從隊尾入隊public E deQueueRear();—— 出隊，從隊尾出隊public void enQueueFront(E element);—— 入隊，從隊頭入隊public E enQueueFront();—— 出隊，從隊頭出隊public E front();—— 添獲取隊頭元素public E rear();—— 添獲取隊尾元素void clear();—— 清除佇列元素
編碼
public class Deque<E> {
//利用雙向連結串列封裝好的方法實現佇列
private List<E> list = new Both_LinkedList<>();
/**
* 獲取佇列元素數量
* @return
*/
public int size() {
return list.size();
}
/**
* 判斷當前佇列是否為空
* @return
*/
public boolean isEmpty() {
return list.isEmpty();
}
/**
* 入隊，從隊尾入隊
* @param element
*/
public void enQueueRear(E element) {
list.add(element);
}
/**
* 出隊，從隊尾出隊
* @return
*/
public E deQueueRear() {
return list.remove(list.size() - 1);
}
/**
* 入隊，從隊頭入隊
* @param element
*/
public void enQueueFront(E element) {
list.add(0, element);
}
/**
* 出隊，從對頭出隊
* @return
*/
public E deQueueFront() {
return list.remove(0);
}
/**
* 獲取隊頭元素
* @return
*/
public E front() {
return list.get(0);
}
/**
* 獲取隊尾元素
* @return
*/
public E rear() {
return list.get(list.size() - 1);
}
/**
* 清空佇列元素
*/
public void clear() {
list.clear();
}
}
迴圈佇列
迴圈佇列
概念：
迴圈佇列：用陣列實現並且優化之後的佇列
圖示結構：
設計：
迴圈佇列又叫環形佇列，是基於Java陣列實現的，使用front指標指向的位置是隊頭，設計上，刪除元素後不會像陣列一樣，挪動元素往前覆蓋，而是將值置空，front往後移動，以這樣的機制刪除元素，刪除後的位置，當front指標後邊的位置滿了，新元素就可以填補剛剛刪除的空位，起到環形的作用
迴圈介面設計
1、屬性：
private int front;—— 迴圈佇列隊頭指標private int size;—— 佇列元素數量private E[] elements;—— 使用順序結構陣列儲存private static final int DEFAULT_CAPACITY = 10;—— 陣列的預設初始化值
2、介面方法：
int size();—— 檢視當前佇列元素的數量boolean isEmpty();—— 判斷佇列是否為空public void enQueue(E element);—— 入隊，從隊尾入隊public E deQueue();—— 出隊，刪除頭部元素public E front();—— 添獲取隊頭元素void clear();—— 清除佇列元素private void ensureCapacity(int capacity)—— 保證要有capacity的容量,不足則擴容private int index(int index);—— 索引對映函式，返回真實陣列下標
1、出隊操作
2、入隊操作
3、再入隊
4、注意點：
(1) 入隊
(2)入隊
(3)出隊
(4)擴容
編碼：
public class CircleQueue<E> {
//陣列的預設初始化值
private static final int DEFAULT_CAPACITY = 10;
//迴圈佇列隊頭指標
private int front;
//佇列元素數量
private int size;
//使用順序結構陣列儲存
private E[] elements;
/**
* 建構函式初始化陣列
*/
public CircleQueue() {
elements = (E[]) new Object[DEFAULT_CAPACITY];
}
/**
* 獲取佇列元素的數量
* @return
*/
public int size(){
return size;
}
/**
* 判斷佇列是否為空
* @return
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 入隊，從隊尾新增元素
* @param element
*/
public void enQueue(E element) {
ensureCapacity(size + 1);
//elements[(front + size) % elements.length] = element;
//呼叫封裝函式
elements[index(size)] = element;
size++;
}
/**
* 出隊，從隊頭移除元素
* @return
*/
public E deQueue() {
E element = elements[front];
elements[front] = null;
//front = (front + 1) % elements.length;
//呼叫封裝函式
front = index(1);
size--;
return element;
}
/**
* 獲取隊頭元素
* @return
*/
public E front(){
return elements[front];
}
/**
* 清空佇列元素
*/
public void clear() {
for (int i = 0; i < size; i++) {
//elements[(i + front) % elements.length] = null;
//呼叫封裝函式
elements[index(i)] = null;
}
front = 0;
size = 0;
}
/**
* 保證要有capacity的容量,不足則擴容
* @param capacity
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) return;
// 新容量為舊容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
//newElements[i] = elements[(i + front) % elements.length];
//呼叫封裝函式
newElements[i] = elements[index(i)];
}
elements = newElements;
// 重置front
front = 0;
}
/**
* 索引對映函式，返回真實陣列下標
* @param index
* @return
*/
private int index(int index){
return (front + index) % elements.length;
}
@Override
public String toString() {
StringBuilder string = new StringBuilder();
string.append("capcacity=").append(elements.length)
.append(" size=").append(size)
.append(" front=").append(front)
.append(", [");
for (int i = 0; i < elements.length; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
迴圈雙端佇列
概念：
迴圈雙端佇列：可以進行兩端新增、刪除操作的迴圈隊
圖示結構：
事實上，在結構上，與迴圈佇列是一樣的，沒有必要設定一個last指標指向隊尾，因為我們採用的是陣列這種順序儲存結構，實際上，last = (font + size - 1) % array.length，只是我們在方法上對其功能進行了擴充套件而已
迴圈介面設計
1、屬性：
private int front;—— 迴圈佇列隊頭指標private int size;—— 佇列元素數量private E[] elements;—— 使用順序結構陣列儲存private static final int DEFAULT_CAPACITY = 10;—— 陣列的預設初始化值
2、介面方法：
int size();—— 檢視當前佇列元素的數量boolean isEmpty();—— 判斷佇列是否為空public void enQueueRear(E element);—— 入隊，從隊尾入隊public E deQueueRear();—— 出隊，從隊尾出隊public void enQueueFront(E element);—— 入隊，從隊頭入隊public E enQueueFront();—— 出隊，從隊頭出隊public E front();—— 添獲取隊頭元素public E rear();—— 添獲取隊尾元素void clear();—— 清除佇列元素private void ensureCapacity(int capacity)—— 保證要有capacity的容量,不足則擴容private int index(int index);—— 索引對映函式，返回真實陣列下標
編碼實現
上面也說到了，在結構上，與迴圈佇列是一樣的，所以大多數的方法是一樣了，只是對其功能進行了增強，調整了部分方法邏輯
方法變動：
(1) 新增public void enQueueFront(E element); —— 入隊，從隊頭入隊
/**
* 入隊，從隊頭入隊
* @param element
*/
public void enQueueFront(E element) {
//front指向當前節點前一位置
front = index(-1);
//假設虛擬索引，以front指向的位置為0，則向隊頭新增元素時往-1新增
elements[front] = element;
size++;
}
(2) 新增public E deQueueRear(); —— 出隊，從隊尾出隊
/**
* 出隊，從隊尾出隊
* @return
*/
public E deQueueRear() {
//找到尾部元素的真實索引
int last = index(size - 1);
E element = elements[last];
elements[last] = null;
size--;
return element;
}
(3) 新增public E rear(); —— 添獲取隊尾元素
/**
* 獲取隊尾元素
* @return
*/
public E rear() {
return elements[index(size - 1)];
}
(4) 變動private int index(int index); —— 索引對映函式，返回真實陣列下標
/**
* 索引對映函式，返回真實陣列下標
* @param index
* @return
*/
private int index(int index){
index += front;
//但真實index為0時，往隊頭新增元素，傳入 -1，小於0
if (index < 0){
index += elements.length;
}
return index % elements.length;
}
宣告
個人能力有限，有不正確的地方，還請指正
文章為原創，歡迎轉載，註明出處即可
本文的程式碼已上傳github,歡迎star