链表面试题（二）

接着上一篇文章来写后面的
8. 查找链表的中间节点，要求只能遍历一次链表
使用指针追赶的方法。定义快慢指针，快指针一次走2步，慢指针一次走1步，当快指针走到尾时，慢指针刚好走到一半。
注意当FastNode–>_next==NULL时，表示链表有偶数个节点，其中间节点有两个

SListNode* FindMidNode(SListNode* head)
{
    SListNode* FastNode, *SlowNode;
    SListNode* prev = NULL;
    FastNode = head;
    SlowNode = head;

    while (FastNode && FastNode->_next)
    {
        FastNode = FastNode->_next->_next; 
        prev = SlowNode;
        SlowNode = SlowNode->_next;
    }

    if (FastNode == NULL)
        return prev;//返回偶数个节点的中间节点

    return SlowNode;
}

9. 查找单链表的倒数第k个节点，要求只能遍历一次链表
使用指针追赶的方法。设置快指针先走k步，然后慢指针从链表头部和快指针同时往后走，当快指针走到链表尾时，慢指针走到倒数第k个节点处。此时要注意链表的长度要大于k

SListNode* FindTailK(SListNode* head, int k)
{
    SListNode* Fast = head;
    SListNode* Slow = head;
    if (head == NULL || k <= 0)
        return NULL;

    //让Fast先走k步
    while (k--)
    {
        //k大于链表中节点的个数
        if (Fast == NULL)
            return NULL;

        Fast = Fast->_next;
    }

    //让Fast和Slow一起走
    while (Fast) 
    {
        Fast = Fast->_next;
        Slow = Slow->_next; 
    }
    return Slow;
}

10. 删除链表的倒数第k个节点
按照上一个题的算法，先找到链表的倒数第k个节点，把它保存下来。再用替换法删除此节点。

void DeleteTailKNode(SListNode* head, int k)
{
    SListNode* Fast, *prev, *Slow;
    //1.找倒数第k个节点
    if (head && k <= 0)
        return NULL;
    while (k--)
    {
        if (Fast == NULL)
            return NULL;

        Fast = Fast->_next;
    }
    while (Fast)
    {
        Fast = Fast->_next;
        prev = Slow;//保存节点
        Slow = Slow->_next;
    }
    //2.删除节点
    if (Slow == head)
        head = Slow->_next;
    else
        prev->_next = Slow->_next;

    free(Slow);
}

11. 判断单链表是否带环？若带环，求环的长度？环的入口点？每个算法的时间复杂度&空间复杂度
1）判断单链表是否带环
定义快慢指针，快指针一次走2步，慢指针一次走1步。如果两个指针相遇了，则单链表带环；如果快指针走到空节点，则链表不带环

//判是否带环
SListNode* IsCycle(SListNode* head)//时间复杂度:O(n) 
{
    SListNode* fast, *slow;
    slow = fast = head;

    while (fast && fast->_next)
    {
        slow = slow->_next;
        fast = fast->_next->_next;

        if (fast == slow)
            return fast;
    }

    return NULL;
}

2）如果单链表带环，求环的长度
在上一问中已经找到了单链表的相遇节点，定义指针从单链表的相遇节点开始走，并且设置一个计数器，每走1步，计数器加1，直到该指针再次遇到相遇点，则返回计数器的数

//求环的长度
int GetCircleLen(SListNode* meet)
{
    int count = 1;
    SListNode* cur = meet;
    if (meet == NULL)
        return NULL; 

    while (cur->_next != meet)
    {
        count++;
        cur = cur->_next;
    }

    return count;
}

3）求环的入口点

• 设环的长度为：C
• 从链表头节点到入口点的长度为：L
• 入口节点到相遇点的长度：X
• 快指针在环中走的圈数：n
• 快指针走的步数：L + nC + X
• 慢指针走的步数：L + X
• 根据快指针走的步数是慢指针的两倍可得关系：L + nC + X = 2(L + X)，化简后可得：nC = L + X
• 结论：从链表头节点到入口点的长度 = 相遇节点到入口点的长度

SListNode * GetEntry(SListNode* head, SListNode* meet)
{
    SListNode* pH = head;
    SListNode* pM = meet;

    if (head == NULL || meet == NULL)
        return NULL;

    while (pH != pM)
    {
        pH = pH->_next;
        pM = pM->_next;
    }

    return pM;
}

12. 判断两个链表是否相交，若相交，求交点（假设链表不带环）
1）判断两个链表是否相交
如果两个链表相交，那么从第一个交点开始到尾节点，所有的节点都是公共节点。所以，两个有公共节点而部分重合的链表，拓扑形状看起来像一个Y，而不可能像X。
所以依次遍历两个链表，最后判断尾节点是否相同。如果相同，则相交；如果不相同则不相交

//判断两个链表是否相交（不带环）
int IsSListCross(SListNode* head1, SListNode* head2)
{
    SListNode* tail1 = head1;
    SListNode* tail2 = head2;
    if (head1 == NULL || head2 == NULL)
        return 0;

    while (tail1->_next)
        tail1 = tail1->_next;

    while (tail2->_next)
        tail2 = tail2->_next;

    return tail1 = tail2;
}

2）求两个不带环链表的交点
设置两个计数器分别记录两个链表的节点个数，再计算两个链表的节点数之差gap。然后按照尾部对齐的形式，让长的链表先走gap步，最后两个链表同时走，就能同时相遇，而相遇的点就是交点。

//求两个不带环链表的交点
SListNode* GetCrossNode(SListNode* head1, SListNode* head2)
{
    int size1 = 0;
    int size2 = 0;
    SListNode* cur1 = head1;
    SListNode* cur2 = head2;
    int gap = 0;//两个链表长度差值
    if (!IsSListCross(head1, head2))
        return NULL;

    //求两个链表中节点的个数
    while (cur1)
    {
        size1++;
        cur1 = cur1->_next;
    }
    while (cur2)
    {
        size2++;
        cur2 = cur2->_next;
    }

    gap = size1 - size2;
    cur1 = head1;
    cur2 = head2;
    if (gap > 0)
    {
        while (gap--)
            cur1 = cur1->_next;
    }
    else
    {
        while (gap--)
            cur2 = cur2->_next;
    }

    while (cur1 != cur2)
    {
        cur1 = cur1->_next;
        cur2 = cur2->_next;
    }

    return cur1;
}

13. 假设链表可能带环，判断是否相交，并求交点
1）判断两个可能带环的链表是否相交
- 都不带环，是上面的子问题
- 一个带环，一个不带环，肯定不相交

- 如果两个链表都带环，就可以求出两个相遇点，如果两个链表相交，则可知两个链表肯定共用同一个环，那么用一个相遇点去遍历环，如果可以找到另一个相遇点，则说明两个链表相交，否则就不相交

• 如果两个带环链表相交而且是环外相交，则两个环的入口点相等，可以将入口点的_next指针置为NULL，题目就转换成求两个不带环单链表的交点
  

• 如果两个带环链表相交而且是环内相交，则两个环的入口点不相等。此时交点就是入口点，任意返回一个入口点即可。
  

  14. 复杂链表的复制（一个链表的每个节点有1个next指针指向下一个节点，还有1个random指针指向这个链表中的一个随机节点或者NULL，复制这个链表）
  先定义复杂链表的结构：

typedef struct CSListNode
{
    struct CSListNode* _next;
    struct CSListNode* _random;
    DataType           _data;
}CSListNode;

动态创建节点：

CSListNode* BuyComplexSListNode(DataType x)
{
    CSListNode* newNode = (CSListNode*)malloc(sizeof(CSListNode));
    if (newNode == NULL)
        assert(0);

    newNode->_data = x;
    newNode->_next = NULL;
    newNode->_random = NULL;

    return newNode;
}

1）给原链表每个节点后插入值相同的新节点
2）给新插入节点的随机指针域赋值
3）将新节点从原链表中拆下来

CSListNode* CopyComplexSList(CSListNode* head)
{
    //1.在原链表每个节点后插入值相同的新节点
    CSListNode* cur = head;
    CSListNode* newNode;
    CSListNode* newHead;

    if (head == NULL)
        return NULL;

    while (cur)
    {
        newNode = BuyComplexSListNode(cur->_data);
        newNode->_next = cur->_next;
        cur->_next = newNode;
        cur = newNode->_next;
    }

    //2.给新插入节点的随机指针域赋值
    cur = head;
    while (cur)
    {
        newNode = cur->_next;

        if (cur->_random)
            newNode->_random = cur->_random->_next;

        cur = newNode->_next;
    }

    //3.将新插入节点从原链表中拆下来
    newHead = head->_next;
    cur = head;
    while (cur->_next)
    {
        newNode = cur->_next;
        cur->_next = newNode->_next;
        cur = newNode;
    }

    return newHead;
}