(超詳細)動手編寫 — 棧、佇列 ( Java實現 )

衍方 發表於 2020-09-13

前言

概念

什麼是棧?

**棧 **:是一種特殊的線性表,只能在一端進行操作

入棧:往棧中新增元素的操作,一般叫做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實現)一文講到,雙向連結串列的頭結點與尾結點有firstlast指標指向,這對於佇列在隊頭、隊尾操作元素是十分方便的,當然是用動態陣列或者單向連結串列也是可以的,只是陣列在隊頭刪除元素會使得後面的元素結點往前移動,而單向連結串列在隊尾新增元素時,指標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、入隊操作

(超詳細)動手編寫 — 棧、佇列 ( Java實現 )

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

GitHub地址