数据结构链表各种问题

一：链表原理

        链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。

        单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Node。向外暴露的只有一个头节点（Head），我们对链表的所有操作，都是直接或者间接地通过其头节点来进行的。 

        上图中最左边的节点即为头结点（Head），但是添加节点的顺序是从右向左的，添加的新节点会被作为新节点。最先添加的节点对下一节点的引用可以为空。引用是引用下一个节点而非下一个节点的对象。因为有着不断的引用，所以头节点就可以操作所有节点了。 
        下图描述了单向链表存储情况。存储是分散的，每一个节点只要记录下一节点，就把所有数据串了起来，形成了一个单向链表。 

       节点（Node）是由一个需要储存的对象及对下一个节点的引用组成的。也就是说，节点拥有两个成员：储存的对象、对下一个节点的引用。下面图是具体的说明：

二、链表的实现

[html]  view plain  copy

1. package com.zjn.LinkAndQueue;  
2.   
3. /**  
4.  * 自定义链表设计  
5.  *   
6.  * @author zjn  
7.  *  
8.  */  
9. public class MyLink {  
10.     Node head = null; // 头节点  
11.   
12.     /**  
13.      * 链表中的节点，data代表节点的值，next是指向下一个节点的引用  
14.      *   
15.      * @author zjn  
16.      *  
17.      */  
18.     class Node {  
19.         Node next = null;// 节点的引用，指向下一个节点  
20.         int data;// 节点的对象，即内容  
21.   
22.         public Node(int data) {  
23.             this.data = data;  
24.         }  
25.     }  
26.   
27.     /**  
28.      * 向链表中插入数据  
29.      *   
30.      * @param d  
31.      */  
32.     public void addNode(int d) {  
33.         Node newNode = new Node(d);// 实例化一个节点  
34.         if (head == null) {  
35.             head = newNode;  
36.             return;  
37.         }  
38.         Node tmp = head;  
39.         while (tmp.next != null) {  
40.             tmp = tmp.next;  
41.         }  
42.         tmp.next = newNode;  
43.     }  
44.   
45.     /**  
46.      *   
47.      * @param index:删除第index个节点  
48.      * @return  
49.      */  
50.     public boolean deleteNode(int index) {  
51.         if (index < 1 || index > length()) {  
52.             return false;  
53.         }  
54.         if (index == 1) {  
55.             head = head.next;  
56.             return true;  
57.         }  
58.         int i = 1;  
59.         Node preNode = head;  
60.         Node curNode = preNode.next;  
61.         while (curNode != null) {  
62.             if (i == index) {  
63.                 preNode.next = curNode.next;  
64.                 return true;  
65.             }  
66.             preNode = curNode;  
67.             curNode = curNode.next;  
68.             i++;  
69.         }  
70.         return false;  
71.     }  
72.   
73.     /**  
74.      *   
75.      * @return 返回节点长度  
76.      */  
77.     public int length() {  
78.         int length = 0;  
79.         Node tmp = head;  
80.         while (tmp != null) {  
81.             length++;  
82.             tmp = tmp.next;  
83.         }  
84.         return length;  
85.     }  
86.   
87.     /**  
88.      * 在不知道头指针的情况下删除指定节点  
89.      *   
90.      * @param n  
91.      * @return  
92.      */  
93.     public boolean deleteNode11(Node n) {  
94.         if (n == null || n.next == null)  
95.             return false;  
96.         int tmp = n.data;  
97.         n.data = n.next.data;  
98.         n.next.data = tmp;  
99.         n.next = n.next.next;  
100.         System.out.println("删除成功！");  
101.         return true;  
102.     }  
103.   
104.     public void printList() {  
105.         Node tmp = head;  
106.         while (tmp != null) {  
107.             System.out.println(tmp.data);  
108.             tmp = tmp.next;  
109.         }  
110.     }  
111.   
112.     public static void main(String[] args) {  
113.         MyLink list = new MyLink();  
114.         list.addNode(5);  
115.         list.addNode(3);  
116.         list.addNode(1);  
117.         list.addNode(2);  
118.         System.out.println("linkLength:" + list.length());  
119.         System.out.println("head.data:" + list.head.data);  
120.         list.printList();  
121.         list.deleteNode(4);  
122.         System.out.println("After deleteNode(4):");  
123.         list.printList();  
124.     }  
125. }  

运行结果如下：

三、链表相关的常见面试题总结

 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.     }