和链表有关面试题

面试中被问链表的题目我就不再多说，直接总结题目。

1、将链表逆序

这个问题很早就研究过，但后来一次面试的时候我突然紧张忘了，没答上来。
我不知道大家的解法是什么，我的解法是遍历链表是用前插发插入节点，最后的链表就是逆序的。

[python]  view plain copy

1. class ListNode:  
2.     def __init__(self, x):  
3.         self.val = x  
4.         self.next = None  
5. class Solution:  
6.     def resverse(self, head):  
7.         print id(head)  
8.         if None == head or None == head.next:  
9.             return head  
10.         p = head.next  
11.         head.next = None  
12.         while None != p:  
13.            q = p.next  
14.            p.next = head  
15.            head = p  
16.            p = q  
17.         return head  

2、判断链表中是否有环

这个问题似乎是有固定的解法即就是设置快、慢两个指针，若指针能相遇，则说明有环，如果慢指针为 None了，就说明没有环

[python]  view plain copy

1. class ListNode:  
2.     def __init__(self, x):  
3.         self.val = x  
4.         self.next = None  
5. class Solution:  
6.   
7.     def hasCycle(self, head):  
8.         if None == head or None == head.next:  
9.             return False  
10.         p = head  
11.         q = head.next  
12.         while q != None and p != q:  
13.             p = p.next  
14.             q = q.next  
15.             if None != q:  
16.                 q = q.next  
17.         return p == q  

3、既然链表中有环，求取环的长度

仔细想想，这其实和我们小学的追击问题是一样的，甲乙相遇的条件是 S甲 - S2 = n * 周长。另外，因为已经找到了环上的一个点，那么直接从该点开始，下次到该点时所走长度就是环的长度。

[python]  view plain copy

1. class Solution:  
2.   
3.     def cycleLen(self, head):  
4.         if None == head or None == head.next:  
5.             return 0  
6.         p = head  
7.         q = head.next  
8.         while q != None and p != q:  
9.             p = p.next  
10.             q = q.next  
11.             if None != q:  
12.                 q = q.next  
13.         if p != q:  
14.             return 0  
15.         ret_len = 1  
16.         p = p.next  
17.         while p != q:  
18.             ret_len += 1  
19.             p = p.next  
20.         return ret_len  

4、判断两个链表的第一个公共点

求公共节点的时候需要分三种情况：两个都没环，一个有环，两个都没环，后两种先不讨论了。

[python]  view plain copy

1. class ListNode:  
2.     def __init__(self, x):  
3.         self.val = x  
4.         self.next = None  
5.   
6. class Solution:  
7.     def getLen(self, head):  
8.         len = 0  
9.         while head != None:  
10.             len += 1  
11.             head = head.next  
12.         return len  
13.     def getCommonNode(self, head1, head2):  
14.         len1 = self.getLen(head1)  
15.         len2 = self.getLen(head2)  
16.         p = head1  
17.         q = head2  
18.         while len1 - len2 > 0:  
19.             p = p.next  
20.             len1 -= 1  
21.         while len1 - len2 < 0:  
22.             q = q.next  
23.             len2 -= 1  
24.         while p != None:  
25.             if p == q:  
26.                 return q  
27.             p = p.next  
28.             q = q.next  
29.         pass  

5、单向链表中，如何在给定节点前快速插入一个节点？

大家都知道，链表插入节点时必须要得到插入位置的前一个节点，但这道题中并没有给出，那么我们是不是应该再遍历一次，找到插入位置的前一个节点？这样是可行的，但不是面试官想要的。那么应该怎样做呢？换个角度，我们在当前节点前插入节点是很难的，但是在当前节点后插入节点又是很容易的，所以我们可以先将节点插入到当前节点之后，然后交换一下数据。

[python]  view plain copy

1. class ListNode:  
2.     def __init__(self, x):  
3.         self.val = x  
4.         self.next = None  
5.   
6. class Solution:  
7.    def insertNode(self, index, node):  
8.        node.next = index.next  
9.        index.next = node  
10.        index.val, node.val = node.val, index.val  

6、对于一个数组，将所有奇数移动到偶数前面

[python]  view plain copy

1. def fun(self, arr):  
2.    p = 0  
3.    q = len(arr) - 1  
4.    while p < q:  
5.        while p < q and arr[p] & 0x01 != 0:  
6.                p += 1  
7.        while p < q and arr[q] & 0x01 == 0:  
8.                q -= 1  
9.        arr[p], arr[q] = arr[q], arr[p]