判断两链表是否相交

13 篇文章 0 订阅

来源http://blog.csdn.net/huangxy10/article/details/8014233

只介绍O(n)算法

思路1:

将链表1中各结点地址存入HashTable中,

再遍历链表2,如果有结点已经在HashTable中,则两链表相交。


思路2:

将链表1的尾结点和链表2的首结点(注意不是头结点)相连。

再判断是否有环,如果有则两链表相交。


思路3:(最简单的方法)

判断两链表的尾结点是否为同一结点,若是,则相交。

 

实现部分为思路2。

  1. // LinkTable.cpp : 定义控制台应用程序的入口点。  
  2. //  
  3.   
  4. #include "stdafx.h"  
  5. #include <iostream>  
  6. #include <string>  
  7. using namespace std;  
  8.   
  9. //链表的结构体  
  10. struct node  
  11. {  
  12.     char val;  
  13.     node * next;  
  14. };  
  15.   
  16. //建立链表  
  17. struct node * create( string & str_link )  
  18. {  
  19.     int len = str_link.length();  
  20.   
  21.     struct node * phead = new node();     //带有表头的链表,表头中不存储任何元素  
  22.     struct node * preNode = phead;  
  23.     forint i=0; i<len; i++ )  
  24.     {  
  25.         struct node * pNode = new node();  
  26.         pNode->val = str_link[i];  
  27.         pNode->next = NULL;  
  28.         preNode->next = pNode;  
  29.         preNode = pNode;  
  30.     }  
  31.     return phead;  
  32. }  
  33.   
  34. //输出链表  
  35. void out_link( struct node * phead )  
  36. {  
  37.     if( phead == NULL )  
  38.         return;  
  39.     struct node * pNode = phead->next;  
  40.     while( pNode )  
  41.     {  
  42.         cout <<pNode->val;  
  43.         pNode = pNode->next;  
  44.     }  
  45.     cout << endl;  
  46. }  
  47.   
  48. //找到第index个元素  
  49. struct node * find_node(struct node* phead, int index )  
  50. {  
  51.     if(!phead) return NULL;  
  52.     struct node * pNode = phead;  
  53.     while( index--)  
  54.     {  
  55.         pNode = pNode->next;  
  56.         if( !pNode )  
  57.             return NULL;  
  58.     }  
  59.     return pNode;  
  60. }  
  61.   
  62. //检查链表有无环  
  63. //有,则返回快慢指针共同指向的点  
  64. //无,则返回空指针  
  65. struct node * check_loop( struct node * phead )  
  66. {  
  67.     if(!phead)  
  68.          return NULL;  
  69.     struct node * pFast = phead;  
  70.     struct node * pSlow = phead;  
  71.   
  72.     int step = 1;  
  73.     while( pFast )  
  74.     {  
  75.         pFast = pFast->next;  
  76.         if( step++%2==0 )  
  77.         {  
  78.             pSlow = pSlow->next;  
  79.             if( pSlow == pFast )  
  80.                 return pSlow;  
  81.         }  
  82.     }  
  83.     return NULL;  
  84. }  
  85.   
  86. //求两个节点的距离,即中间有多少个连线  
  87. //返回-1为出错,如果是同一节点,则返回0  
  88. int find_length( struct node* pNode1, struct node* pNode2 )  
  89. {  
  90.     if(!pNode1||!pNode2) return -1;  
  91.   
  92.     int len=0;  
  93.     while( pNode1 )  
  94.     {  
  95.         if( pNode1 == pNode2 )  
  96.             return len;  
  97.         pNode1 = pNode1->next;  
  98.         len++;  
  99.     }  
  100.     return -1;  
  101. }  
  102.   
  103. //找环的起始点,pTail为快慢指针共同指向的节点  
  104. struct node * loop_first_node( struct node * phead, struct node * pTail )  
  105. {  
  106.     if( !phead || !pTail ) return NULL;  
  107.     struct node * pNode1 = pTail->next;  
  108.     struct node * pNode2 = phead->next;  
  109.     int M = find_length( pNode1, pTail );  
  110.     int N = find_length( pNode2, pTail );  
  111.   
  112.     if( M > N )  
  113.     {  
  114.         int step = M-N;  
  115.         while(step--)  
  116.             pNode1 = pNode1->next;  
  117.     }  
  118.     if( N > M )  
  119.     {  
  120.         int step = N-M;  
  121.         while(step--)  
  122.             pNode2 = pNode2->next;  
  123.     }  
  124.     while(pNode1&&pNode2)  
  125.     {  
  126.         if(pNode1 == pNode2 )  
  127.             return pNode1;  
  128.         pNode1 = pNode1->next;  
  129.         pNode2 = pNode2->next;  
  130.     }  
  131.     return NULL;  
  132. }  
  133.   
  134. void test()  
  135. {  
  136.     string str;  
  137.     cin >> str;  
  138.     struct node *phead1 = create( str );  
  139.       
  140.     int index;  
  141.     cin >> index;  
  142.     struct node * pNode1 = find_node( phead1, index );  
  143.   
  144.     cin >> str;  
  145.     struct node *phead2 = create( str );  
  146.   
  147.     struct node * pNode = phead2;  
  148.     while( pNode->next )  
  149.         pNode = pNode->next;  
  150.     pNode->next = pNode1;        //生成相交链表, 注释掉之一行则为不相交  
  151.   
  152.     while( pNode->next )           //找到链表1的尾结点  
  153.         pNode = pNode->next;  
  154.     pNode->next = phead2->next;    //连接链表2的首结点  
  155.     struct node * pTail = check_loop( phead1 ); //检查是否有环  
  156.     struct node * pFirstLoopNode = NULL;  
  157.     if( pTail )  
  158.     {     
  159.         cout <<"cross." <<endl;  
  160.     }  
  161.     else  
  162.         cout << "no cross." <<endl;  
  163.   
  164. }  
  165.   
  166. int _tmain(int argc, _TCHAR* argv[])  
  167. {  
  168.     test();  
  169.     return 0;  
  170. }  

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值