雙向循環鏈表的Java版本實現

• 1、單項循環列表

     單向循環鏈表是單鏈表的另一種形式，其結構特點是鏈表中最后一個結點的指針不再是結束標記，而是指向整個鏈表的第一個結點，從而使單鏈表形成一個環。和單鏈表相比，循環單鏈表的長處是從鏈尾到鏈頭比較方便。當要處理的數據元素序列具有環型結構特點時，適合於采用循環單鏈表。

• 2、單向循環鏈表

     和單鏈表相同，循環單鏈表也有帶頭結點結構和不帶頭結點結構兩種，帶頭結點的循環單鏈表實現插入和刪除操作時，算法實現較為方便。帶頭結點的循環單鏈表結構如下：

     

 

帶頭結點的循環單鏈表的操作實現方法和帶頭結點的單鏈表的操作實現方法類同，差別僅在於：

（1）在構造函數中，要加一條head.next = head 語句，把初始時的帶頭結點的循環單鏈表設計成圖2-11 （a）所示的狀態。

（2）在index(i)成員函數中，把循環結束判斷條件current != null改為current != head。

• 雙向循環鏈表

      雙向鏈表是每個結點除后繼指針外還有一個前驅指針。和單鏈表類同，雙向鏈表也有帶頭結點結構和不帶頭結點結構兩種，帶頭結點的雙向鏈表更為常用；另外，雙向鏈表也可以有循環和非循環兩種結構，循環結構的雙向鏈表更為常用。

      在雙向鏈表中，每個結點包括三個域，分別是element域、next域和prior域，其中element域為數據元素域，next域為指向后繼結點的對象引用，prior域為指向前驅結點的對象引用。

如下圖是帶頭結點的循環雙向鏈表的圖示結構。循環雙向鏈表的next和prior各自構成自己的循環單鏈表。

在雙向鏈表中，有如下關系：設對象引用p表示雙向鏈表中的第i個結點，則p.next表示第i+1個結點，p.next.prior仍表示第i個結點，即p.next.prior == p；同樣地，p.prior表示第i-1個結點，p.prior.next仍表示第i個結點，即p.prior.next == p。下圖是雙向鏈表上述關系的圖示。

循環雙向鏈表的插入過程如下圖所示。圖中的指針p表示要插入結點的位置，s表示要插入的結點，①、②、③、④表示實現插入過程的步驟。

 

 

 //==========================================我是代碼的分割線

//具體代碼的分析已經詳細的寫在了解析里面，歡迎討論

/**
 * 本項目主要是通過幾個類來組合實現
 * 1、List的線性表的接口
 * 2、Node節點類的具體方法
 * 3、單項鏈表類的具體實現
 */


/**
 * 線性表接口
 */
public interface List {

    // 獲得線性表的長度
    public int size();

    // 判斷是否為空
    public boolean isEmpty();

    // 插入操作，需要拋出異常
    public void insert(int index, Object obj) throws Exception;

    // 刪除元素
    public void delete(int index) throws Exception;

    // 獲取指定位置元素
    public Object get(int index) throws Exception;

}

//節點類
//這個是重點！！！！Java一樣可以實現指針的跳轉->使用引用
public class Node {

    Object element; // 數據域
    Node next;// 后繼指針域
    Node prior;// 前驅指針域

    // 頭節點的構造方法
    public Node(Node nextval) {
        this.next = nextval;
    }

    // 非頭節點的構造方法
    public Node(Object obj, Node nextval) {
        this.element = obj;
        this.next = nextval;
    }

    // 獲得當前節點的后繼結點
    public Node getNext() {
        return this.next;
    }

    // 獲得當前節點的前驅結點
    public Node getPrior() {
        return this.prior;
    }

    // 獲得當前節點的數據域的值
    public Object getElement() {
        return this.element;
    }

    // 設置當前節點的后繼指針域
    public void setNext(Node nextval) {
        this.next = nextval;
    }

    // 設置當前節點的前驅指針域
    public void setPrior(Node priorval) {
        this.prior = priorval;
    }

    
    // 設置當前節點的數據域，
    public void setElement(Object obj) {
        this.element = obj;
    }

    public String toString() {
        return this.element.toString();
    }
}

//單向鏈表類
public class DoubleCycleLinkList implements List {

    Node head;// 頭指針
    Node current;// 當前節點對象
    int size; // 節點的個數

    // 初始化一個空鏈表
    public DoubleCycleLinkList() {
        // 初始化頭節點，讓頭指針指向頭節點,並且讓當前節點對象等於頭節點
        this.head = current = new Node(null);
        this.size = 0; // 單項鏈表出事長度為0
        // 循環列表屬性
        this.head.next = head;
        this.head.prior = head;
    }

    // 定位函數,實現當前操作對象的前一個節點，也就是讓當前節點對象定位到要要操作節點的前一個節點
    public void index(int index) throws Exception {
        // 參數非法時，出現-1是由於第一個元素的下標是0，而第一個元素的前面就是頭節點，該節點就得用-1表示下標了。
        if (index < -1 || index > size - 1) {
            throw new Exception("參數錯誤");
        }
        // 說明是在頭節點之后進行操作
        if (index == -1)
            return;
        // 通過該循環獲得要操作的那個數的前一個節點
        current = head.next;
        int j = 0;// 循環變量
        // 循環鏈表屬性
        while (current != head && j < index) {
            current = current.next;
            j++;
        }

    }

    @Override
    public int size() {
        // TODO Auto-generated method stub
        return this.size;
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return size == 0;
    }

    @Override
    public void insert(int index, Object obj) throws Exception {
        // TODO Auto-generated method stub
        // 可以等於0表示在一個元素的前面插入，也就是頭結點的后面
        if (index < 0 || index > size) {
            throw new Exception("參數錯誤！ ");
        }
        /**
         * 這里是核心操作
         */
        // 定位到要操作節點的前一個節點對象
        index(index - 1);
        // 將前一個節點進行設置,使其指向要插入節點的指針域，
        current.setNext(new Node(obj, current.next));
        size++;
    }

    @Override
    public void delete(int index) throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("鏈表為空，無法刪除");
        }

        if (index < 0 || index > size) {
            throw new Exception("參數錯誤！");
        }
        // 進行定位
        index(index - 1);
        // current此時表示要刪除節點的前一個節點的指示，因此需要將該節點指向要刪除的那個節點的下一個節點才對
        // 修改后繼指針
        current.setNext(current.next.next);
        // 修改前驅指針
        current.next.setPrior(current);
        size--;

    }

    @Override
    public Object get(int index) throws Exception {
        // TODO Auto-generated method stub
        if (index < -1 || index > size - 1) {
            throw new Exception("參數非法，無法查詢");
        }
        // 先定位
        index(index);
        return current;
    }
}

 

//測試類
public class Test {
    public static void main(String[] args) throws Exception {
        DoubleCycleLinkList list = new DoubleCycleLinkList();
        for (int i = 0; i < 10; i++) {
            // 0-99之間的整數
            int temp = (int) (Math.random() * 100);
            list.insert(i, temp);
            System.out.print(temp + " ");
        }

        list.delete(4);
        System.out.println();
        System.out.println("----刪除第五個元素之后------");
        for (int i = 0; i < list.size; i++) {
            System.out.print(list.get(i) + " ");
        }
    }
}