链表面试题整理

 

某本书上面说了，链表这个东西，实际用的并不多，但是可以提供很好的考察面试者编程技巧和思维能力的素材。这里总结一下，见过的面试题和对应的候选解法。

题一、 给定单链表，检测是否有环。
   
1)使用两个指针p1,p2从链表头开始遍历，p1每次前进一步，p2每次前进两步。如果p2到达链表尾部，说明无环，否则p1、p2必然会在某个时刻相遇(p1==p2)，从而检测到链表中有环。
http://ostermiller.org/find_loop_singly_linked_list.html
这篇文章讲了很多好的坏得相关算法。
2)使用两个指针p1,p2从链表头开始遍历，p1每次前进一步，p2每次前进两步。如果p2到达链表尾部，说明无环，否则p1、p2必然会在某个时刻相遇(p1==p2)，从而检测到链表中有环。

3) 这2篇文章不错，又新增加了一种方法。
http://kb.cnblogs.com/page/52054/

 http://www.cppblog.com/humanchao/archive/2008/04/17/47357.html

4) 扩展: 怎么快速检测出一个巨大的链表中的死链？或者如何找出一个单链表的中间节点？

5) 题目为：对于普通的单向链表，如果实现确定其内部有一个环，如何确定何处出现环路的？单向链表每个节点中只有data和next两个字段。
(单向链表含环路，不要总是想到“0”型环路，还要想到“6”字型环路)
原本听到这道题时,我首先想到的笨办法就是:建一个足够大的一维数组，，每个位置放Node*类型指针。而后开始遍历单向链表，遍历过一个节点后就将该节点的指针添加到这个一维数组中，随后与该数组前边的所有元素进行一次遍历比较，如果有重复，则定位到了这个出现环路的节点。
但是后来面试官说：这个空间复杂度有点大，如果场景是有几百万条记录呢？有没有办法大大的降低这个时间复杂度？

6)第一种方法步长法。

 1。初始化两个指针p=headq=head

2。循环遍历链表 p=p->next;     q=q->next->next 如果有 p=q 的时刻则说明为循环链表 否则为非循环链表

这个算法的思想是可以看做两个在那里跑步一个速度快一个速度慢当链表中有个环存在时相当于这两个人在围绕一个圈跑步那么跑得快的总会在某一时刻追上那个跑得慢的。 第二种方法 比较节点和下一个节点的值如果下一个节点的地址值比该节点的地址值小或者相等的话就是循环链表。 

 //1步长法

bool Link::isLoop()   {      

Note *s,*f;//快慢指针    

s=head->next;      

 f=head->next->next;  

while (s!=NULL && f!=NULL && f->next!=NULL)       {  

 if (s == f)   return true;          

 s = s->next;        

   f = f->next->next;       }   return false;   }  

 

 //2比较地址法

bool Link::isLoop2()   {      

Note *temp = head;  

while(temp!=NULL &&temp->next!= NULL)     

  {  

 if (temp->next<=temp)          

 {  

return true;          

 }  

temp = temp->next;      

}  

return false;  

}  

 

题二、给定两个单链表(head1, head2)，检测两个链表是否有交点，如果有返回第一个交点。

1)如果head1==head2，那么显然相交，直接返回head1。
  否则，分别从head1,head2开始遍历两个链表获得其长度len1与len2。假设len1>=len2，那么指针p1由head1开始向后移动len1-len2步。指针p2=head2，下面p1、p2每次向后前进一步并比较p1p2是否相等，如果相等即返回该结点，否则说明两个链表没有交点。

2)如果head1==head2，那么显然相交，直接返回head1。
  否则，分别从head1,head2开始遍历两个链表获得其长度len1与len2。假设len1>=len2，那么指针p1由head1开始向后 移动len1-len2步。指针p2=head2，下面p1、p2每次向后前进一步并比较p1p2是否相等，如果相等即返回该结点，否则说明两个链表没有 交点。

 

扩展：

给定一个单链表，只给出头指针h：

1、如何判断是否存在环？

2、如何知道环的长度？

3、如何找出环的连接点在哪里？

4、带环链表的长度是多少？

解法：

1、对于问题1，使用追赶的方法，设定两个指针slow、fast，从头指针开始，每次分别前进1步、2步。如存在环，则两者相遇；如不存在环，fast遇到NULL退出。

2、对于问题2，记录下问题1的碰撞点p，slow、fast从该点开始，再次碰撞所走过的操作数就是环的长度s。

3、问题3：有定理：碰撞点p到连接点的距离=头指针到连接点的距离，因此，分别从碰撞点、头指针开始走，相遇的那个点就是连接点。

该定理的证明可参考：http://fayaa.com/tiku/view/7/

4、问题3中已经求出连接点距离头指针的长度，加上问题2中求出的环的长度，二者之和就是带环单链表的长度

 

 

 

题三、给定单链表(head)，如果有环的话请返回从头结点进入环的第一个节点。
  
1)运用题一，我们可以检查链表中是否有环。
   如果有环，那么p1p2重合点p必然在环中。从p点断开环，方法为：p1=p, p2=p->next, p->next=NULL。此时，原单链表可以看作两条单链表，一条从head开始，另一条从p2开始，于是运用题二的方法，我们找到它们的第一个交点即为所求。
    也可以不断开环。设重合点为p3,从p3开始遍历这个环，同时从表头开始走，检查每步是否在那个环中。这个方法大概有nlogn。
   使用快慢指针，第一次相遇，表明存在循环。继续快慢指针，第二次相遇，得到的iteration步长为环的长度。分别从相遇点和第一个节点出发，都是步长为1的指针，当相遇时，得到的iteration步长为环首的位置。

2)要点: 如果两个链表相交，那个两个链表从相交点到链表结束都是相同的节点
     另解:http://hxraid.iteye.com/blog/701699

 

题四、只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。
   办法很简单，首先是放p中数据,然后将p->next的数据copy入p中，接下来删除p->next即可。

 

题五、只给定单链表中某个结点p(非空结点)，在p前面插入一个结点。
   办法与前者类似，首先分配一个结点q，将q插入在p后，接下来将p中的数据copy入q中，然后再将要插入的数据记录在p中。

 

题六、给定单链表头结点，删除链表中倒数第k个结点。
   使用两个节点p1,p2，p1初始化指向头结点，p2一直指向p1后第k个节点，两个结点平行向后移动直到p2到达链表尾部(NULL),然后根据p1删除对应结点。

 

题七、链表排序
   链表排序最好使用归并排序算法。堆排序、快速排序这些在数组排序时性能非常好的算法，在链表只能“顺序访问”的魔咒下无法施展能力；但是归并排序却如鱼得水，非但保持了它O(nlogn)的时间复杂度，而且它在数组排序中广受诟病的空间复杂度在链表排序中也从O(n)降到了O(1)。真是好得不得了啊，哈哈。以上程序是递推法的程序，另外值得一说的是看看那个时间复杂度，是不是有点眼熟？对！这就是分治法的时间复杂度，归并排序又是divide and conquer。

double cmp(ListNode *p ,ListNode *q)
{
 return (p->keyVal - q->keyVal);
}

ListNode* mergeSortList(ListNode *head)
{   
    ListNode *p, *q, *tail, *e;  
    int nstep = 1;   
    int nmerges = 0;   
    int i;   
    int psize, qsize;
  
    if (head == NULL || head->next == NULL)       
    {return head;}   
    while (1)       
    {   p = head;   
    tail = NULL;
    nmerges = 0;  
    while (p)       
    {   nmerges++;  q = p;  psize = 0;   
    for (i = 0; i < nstep; i++){       
        psize++;       
        q = q->next;       
        if (q == NULL)break;       
    }   
    qsize = nstep;   
    while (psize >0 || (qsize >0 && q))       
    {       
        if (psize == 0 ){e = q; q = q->next; qsize--;}
      
        elseif (q == NULL || qsize == 0){e = p; p = p->next; psize--;}
      
        elseif (cmp(p,q) <= 0){e = p; p = p->next; psize--;}
      
        else{e = q; q = q->next; qsize--;}
      
        if (tail != NULL){tail->next = e;}
      
        else{head = e;}
      
        tail = e;
      
    }   
    p = q;
    }   
    tail->next = NULL;   
    if (nmerges <= 1){return head;}  
    else{nstep <<= 1;}   
    }  
}

 

 

题八、倒转单链表

给出非递归和递归解法：
#include

using namespace std;

struct Node
{
    int data;
    Node* next;
}*head;

// 非递归写法
Node* InverseLinkedList(Node* head)
{
    if(head == NULL)
        return NULL;
    Node* newHead = NULL;
    while(head != NULL)
    {
        Node* nextNode = head->next;
        head->next = newHead;
        newHead = head;
        head = nextNode;
    }
    return newHead;
}

// 递归写法
Node* InverseLinkedListRecur(Node* head)
{
    if(head == NULL)
        return NULL;
    if(head->next == NULL)
        return head;
    Node* newHead = InverseLinkedListRecur(head->next);
    Node *tmp = newHead;
    while(tmp->next != NULL)
    {
        tmp = tmp->next;
    }
    tmp->next = head;
    head->next = NULL;
    return newHead;
}

int main()
{
    // 构建链表 9->8->7->6->5->4->3->2->1->0->NULL
    for(int i = 0; i < 10; i++)
    {
        Node* node = new Node();
        node->data = i;
        node->next = head;
        head = node;
    }
    head = InverseLinkedList(head);
    Node *tmp = head;
    while(head != NULL)
    {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
    head = InverseLinkedListRecur(tmp);
    tmp = head;
    while(head != NULL)
    {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
    while(tmp != NULL)
    {
        Node* next = tmp->next;
        delete tmp;
        tmp = next;
    }
}

 

 

题九、两个有序链表的合并( 无环单链表合并[微软] )
 已知单链线性表La和Lb的元素按值非递减排列.归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列.
 参考:http://rayloo.iteye.com/blog/1008874
 
 有两个有序链表，各自内部是有序的，但是两个链表之间是无序的。

typedef struct node{
    int data;
    struct node * next;
}* List;

List mergeSortedLinkList(List list1, List list2)
{
    List pList1,pList2,mergedList,pCurNode;

    if (list1 == NULL)
    {
        return list2;
    }
    if (list2 == NULL)
    {
        return list1;
    }

    pList1 = list1;
    pList2 = list2;
    mergedList = NULL;
    if (pList1==pList2)
    {      
        mergedList = pList1;
        pList1 = pList1->next;
        pList2 = pList2->next;
    }
    else
    {
        if (pList1->data <= pList2->data)
        {
            mergedList = pList1;
            pList1 = pList1->next;
        }
        else
        {
            mergedList = pList2;
            pList2 = pList2->next;
        }
    }
    pCurNode = mergedList;
    while(pList1 && pList2)
    {
        if (pList1==pList2)
        {
            pCurNode->next = pList1;
            pCurNode = pList1;
            pList1 = pList1->next;
            pList2 = pList2->next;
        }
        else
        {
            if (pList1->data <= pList2->data)
            {
                pCurNode->next = pList1;
                pCurNode = pList1;
                pList1 = pList1->next;
            }
            else
            {
                pCurNode->next = pList2;
                pCurNode = pList2;
                pList2 = pList2->next;
            }
        }
    }

    pCurNode->next =pList1?pList1:pList2;

    return mergedList;
}

 

题十、找出链表的中间元素
单链表的一个比较大的特点用一句广告语来说就是“不走回头路”，不能实现随机存取（random access）。如果我们想要找一个数组a的中间元素，直接a[len/2]就可以了，但是链表不行，因为只有a[len/2 - 1] 知道a[len/2]在哪儿，其他人不知道。因此，如果按照数组的做法依样画葫芦，要找到链表的中点，我们需要做两步（1）知道链表有多长（2）从头结点开始顺序遍历到链表长度的一半的位置。这就需要1.5n（n为链表的长度）的时间复杂度了。有没有更好的办法呢？有的。想法很简单：两个人赛跑，如果A的速度是B的两倍的话，当A到终点的时候，B应该刚到中点。这只需要遍历一遍链表就行了，还不用计算链表的长度。
 

题十一、逆序输出无环单链表的所有节点值
 详见 :http://blog.csdn.net/zhulei632/article/details/6736260
 扩展：该题还有两个常见的变体：
  1. 从尾到头输出一个字符串；
  2. 定义一个函数求字符串的长度，要求该函数体内不能声明任何变量。

参考链接：
1.常见的链表操作面试题：
http://article.yeeyan.org/view/9225/173996
2.常见的链表操作
http://blog.csdn.net/fatshaw/article/details/6452460
3.前2个问题的分析
http://keep.iteye.com/blog/293454

 

扩展阅读：
链表分为单链表、双向链表、循环单链表、循环双链表等。