資料結構連結串列各種問題

一：連結串列原理

        連結串列是一種資料結構，和陣列同級。比如，Java中我們使用的ArrayList，其實現原理是陣列。而LinkedList的實現原理就是連結串列了。連結串列在進行迴圈遍歷時效率不高，但是插入和刪除時優勢明顯。下面對單向連結串列做一個介紹。

        單向連結串列是一種線性表，實際上是由節點（Node）組成的，一個連結串列擁有不定數量的節點。其資料在記憶體中儲存是不連續的，它儲存的資料分散在記憶體中，每個結點只能也只有它能知道下一個結點的儲存位置。由N各節點（Node）組成單向連結串列，每一個Node記錄本Node的資料及下一個Node。向外暴露的只有一個頭節點（Head），我們對連結串列的所有操作，都是直接或者間接地通過其頭節點來進行的。 

        上圖中最左邊的節點即為頭結點（Head），但是新增節點的順序是從右向左的，新增的新節點會被作為新節點。最先新增的節點對下一節點的引用可以為空。引用是引用下一個節點而非下一個節點的物件。因為有著不斷的引用，所以頭節點就可以操作所有節點了。 
        下圖描述了單向連結串列儲存情況。儲存是分散的，每一個節點只要記錄下一節點，就把所有資料串了起來，形成了一個單向連結串列。 

       節點（Node）是由一個需要儲存的物件及對下一個節點的引用組成的。也就是說，節點擁有兩個成員：儲存的物件、對下一個節點的引用。下面圖是具體的說明：

二、連結串列的實現

三、連結串列相關的常見面試題總結

 1. 連結串列反轉

調整指標的指向，反轉後連結串列的頭結點是原始連結串列的尾節點。

[html] view plain copy

1. /**  
2.      * 連結串列反轉  
3.      *   
4.      * @param head  
5.      * @return  
6.      */  
7.     public Node ReverseIteratively(Node head) {  
8.         Node pReversedHead = head;  
9.         Node pNode = head;  
10.         Node pPrev = null;  
11.         while (pNode != null) {  
12.             Node pNext = pNode.next;  
13.             if (pNext == null) {  
14.                 pReversedHead = pNode;  
15.             }  
16.             pNode.next = pPrev;  
17.             pPrev = pNode;  
18.             pNode = pNext;  
19.         }  
20.         this.head = pReversedHead;  
21.         return this.head;  
22.     }  

執行結果：

2.  查詢單連結串列的中間節點

    採用快慢指標的方式查詢單連結串列的中間節點，快指標一次走兩步，慢指標一次走一步，當快指標走完時，慢指標剛好到達中間節點。

[html] view plain copy

1. /**  
2.      * 連結串列反轉  
3.      *   
4.      * @param head  
5.      * @return  
6.      */  
7.     public Node ReverseIteratively(Node head) {  
8.         Node pReversedHead = head;  
9.         Node pNode = head;  
10.         Node pPrev = null;  
11.         while (pNode != null) {  
12.             Node pNext = pNode.next;  
13.             if (pNext == null) {  
14.                 pReversedHead = pNode;  
15.             }  
16.             pNode.next = pPrev;  
17.             pPrev = pNode;  
18.             pNode = pNext;  
19.         }  
20.         this.head = pReversedHead;  
21.         return this.head;  
22.     }  

3.查詢倒數第k個元素

        採用兩個指標P1,P2，P1先前移K步，然後P1、P2同時移動，當p1移動到尾部時，P2所指位置的元素即倒數第k個元素 。

[html] view plain copy

1. /**  
2.      * 查詢倒數 第k個元素  
3.      *   
4.      * @param head  
5.      * @param k  
6.      * @return  
7.      */  
8.     public Node findElem(Node head, int k) {  
9.         if (k < 1 || k > this.length()) {  
10.             return null;  
11.         }  
12.         Node p1 = head;  
13.         Node p2 = head;  
14.         for (int i = 0; i < k; i++)// 前移k步  
15.             p1 = p1.next;  
16.         while (p1 != null) {  
17.             p1 = p1.next;  
18.             p2 = p2.next;  
19.         }  
20.         return p2;  
21.     }  

4. 對連結串列進行排序

[html] view plain copy

1. /**  
2.      * 排序  
3.      *   
4.      * @return  
5.      */  
6.     public Node orderList() {  
7.         Node nextNode = null;  
8.         int tmp = 0;  
9.         Node curNode = head;  
10.         while (curNode.next != null) {  
11.             nextNode = curNode.next;  
12.             while (nextNode != null) {  
13.                 if (curNode.data > nextNode.data) {  
14.                     tmp = curNode.data;  
15.                     curNode.data = nextNode.data;  
16.                     nextNode.data = tmp;  
17.                 }  
18.                 nextNode = nextNode.next;  
19.             }  
20.             curNode = curNode.next;  
21.         }  
22.         return head;  
23.     }  

執行結果：

5. 刪除連結串列中的重複節點

[html] view plain copy

1. /**  
2.      * 刪除重複節點  
3.      */  
4.     public void deleteDuplecate(Node head) {  
5.         Node p = head;  
6.         while (p != null) {  
7.             Node q = p;  
8.             while (q.next != null) {  
9.                 if (p.data == q.next.data) {  
10.                     q.next = q.next.next;  
11.                 } else  
12.                     q = q.next;  
13.             }  
14.             p = p.next;  
15.         }  
16.   
17.     }  

6.  從尾到頭輸出單連結串列，採用遞迴方式實現

[html] view plain copy

1. /**  
2.      * 從尾到頭輸出單連結串列，採用遞迴方式實現  
3.      *   
4.      * @param pListHead  
5.      */  
6.     public void printListReversely(Node pListHead) {  
7.         if (pListHead != null) {  
8.             printListReversely(pListHead.next);  
9.             System.out.println("printListReversely:" + pListHead.data);  
10.         }  
11.     }  

7.  判斷連結串列是否有環，有環情況下找出環的入口節點

[html] view plain copy

1. /**  
2.      * 判斷連結串列是否有環，單向連結串列有環時，尾節點相同  
3.      *   
4.      * @param head  
5.      * @return  
6.      */  
7.     public boolean IsLoop(Node head) {  
8.         Node fast = head, slow = head;  
9.         if (fast == null) {  
10.             return false;  
11.         }  
12.         while (fast != null && fast.next != null) {  
13.             fast = fast.next.next;  
14.             slow = slow.next;  
15.             if (fast == slow) {  
16.                 System.out.println("該連結串列有環");  
17.                 return true;  
18.             }  
19.         }  
20.         return !(fast == null || fast.next == null);  
21.     }  
22.   
23.     /**  
24.      * 找出連結串列環的入口  
25.      *   
26.      * @param head  
27.      * @return  
28.      */  
29.     public Node FindLoopPort(Node head) {  
30.         Node fast = head, slow = head;  
31.         while (fast != null && fast.next != null) {  
32.             slow = slow.next;  
33.             fast = fast.next.next;  
34.             if (slow == fast)  
35.                 break;  
36.         }  
37.         if (fast == null || fast.next == null)  
38.             return null;  
39.         slow = head;  
40.         while (slow != fast) {  
41.             slow = slow.next;  
42.             fast = fast.next;  
43.         }  
44.         return slow;  
45.     }