Java中的链表数据结构

首先，我们来定义一个链表的数据结构，如下：

 1 public class Link {
 2     private int value;
 3     private Link next;
 4     public void set_Value(int m_Value) {
 5         this.value = m_Value;
 6     }
 7     public int get_Value() {
 8         return value;
 9     }
10     public void set_Next(Link m_Next) {
11         this.next = m_Next;
12     }
13     public Link get_Next() {
14         return next;
15     }
16 }

有了这个数据结构后，我们需要一个方法来生成和输出链表，其中链表中每个元素的值采用的是随机数。

生成链表的代码如下：

 1     public static Link init(int count, int maxValue)
 2     {
 3         Link list = new Link();
 4         Link temp = list;
 5         Random r = new Random();
 6         temp.set_Value(Integer.MIN_VALUE);
 7         for (int i = 0; i < count; i++)
 8         {
 9             Link node = new Link();
10             node.set_Value(r.nextInt(maxValue));
11             temp.set_Next(node);
12             temp=node;
13         }
14         temp.set_Next(null);
15         return list;
16     }
17
18     public static Link init(int count)
19     {
20         return init(count, Integer.MAX_VALUE);
21     }

对于链表的头结点，我们是不存储任何信息的，因此将其值设置为Integer.MIN_VALUE。我们重载了生成链表的方法。

下面是打印链表信息的方法：

 1     public static void printList(Link list)
 2     {
 3         if (list == null || list.get_Next() == null)
 4         {
 5             System.out.println("The list is null or empty.");
 6             return;
 7         }
 8         Link temp = list.get_Next();
 9         StringBuffer sb = new StringBuffer();
10         while(temp != null)
11         {
12             sb.append(temp.get_Value() + "->");
13             temp=temp.get_Next();
14         }
15         System.out.println(sb.substring(0, sb.length() - 2));
16     }

好了，有了以上这些基础的方法， 我们就可以深入探讨链表相关的面试题了。

• 链表反转 思路：有两种方法可以实现链表反转，第一种是直接循环每个元素，修改它的Next属性；另一种是采取递归的方式。 首先来看直接循环的方式：

   1     public static Link Reverve(Link list)
   2     {
   3         if (list == null || list.get_Next() == null || list.get_Next().get_Next() == null)
   4         {
   5             System.out.println("list is null or just contains 1 element, so do not need to reverve.");
   6             return list;
   7         }
   8         Link current = list.get_Next();
   9         Link next = current.get_Next();
  10         current.set_Next(null);
  11         while(next != null)
  12         {
  13             Link temp = next.get_Next();
  14             next.set_Next(current);
  15             current = next;
  16             next = temp;
  17         }
  18         list.set_Next(current);
  19
  20         return list;
  21     }

  然后是递归方式：

   1     public static Link RecursiveReverse(Link list)
   2     {
   3         if (list == null || list.get_Next() == null || list.get_Next().get_Next() == null)
   4         {
   5             System.out.println("list is null or just contains 1 element, so do not need to reverve.");
   6             return list;
   7         }
   8
   9         list.set_Next(Recursive(list.get_Next()));
  10
  11         return list;
  12     }
  13
  14
  15     private static Link Recursive(Link list)
  16     {
  17         if (list.get_Next() == null)
  18         {
  19             return list;
  20         }
  21         Link temp = Recursive(list.get_Next());
  22         list.get_Next().set_Next(list);
  23         list.set_Next(null);
  24
  25         return temp;
  26 

• 输出指定位置的元素（倒数第N个元素） 思路：采用两个游标来遍历链表，第1个游标先走N步，然后两个游标同时前进，当第一个游标到最后时，第二个游标就是想要的元素。

   1     public static Link find(Link list, int rPos)
   2     {
   3         if (list == null || list.get_Next() == null)
   4         {
   5             return null;
   6         }
   7         int i = 1;
   8         Link first = list.get_Next();
   9         Link second = list.get_Next();
  10         while(true)
  11         {
  12             if (i==rPos || first == null) break;
  13             first = first.get_Next();
  14             i++;
  15         }
  16         if (first == null)
  17         {
  18             System.out.println("The length of list is less than " + rPos + ".");
  19             return null;
  20         }
  21         while(first.get_Next() != null)
  22         {
  23             first = first.get_Next();
  24             second = second.get_Next();
  25         }
  26
  27         return second;
  28     }

• 删除指定节点 思路：可以分情况讨论，如果指定节点不是尾节点，那么可以采用取巧的方式，将指定节点的值修改为下一个节点的值，将指定节点的Next属性设置为Next.Next；但如果指定节点为尾节点，那么只能是从头开始遍历。

   1     public static void delete(Link list, Link element)
   2     {
   3         if (element.get_Next() != null)
   4         {
   5             element.set_Value(element.get_Next().get_Value());
   6             element.set_Next(element.get_Next().get_Next());
   7         }
   8         else
   9         {
  10             Link current = list.get_Next();
  11             while(current.get_Next() != element)
  12             {
  13                 current = current.get_Next();
  14             }
  15             current.set_Next(null);
  16         }
  17     }

• 删除重复节点 思路：采用hashtable来存取链表中的元素，遍历链表，当指定节点的元素在hashtable中已经存在，那么删除该节点。

   1     public static void removeDuplicate(Link list)
   2     {
   3         if (list == null || list.get_Next() == null || list.get_Next().get_Next() == null) return;
   4         Hashtable table = new Hashtable();
   5         Link cur = list.get_Next();
   6         Link next = cur.get_Next();
   7         table.put(cur.get_Value(), 1);
   8         while(next != null)
   9         {
  10             if (table.containsKey(next.get_Value()))
  11             {
  12                 cur.set_Next(next.get_Next());
  13                 next = next.get_Next();
  14             }
  15             else
  16             {
  17                 table.put(next.get_Value(), 1);
  18                 cur= next;
  19                 next = next.get_Next();
  20             }
  21
  22         }
  23     }

• 寻找链表中间节点 思路：采用两个游标的方式，第一个游标每次前进两步，第二个游标每次前进一步，当第一个游标到最后时，第二个游标就是中间位置。需要注意的是，如果链表元素的个数是偶数，那么中间元素应该是两个。

   1     public static void findMiddleElement(Link list)
   2     {
   3         if (list == null || list.get_Next() == null) return;
   4         System.out.println("The Middle element is:");
   5         if (list.get_Next().get_Next() == null)
   6         {
   7             System.out.println(list.get_Next().get_Value());
   8         }
   9         Link fast = list.get_Next();
  10         Link slow = list.get_Next();
  11         while(fast.get_Next() != null && fast.get_Next().get_Next() != null)
  12         {
  13             fast = fast.get_Next().get_Next();
  14             slow = slow.get_Next();
  15         }
  16
  17         if (fast != null && fast.get_Next() == null)
  18         {
  19             System.out.println(slow.get_Value());
  20         }
  21         else
  22         {
  23             System.out.println(slow.get_Value());
  24             System.out.println(slow.get_Next().get_Value());
  25         }
  26     }

• 链表元素排序 思路：链表元素排序，有两种方式，一种是链表元素本身的排序，一种是链表元素值得排序。第二种方式更简单、灵活一些。

   1     public static void Sort(Link list)
   2     {
   3         if (list == null || list.get_Next() == null || list.get_Next().get_Next() == null)
   4         {
   5             return;
   6         }
   7         Link current = list.get_Next();
   8         Link next = current.get_Next();
   9         while(current.get_Next() != null)
  10         {
  11             while(next != null)
  12             {
  13                 if (current.get_Value() > next.get_Value())
  14                 {
  15                     int temp = current.get_Value();
  16                     current.set_Value(next.get_Value());
  17                     next.set_Value(temp);
  18                 }
  19                 next = next.get_Next();
  20             }
  21             current = current.get_Next();
  22             next = current.get_Next();
  23         }
  24     }

• 判断链表是否有环，如果有，找出环上的第一个节点 思路：可以采用两个游标的方式判断链表是否有环，一个游标跑得快，一个游标跑得慢。当跑得快的游标追上跑得慢的游标时，说明有环；当跑得快的游标跑到尾节点时，说明无环。 至于如何找出换上第一个节点，可以分两步，首先确定环上的某个节点，计算头结点到该节点的距离以及该节点在环上循环一次的距离，然后建立两个游标，分别指向头结点和环上的节点，并将距离平摊（哪个距离大，先移动哪个游标，直至两个距离相等），最后同时移动两个游标，碰到的第一个相同元素，就是环中的第一个节点。

   1     public static Link getLoopStartNode(Link list)
   2     {
   3         if (list == null || list.get_Next() == null || list.get_Next().get_Next() == null)
   4         {
   5             return null;
   6         }
   7         int m = 1, n = 1;
   8         Link fast = list.get_Next();
   9         Link slow = list.get_Next();
  10         while(fast != null && fast.get_Next() != null)
  11         {
  12             fast = fast.get_Next().get_Next();
  13             slow = slow.get_Next();
  14             if (fast == slow) break;
  15             m++;
  16         }
  17         if (fast != slow)
  18         {
  19             return null;
  20         }
  21         Link temp = fast;
  22         while(temp.get_Next() != fast)
  23         {
  24             temp = temp.get_Next();
  25             n++;
  26         }
  27         Link node1 = list.get_Next();
  28         Link node2 = fast;
  29         if (m < n)
  30         {
  31             for (int i = 0; i < n - m; i++)
  32             {
  33                 node2 = node2.get_Next();
  34             }
  35         }
  36         if (m > n)
  37         {
  38             for (int i = 0; i < m - n; i++)
  39             {
  40                 node1 = node1.get_Next();
  41             }
  42         }
  43         while(true)
  44         {
  45             if (node1 == node2)
  46             {
  47                 break;
  48             }
  49             node1 = node1.get_Next();
  50             node2 = node2.get_Next();
  51         }
  52
  53         return node1;
  54
  55     }

• 判断两个链表是否相交 思路：判断两个链表的尾节点是否相同，如果相同，一定相交

   1     public static boolean isJoint(Link list1, Link list2)
   2     {
   3         if (list1 == null || list2 == null || list1.get_Next() == null || list2.get_Next() == null)
   4         {
   5             return false;
   6         }
   7         Link node1 = list1;
   8         Link node2 = list2;
   9         while(node1.get_Next() != null)
  10         {
  11             node1 = node1.get_Next();
  12         }
  13         while(node2.get_Next() != null)
  14         {
  15             node2 = node2.get_Next();
  16         }
  17
  18         return node1 == node2;
  19     }

• 合并两个有序链表 思路：新建一个链表，然后同时遍历两个有序链表，比较其大小，将元素较小的链表向前移动，直至某一个链表元素为空。然后将非空链表上的所有元素追加到新建链表中。

   1     public static Link merge(Link list1, Link list2)
   2     {
   3         Link list = new Link();
   4         list.set_Value(Integer.MIN_VALUE);
   5         Link current1 = list1.get_Next();
   6         Link current2 = list2.get_Next();
   7         Link current = list;
   8         while(current1 != null && current2 != null)
   9         {
  10             Link temp = new Link();
  11             if (current1.get_Value() > current2.get_Value())
  12             {
  13                 temp.set_Value(current2.get_Value());
  14                 current2 = current2.get_Next();
  15             }
  16             else
  17             {
  18                 temp.set_Value(current1.get_Value());
  19                 current1 = current1.get_Next();
  20             }
  21             current.set_Next(temp);
  22             current = temp;
  23         }
  24         if (current1 != null)
  25         {
  26             while(current1 != null)
  27             {
  28                 Link temp = new Link();
  29                 temp.set_Value(current1.get_Value());
  30                 current.set_Next(temp);
  31                 current = temp;
  32                 current1 = current1.get_Next();
  33             }
  34         }
  35
  36         if (current2 != null)
  37         {
  38             while(current2 != null)
  39             {
  40                 Link temp = new Link();
  41                 temp.set_Value(current2.get_Value());
  42                 current.set_Next(temp);
  43                 current = temp;
  44                 current2 = current2.get_Next();
  45             }
  46         }
  47
  48         current.set_Next(null);
  49
  50         return list;
  51     }

• 交换链表中任意两个元素（非头结点） 思路：首先需要保存两个元素的pre节点和next节点，然后分别对pre节点和next节点的Next属性重新赋值。需要注意的是，当两个元素师相邻元素时，需要特殊处理，否则会将链表陷入死循环。

   1     public static void swap(Link list, Link element1, Link element2)
   2     {
   3         if (list == null || list.get_Next() == null || list.get_Next().get_Next() == null ||
   4                 element1 == null || element2 == null || element1 == element2)
   5             return;
   6
   7         Link pre1 = null, pre2 = null, next1 = null, next2 = null;
   8         Link cur1=element1, cur2=element2;
   9         Link temp = list.get_Next();
  10         boolean bFound1 = false;
  11         boolean bFound2 = false;
  12         while(temp != null)
  13         {
  14             if(temp.get_Next() == cur1)
  15             {
  16                 pre1=temp;
  17                 next1 = temp.get_Next().get_Next();
  18                 bFound1 = true;
  19             }
  20             if (temp.get_Next() == cur2)
  21             {
  22                 pre2 = temp;
  23                 next2 = temp.get_Next().get_Next();
  24                 bFound2=true;
  25             }
  26             if (bFound1 && bFound2) break;
  27             temp = temp.get_Next();
  28         }
  29
  30         if (cur1.get_Next() == cur2)
  31         {
  32             temp = cur2.get_Next();
  33             pre1.set_Next(cur2);
  34             cur2.set_Next(cur1);
  35             cur1.set_Next(temp);
  36         }
  37         else if (cur2.get_Next() == cur1)
  38         {
  39             temp = cur1.get_Next();
  40             pre2.set_Next(cur1);
  41             cur1.set_Next(cur2);
  42             cur2.set_Next(temp);
  43         }
  44         else
  45         {
  46             pre1.set_Next(cur2);
  47             cur1.set_Next(next2);
  48             pre2.set_Next(cur1);
  49             cur2.set_Next(next1);
  50         }
  51     }

  这里，还有另外一种取巧的方法，就是直接交换两个元素的值，而不需要修改引用。