有一種較為特殊的單向連結串列，如下：

這種連結串列一個特點是，除了next指向下一個節點外，它還多了一個指標jump,這個指標指向佇列中的某一個節點,這個節點可以是當前節點自己，也可以是佇列中的其他節點。例如上圖，節點0的jump指標指向了最後一個節點，而節點1的jump指標指向了它自己。這種連結串列有一個專門的名稱，叫Posting List.

要求，你設計一個演算法，複製給定的一個Posting List。演算法的時間複雜度是O(n), 演算法除了執行分配賦值節點所需的記憶體外，不能分配多餘記憶體，例如給定上面佇列，你的演算法智慧多分配五個節點的記憶體。演算法可以更改原佇列，當更改後，需要將佇列恢復原狀。

這道題目有一定難度，難點在於如何複製jump指標。如果沒有jump指標，那麼複製一個單項鍊表是很容易的。我們先設想一個最簡單的做法，先不考慮jump節點，先把單項佇列複製出來，然後再考慮如何設定新佇列節點的jump指標。

一個做法是，給定一個具體的節點，然後將佇列遍歷以便，判斷jump節點與當前節點的距離，例如給定節點0，我們通過遍歷得知，jump指向的節點，與當前節點有四個節點的距離，然後在新複製的佇列中，從新賦值的節點0往後走4個節點，找到新拷貝的節點4，接著把新節點0的jump指標指向新生成的節點4.

上面做法有個問題就是，設定每個節點的jump指標時，都得將佇列遍歷一次，這樣的話，整個演算法複雜度會是 O(n^2).但題目要求，演算法複雜度必須是O(n),由此，我們必須重新思考新的演算法。

我的做法是這樣的，首先遍歷佇列，為每個節點生成一個拷貝：

接著，把原節點的next指標指向對應的拷貝節點，拷貝節點的next指標指向原節點原來next指向的節點：

經過上面的變動，原節點跟它自己的拷貝連線了起來，同時原佇列的連線性任然得以保持，例如圖中，上面的節點0要抵達它的下一個節點，那麼只需要通過next指標到達它的拷貝節點，也就是下面的節點0，然後再通過拷貝節點的next指標就可以抵達上面的節點1了。

此時，新節點的jump指標就容易設定了，例如要設定新拷貝的節點0的jump指標，先通過它原節點的jump指標，找到節點4，然後再通過節點4的next指標，找到節點4的拷貝節點，也就是上圖下方的節點4，最後把拷貝節點0的 jump指標設定成對應的上圖下方的節點4即可。如果用node來表示原節點，cpNode來表示對應的拷貝節點，下面程式碼就可以設定拷貝節點的jump指標：

cpNode = node.next; //獲得拷貝節點
cpNode.jump = node.jump.next; 

遍歷原佇列的每個節點，採取上面的操作，這樣，新拷貝節點的jump指標就能夠正確的設定了。

最後，恢復原佇列以及設定拷貝節點的next指標。由於拷貝節點的next指標，指向原節點原來next指向的物件，由此只要把原節點的next設定為拷貝節點的next指向的物件，就可以復原原來的狀態。拷貝節點0的next要想指向拷貝節點1，首先通過它自己的next，找到原節點1，也就是圖中上方的節點1，然後通過原節點1的next找到對應的拷貝節點，也就是圖中下方的節點1，於是把拷貝節點0的next指標就可以指向拷貝節點1，從而實現圖中下方的節點0通過next指標指向拷貝節點1。實現程式碼如下：

cpNode = node.next; //獲得拷貝節點
node.next = cpNode.next; //恢復原節點的next指標
node = node.next; 
cpNode.next = node.next;  //將當前拷貝節點的next指標指向下一個拷貝節點。

上面演算法，每一步驟的時間複雜度都是o(n),同時我們只為新節點分配記憶體，除此只為，並沒有多餘的記憶體分配，因此，演算法符合題目要求。我們看看具體的程式碼實現：

public class ListUtility {
    private Node tail;
    private Node head;
    private int listLen = 0;
    private int postingListLen = 0;
    HashMap<Integer, PostingNode> map = new HashMap<Integer, PostingNode>();

    PostingNode createPostingList(int nodeNum) {
        if (nodeNum <= 0) {
            return null;
        }

        postingListLen = nodeNum;
        PostingNode postingHead = null, postingTail = null;
        PostingNode postingNode = null;
        int val = 0;
        while (nodeNum > 0) {
            if (postingNode == null) {
                postingHead = new PostingNode();
                postingHead.val = val;
                postingNode = postingHead;
                postingTail = postingHead;

            } else {
                postingNode.next = new PostingNode();
                postingNode = postingNode.next;
                postingNode.val = val;
                postingNode.next = null;
                postingTail = postingNode;
            }

            map.put(val, postingNode);
            val++;
            nodeNum--;
        }

       PostingNode tempHead = postingHead;
       createJumpNode(tempHead);

        return postingHead;
    }

    private void createJumpNode(PostingNode pHead) {
        Random ra = new Random();

        while (pHead != null) {
            int n = ra.nextInt(postingListLen);
            pHead.jump = map.get(n);
            pHead = pHead.next;
        }
    }

    public void printPostingList(PostingNode pHead) {
        while (pHead != null) {
            System.out.print("(node val:" + pHead.val + " jump val : " + pHead.jump.val + " ) ->");
            pHead = pHead.next;
        }

        System.out.print(" null ");
    }

    ....
 }

上面的程式碼用於建立一個Posting list, 連結串列的複雜演算法實現在類PostingList.java中，程式碼如下：

public class PostingList {
    private PostingNode head ;
    private PostingNode copyHead;

    public PostingList(PostingNode node) {
        this.head = node;
    }

    public PostingNode copyPostingList() {
        createPostingNodes();
        createJumpNodes();
        ajustNextPointer();

        return copyHead;
    }

    private void createPostingNodes() {
        PostingNode node = null;
        PostingNode tempHead = head;
        while (tempHead != null) {
            node = new PostingNode();
            node.next = tempHead.next;
            node.val = tempHead.val;
            tempHead.next = node;
            tempHead = node.next;

        }
    }

    private void createJumpNodes() {
        PostingNode temp = head;
        copyHead = temp.next;

        while (temp != null) {
            PostingNode cpNode = temp.next;
            cpNode.jump = temp.jump.next;
            temp = cpNode.next;
        }
    }


    private void ajustNextPointer() {
        PostingNode temp = head;
        while (temp != null) {
            PostingNode cpNode = temp.next;
            temp.next = cpNode.next;
            temp = temp.next;
            if (temp != null) {
                cpNode.next = temp.next;    
            } else {
                cpNode.next = null;
            }

        }
    }
 }

createPostingNodes 執行的是步驟1，它為每一個節點生成一個拷貝。
createJumpNodes 執行步驟2，它為每一個拷貝節點設定他們對應的jump指標
ajustNextPointer 執行步驟3，它調整原佇列節點的next指標，以及設定拷貝節點的next指標。

每個函式裡，只包含一個while迴圈，用於遍歷佇列，因此演算法實現的複雜度是o(n).具體的程式碼講解和除錯演示過程，請參看視訊。

歡迎關注公眾號，讓我們一起學習，交流，成長：