3.6 编程判断两个链表是否相交

（一）题目：输入一个单项链表，找出该链表的倒数第k个节点。

   解法：设立两个指针，先让第一个指针先往前走k步，然后第二个指针放到链表开头。

      然后两个链表一起往后走，当第一个链表到达链表尾部的时候，后面那个链表所在的位置就刚好是链表的倒数第k个节点！

   代码：

   

struct node {
    int data;
    node *pNext;
};

node* funtion(node *head, int k) {
    assert(k >= 0);
    node *pOne, *pTwo;
    pOne = head;
    pTwo = head;
    for(; k >0 && pTwo != NULL; k--) {
        pTwo = pTwo->pNext;
    }
    if(k > 0) return NULL;
    while(pTwo != NULL) {
        pOne = pOne -> pNext;
        pTwo = pTwo -> pNext;
    }
    return pOne;
}

（二）题目：给定两个单项链表，给定这两个单项链表的头指针，编程判断这两个链表是否相交。

   方法：因为两个链表如果相交的话，那么从相交节点开始，到最后，这两个链表的后面的部分都是公共的部分！

     所以，只需要分别从两个链表开头，遍历到最后结尾处，看看两个尾部是不是相同的一个节点！如果是的话，说明这两个链表是相交的，如果不是的话，说明这两个      链表是不相交的。

    

   题目：上面说的这种方法是两个链表都不带环，但是如果链表带了环呢！？

   所以总的方法：

（1）先判断两个链表带不带环

（2）如果都不带环，就判断两个链表的尾节点是否相等。

（3）如果都带环，判断一链表上两个指针相遇的那个节点，在不在另外一条链表上。如果在的话，则两个链表相交。如果不在的话，则不相交。

   代码：

struct node {
    int data;
    node *pNext;
};

bool isCircle(node *head, node *&circleNode, node *&lastNode) {
    node *fast = head -> pNext;
    node *slow = head;
    while(fast && slow && fast != slow) {
        if(fast -> pNext != NULL)   fast = fast -> pNext;
        if(fast -> pNext == NULL)   lastNode = fast;
        if(slow -> pNext == NULL)   lastNode = slow;
        fast = fast -> pNext;
        slow = slow -> pNext;
    }
    if(fast == slow && fast && slow) {
        circleNode = fast;
        return true;
    } else return false;
}

bool detect(node *head1, node *head2) {
    node *circleNode1;
    node *circleNode2;
    node *lastNode1;
    node *lastNode2;
    
    bool isCircle1 = isCircle(head1, circleNode1, lastNode1);
    bool isCircle2 = isCircle(head2, circleNode2, lastNode2);
    
    if(isCircle1 != isCircle2) return false;        //两个链变一个有环，一个无环
    else if(!isCircle1 && !isCircle2) return lastNode1 == lastNode2;        //两个链表都无环
    else {              //两个链表都有环
        node *temp = circleNode1 -> pNext;
        while(temp != circleNode1) {
            if(temp == circleNode2) return true;
            temp = temp -> pNext;
        }
        return false;
    }
    return false;
}

（三）求两个链表相交的第一个节点

方法，思路：先求出更长的那个链表的，然后在这个链表上面先走长度之差的步数，然后两个指针在一起走，走到最后，既是同一个节点！

  

struct node {
    int data;
    node *pNext;
};


unsigned int ListLength(node *pHead) {
    unsigned int nLength = 0;
    node *pNode = pHead;
    while(pNode != NULL) {
        nLength++;
        pNode = pNode -> pNext;
    }
    return nLength;
}


node* FindFirstCommonNode(node *pHead1, node *pHead2) {
    unsigned int nLength1 = ListLength(pHead1);
    unsigned int nLength2 = ListLength(pHead2);
    int nLengthDiff = nLength1 - nLength2;
    node *pListHeadLong = pHead1;
    node *pListHeadShort = pHead2;
    if(nLength1 < nLength2) {
        nLengthDiff = nLength2 - nLength1;
        pListHeadLong = pHead2;
        pListHeadShort = pHead1;
    }
    for(int i = 0; i < nLengthDiff; ++i) pListHeadLong = pListHeadLong -> pNext;
    while(pListHeadLong != NULL && pListHeadShort != NULL && pListHeadLong != pListHeadShort) {
        pListHeadLong = pListHeadLong -> pNext;
        pListHeadShort = pListHeadShort -> pNext;
    }
    node *pFirstCommonNode = NULL;
    if(pListHeadLong == pListHeadShort) pFirstCommonNode = pListHeadLong;
    return pFirstCommonNode;
}