資料結構與演算法--迴圈連結串列

單迴圈連結串列的實現

單連結串列的實現中，最後一個結點始終指向null，表示達到表尾部。位於last這個位置，想要訪問其他結點是不可能的了，因為我們既沒有prev指標指向前一個結點，last也不指向任何其他結點。如果把last和first連線起來，即讓last.next指向first，這樣就形成了一個首尾相連的環形結構，所以不管從哪個結點出發，總能遍歷到所有結點。非迴圈結構的單連結串列，根據當前結點是否為null判斷是否到了表尾，由於迴圈連結串列沒有明確的first和last之說了，所以在遍歷時候按照first或者last去判斷不太方便。為了簡單起見，直接用連結串列長度N作為判斷條件。index自增到N說明已經遍歷完一遍。基本上拿單連結串列的程式碼改改就能實現，比較簡單就直接上程式碼了。

package Chap3;


import java.util.Iterator;

/**
 * 單向迴圈連結串列，last不再指向null而是first，即使得last.next = first
 * 同時遍歷判斷條件從current != null 變成判斷長度 i < N
 */
public class CircularLinkedList<Item> implements Iterable<Item> {

    private class Node {
        Item data;
        Node next;
    }

    // 指向第一個節點
    private Node first;
    // 指向最後一個節點
    private Node last;
    private int N;

    public CircularLinkedList(Item... items) {
        for (Item item : items) {
            add(item);
        }
    }

    public int size() {
        return N;
    }

    public boolean isEmpty() {
        return N == 0;
    }

    private Node index(int index) {
        // [0, N-1]的定位範圍
        if (index < 0 || index >= N) {
            throw new IndexOutOfBoundsException(index + "");
        }

        Node current = first;
        for (int j = 0; j < index; j++) {
            current = current.next;
        }
        return current;
    }

    public Item get(int index) {
        Node current = index(index);
        return current.data;
    }

    public void set(int index, Item item) {
        Node current = index(index);
        current.data = item;
    }

    // 可以在表頭（index==0）和表尾插入
    public void insert(int index, Item item) {
        // 如果index==0,因為沒有設定頭結點所以只需單向連結就行
        if (index == 0) {
            push(item);
        } else if (index == N) {
            add(item);
        }
        else if (index > 0 && index < N) {
            Node a = new Node();
            // 其他插入的位置在index-1和index之間, 需要定位到index-1的位置，
            Node current = index(index - 1);
            a.data = item;
            a.next = current.next;
            current.next = a;
            N++;
        } else {
            throw new IndexOutOfBoundsException(index + "");
        }
    }


    public Item remove(int index) {
        // 和insert一樣，index==0處理方式也不一樣
        Item item;
        if (index == 0) {
            item = pop();
            // 和insert不一樣（它可以在表尾null處插入），remove則不該移除本來就是null的值
            // 表尾的刪除也稍有不同
        } else if(index == N -1) {
            Node current = index(index - 1);
            item = current.next.data;
            current.next = first;
            last = current;
        } else if (index > 0 && index < N) {
            Node current = index(index - 1);
            // 定位到index的上一個了，所以取next
            item = current.next.data;
            Node next = current.next.next;
            // 下面兩行幫助垃圾回收
            current.next.next = null;
            current.next.data = null;
            current.next = next;
            N--;
        } else {
            throw new IndexOutOfBoundsException(index + "");
        }
        return item;
    }

    public void add(Item item) {
        Node oldlast = last;
        last = new Node();
        last.data = item;
        // 如果是第一個元素，則last和first指向同一個，即第一個
        if (isEmpty()) {
            first = last;
            last.next = first;
        } else {
            oldlast.next = last;
            // last被新結點取代，next預設是null，所以每次add都要將它的next指向first
            last.next = first;
        }
        N++;
    }

    public void push(Item item) {
        Node oldfirst = first;
        first = new Node();
        first.data = item;
        if (isEmpty()) {
            last = first;
            // 這句是迴圈連結串列
            last.next = first;
        } else {
            first.next = oldfirst;
        }
        N++;
    }

    // 刪除表頭元素
    public Item pop() {
        Item item = first.data;
        Node next = first.next;
        // 這兩行有助於垃圾回收
        first.data = null;
        first.next = null;
        first = next;
        N--;
        // 最後一個元素被刪除，first自然為空了，但是last需要置空。
        // 注意是先減再判斷是否為空
        if (isEmpty()) {
            last = null;
        }
        return item;
    }

    public void clear() {
        while (first != null) {
            Node next = first.next;
            // 下面兩行幫助垃圾回收
            first.next = null;
            first.data = null;
            first = next;
        }
        // 所有元素都空時，last也沒有有所指了。記得last置空
        last = null;
        N = 0;
    }

    public int indexOf(Item item) {
        int index = 0;
        int i = 0;

        if (item != null) {
            for (Node cur = first; i < N; cur = cur.next) {
                if (item.equals(cur.data)) {
                    return index;
                }
                index++;
                i++;
            }
        } else {
            for (Node cur = first; i < N; cur = cur.next) {
                if (cur.data == null) {
                    return index;
                }
                index++;
                i++;
            }
        }
        return -1;
    }

    public boolean contains(Item item) {
        return indexOf(item) >= 0;
    }

    // 因為是迴圈連結串列，無頭無尾，用長度判斷比較方便
    @Override
    public Iterator<Item> iterator() {
        return new Iterator<>() {
            private Node current = first;
            private int i = 0;

            @Override
            public boolean hasNext() {
                return i < N;
            }

            @Override
            public Item next() {
                Item item = current.data;
                current = current.next;
                i++;
                return item;
            }
        };
    }

    @Override
    public String toString() {
        Iterator<Item> it = iterator();

        if (!it.hasNext()) {
            return "[]";
        }

        StringBuilder sb = new StringBuilder();
        sb.append("[");
        while (true) {
            Item item = it.next();
            sb.append(item);
            if (!it.hasNext()) {
                return sb.append("]").toString();
            }

            sb.append(", ");
        }
    }

    public void combineList(CircularLinkedList<Item> b) {
        // 原表的尾和第二個連結串列的頭相連
        last.next = b.first;
        // 第二個連結串列的尾和原表的頭相連
        b.last.next = first;
        // 更新原表的last
        last = b.last;
        // 更新長度
        N += b.N;
    }

    public static void main(String[] args) {
        CircularLinkedList<String> a = new CircularLinkedList<>();

        a.push("1");
        a.push("2");
        a.push("3");
        System.out.println(a.size());
        a.set(1, "22");
        System.out.println(a.get(1));
        a.clear();
        a.add("1");
        a.add("2");
        a.add("3");
        a.insert(2, "4");
        a.remove(1);
        System.out.println(a); // [1, 4, 3]
        System.out.println(a.indexOf("4")); // 1

        CircularLinkedList<String> b = new CircularLinkedList<>("10", "40", "30");
        a.combineList(b);
        System.out.println(a);
    }
}

除了add、push、indexOf和Iterator的實現，其餘程式碼沒有改動。

add和push在新增第一個元素時增加了一行last.next = first;表示last的下一個結點就是first。另外add方法在後續新增元素時，由於實現中last = new Node();，此時last.next還等於null，也需要last.next = first;。而push方法在後續新增元素時，因為改變的是first，last.next沒有改變，只是指向了新的first而已，所以無需那句last.next = first;。

而indexOf方法，以連結串列的長度作為遍歷結束的標誌，按照習慣，從first開始，遍歷一遍連結串列後停止。

for (Node cur = first; i < N; cur = cur.next) {
    i++;
}

Iterator中hasNext和next的實現其實和上面indexOf的實現是一個原理。

拼接兩個迴圈連結串列

新增了一個方法！combineList可以將兩個單迴圈連結串列首尾相連，形成一個更大的單迴圈連結串列。

public void combineList(CircularLinkedList<Item> b) {
    // 原表的尾和第二個連結串列的頭相連
    last.next = b.first;
     // 第二個連結串列的尾和原表的頭相連
    b.last.next = first;
    // 更新原表的last
    last = b.last;
    // 更新長度
    N += b.N;
}

若連結串列A連結連結串列B：

1. 將迴圈連結串列A的last和迴圈連結串列B的first相連；
2. 將迴圈連結串列B的last和迴圈連結串列A的first相連；
3. 更新新連結串列的last為連結串列B的last

看圖更直觀。

---

by @sunhaiyu

2017.8.1