单向链表相交的第一个公共结点, 判断链表是否有环以及环的入口节点

//////题目：两个单向链表，找出它们的第一个公共结点。
//////
//////链表的结点定义为：
//////
//////struct ListNode
//////
//////{
//////
//////      int       m_nKey;
//////
//////      ListNode*   m_pNext;
//////
//////};
//////
//////分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试题中，链表出现的概率相当高。
//////如果两个单向链表有公共的结点，也就是说两个链表从某一结点开始，它们的m_pNext都指向同一个结点。
//////但由于是单向链表的结点，每个结点只有一个m_pNext，因此从第一个公共结点开始，
//////之后它们所有结点都是重合的，不可能再出现分叉。所以，两个有公共结点而部分重合的链表，
//////拓扑形状看起来像一个Y，而不可能像X。

#include <iostream>
#include <algorithm>
using namespace std;

#define NSIZ 101

struct ListNode
{

int m_nKey;
ListNode*  m_pNext;

};

//获得链表长度
int GetListLength(ListNode * head)
{
if(!head)
{
return 0;
}
int len = 0;
ListNode * tmp = head;

while(tmp)
{
++len;
tmp = tmp->m_pNext;
}
return len;
}

//尾插法构造链表
void CreateList(ListNode * & head, int arr[], int n)
{
ListNode * p = head;
if(head == 0)
{
head = new ListNode();
head->m_nKey = arr[0];
p = head;
}
int i = 1;
for(;i < n; ++i)
{
ListNode * tmp = new ListNode();
tmp->m_nKey = arr[i];
p->m_pNext = tmp;
p = tmp;
}
p->m_pNext = 0;
}

//合并2个链表
ListNode* UnionList(ListNode * head1, ListNode * head2)
{

if(head1 == 0 && head2)
{
return head2;
}
else if(head1 && !head2)
{
return head1;
}
else if(head1 && head2)
{
ListNode * pre = head1;
ListNode * p = pre->m_pNext;
while(p)
{
pre = p;
p = p->m_pNext;
}

pre->m_pNext = head2;
return head1;
}
else
{
return 0;
}
}

//打印链表元素值
void dump(ListNode * head)
{
ListNode * p = head;
while(p)
{
printf("%d ", p->m_nKey);
p = p->m_pNext;
}

printf("\n");
}

//判断两个链表是否有交点，如果有则返回第一个交点
//如果head1 && head1 == head2那么显然相交，返回head1
//否则 分别获得head1链表和head2链表的长度为len1和len2 ，并且假设len1 > len2
//然后用指针pLong从head1开始向后移sub = len1 - len2步，指针pShort = head2
//然后p1,p2每次前进一步并且比较p1 == p2，若不为空且相等则返回p1，
//否则说明head1链表和head2链表没有交点
ListNode * FirstCommonNode(ListNode * head1, ListNode * head2)
{
int len1 = GetListLength(head1);
int len2 = GetListLength(head2);
ListNode * Short = head1, *Long = head2;
int sub = len2 - len1;
if (len1  > len2)
{
Short = head2;
Long = head1;
sub  = len1 - len2;
}

while(sub > 0)
{
Long = Long->m_pNext;
--sub;
}

while(Short && Long && Short != Long)
{
Short = Short->m_pNext;
Long = Long->m_pNext;
}

if (Short && Long && Short == Long)
{
return Short;
}

return 0;
}

//检测链表中是否有环,快慢指针方法
//若有环则返回从头结点进入环的第一个节点
//假设p1 = head1, p2 = head->next->next
//首先检查是否有环，有环的话p1，p2必然在环内相遇
//此时从相遇处端口，方法为
//common = p2;
//head2 = p2->next， p2 ->next=  0;
//此时原链表被分成了2个链表，头结点分别为head1, head2
//利用FirstCommonNode(ListNode * head1, ListNode * head2)函数得到相交节点FirtNode
//然后修复链表：common->next= head2
//最后返回FirstNode
ListNode * HasLoop(ListNode * head)
{
if (!head)
{
return 0;
}

ListNode * slow = head;
ListNode * quick = head;
while(quick && quick->m_pNext)
{
slow = slow->m_pNext;
quick = quick->m_pNext->m_pNext;
if (slow == quick)
{
break;
}
}

// 无环的话
if (slow != quick )
{
return 0;
}

// p1表示相遇的点， p2表示p1->next
//然后把p1->next 置为0
//那么原链表形成了2个相交链表，一个以head为表头，一个以p2为表头
ListNode * p1 = quick;
ListNode * p2 = p1->m_pNext;
p1->m_pNext = 0;
ListNode * firtNode = FirstCommonNode(head,p2);

p1->m_pNext = p2;
return firtNode;
}

//给定单链表中某一个节点P,删除该节点（P节点不是最后节点）
//方法：首先存放好p中数据，然后把P->next中数据copy到p中，然后把p->next删除。
int DeleteNode(ListNode * p)
{
if (!p)
{
return INT_MIN;
}

int tmp = p->m_nKey;
ListNode * tmpNode = p->m_pNext;
p->m_nKey = p->m_pNext->m_nKey;
p->m_pNext = p->m_pNext->m_pNext;

if (tmpNode != 0)
{
delete tmpNode;
tmpNode = 0;
}
}

//给定单链表中某一个非空节点P,在节点P前面插入一个节点
//方法：首先分配一个节点q,将q插在p点之后
//然后将p点数据copy到q节点中，然后再把要插入的数据放到p中
int InsertNode(ListNode * p, int data)
{
if (!p)
{
return INT_MIN;
}

ListNode * tmpNode = new ListNode();
tmpNode->m_nKey = p->m_nKey;
tmpNode->m_pNext = p->m_pNext;
p->m_pNext = tmpNode;

p->m_nKey = data;

}

int main()
{

int arr[] = {1, 2, 3};
int brr[] = {4, 5, 6};
int crr[] = {7, 8, 9};
int alen = sizeof(arr)/sizeof(arr[0]);
int blen = sizeof(brr)/sizeof(brr[0]);
int clen = sizeof(crr)/sizeof(crr[0]);

ListNode * head1 = 0;
ListNode * head2 = 0;
ListNode * head3 = 0;

CreateList(head1, arr, alen);
CreateList(head2, brr, blen);
CreateList(head3, crr, clen);

//合并链表1和链表3
head1 = UnionList(head1, head3);
//合并链表2和链表3
head2 = UnionList(head2, head3);

//打印链表1
dump(head1);

//打印链表2
dump(head2);

//寻找两个链表的第一个公共节点
ListNode *findNode =  FirstCommonNode(head1, head2);
printf("第一个公共节，地址为：Ox%x 值为：%d\n", findNode, findNode->m_nKey);

findNode = HasLoop(head1);
findNode == 0?printf("没有环\n"):printf("有环，换的入口节点值为：%d\n", findNode->m_nKey);
return 0;
}