C实现之单链表是否相交

  1 # include<stdio.h>
  2 struct Slist{
  3     int size;
  4     struct sl* head;
  5 };
  6 struct sl{
  7     int k;
  8     struct sl* next;
  9 };
 10 typedef struct Slist Sl;
 11 typedef struct sl sl;
 12 void init(Sl* m,int k){
 13     sl* p = (sl *)malloc(sizeof(sl));
 14     p->k = k;
 15     p->next = NULL;
 16     m->head =p;
 17     m->size = 1;
 18 }
 19
 20 sl* add(Sl* m,int key ){
 21     sl* p=(sl *)malloc(sizeof(sl));
 22     sl* q = (sl *)malloc(sizeof(sl));
 23     p->k = key;
 24     p->next = NULL;
 25     q = m->head;
 26     while (q->next != NULL)
 27         q = q->next;
 28     q->next = p;
 29     m->size++;
 30     return p;
 31 }
 32
 33 void FanZhuan(Sl* m){                            //链表反转
 34
 35     sl* p = m->head;
 36     sl* q =NULL;
 37     sl* r =NULL;
 38     while (p->next!=NULL){
 39
 40         q = p->next;
 41         p->next = r;
 42         r = p;
 43         p = q;
 44     }
 45     q->next = r;
 46     m->head = q;
 47 }
 48
 49 void BianLi(Sl* m){                                 //遍历链表
 50
 51     sl* a = m->head;
 52     printf(" \n");
 53     while (a != NULL){
 54         printf("%d",a->k);
 55         a = a->next;
 56     }
 57 }
 58
 59 sl* CheckLoop(Sl* m){                                //测试是否有环
 60     sl* a = m->head;
 61     sl* b = m->head;
 62     while (b!=NULL){
 63         a = a->next;
 64         if (b->next == NULL)
 65             return NULL;
 66         if (b->next->next == NULL)
 67             return NULL;
 68         b = b->next->next;
 69         if (a == b)
 70             return a;
 71     }
 72     return NULL;
 73 }
 74
 75 int NloopCheck(Sl* f,Sl* n){            //两者均无环,测相交
 76     sl* k1 = f->head;
 77     sl* k2 = n->head;
 78     while (k1->next!=NULL)
 79     {
 80         k1 = k1->next;
 81     }                                   //取得表k1的最后一个节点
 82     while (k2 != NULL){
 83         k2 = k2->next;
 84         if (k2 == k1)
 85         {
 86              return 1;
 87         }
 88     }
 89     return 0;
 90 }
 91
 92 void Check(Sl*t1,Sl*t2){                     //测试是否相交
 93
 94     sl* Y1 = CheckLoop(t1);                  //先测两个表的每个表是否有环
 95     sl* Y2 = CheckLoop(t2);
 96 //    if (Y1 != NULL)
 97 //        printf("The first have loop!\n");
 98 //    if (Y2 != NULL)
 99 //        printf("The second have loop!");
100
101     int y1 = (Y1 != NULL);
102     int y2 = (Y2 != NULL);
103     int y = y1 + y2;
104     int yes = 0;
105     sl* test = NULL;
106     switch (y)
107     {
108     case 0:                                       //均无环
109         printf("\n Two have no loop!");
110         yes = NloopCheck(t1, t2);
111         break;
112
113     case 1:                                       //一个有环,一个没有
114         printf("\n One Have loop!");
115         yes = 0;
116         break;
117
118     case 2:                                       //两者都有环
119         printf("\n Two have loop!");
120         test = t2->head;
121         while (1)
122         {
123             if (test == Y2)
124             {
125                 yes = 1;
126                 break;
127             }
128             test = test->next;
129         }
130         break;
131     default:
132         break;
133     }
134
135     if (yes == 1)
136         printf("\n Have intersection!");
137     else
138         printf("\n Don‘t have intersection!");
139 }
140
141 void main(){
142     Sl* t1 = (Sl*)malloc(sizeof(Sl));                 //创建带环链表t1
143     t1->size=0;
144     t1->head = NULL;
145     init(t1,8);
146     add(t1, 3);
147     add(t1, 2);
148     sl* t1Start=add(t1, 1);                           //loop start!
149     add(t1, 0);
150     add(t1, 9);
151     sl* t2Start=add(t1, 10);
152     t2Start->next = t1Start;                           //Add loop!
153
154     Sl* t2 = (Sl*)malloc(sizeof(Sl));                 //创建链表t2与t1相交
155     t2->size = 0;
156     t2->head = NULL;
157     init(t2, 8);
158     add(t2, 3);
159     add(t2, 2);
160     sl* w2 = add(t2, 1);
161     w2->next = t2Start;
162
163
164     Sl* t3 = (Sl*)malloc(sizeof(Sl));                 //创建五环链表t3
165     t3->size = 0;
166     t3->head = NULL;
167     init(t3, 8);
168     add(t3, 3);
169     add(t3, 2);
170     sl* w3= add(t3, 1);
171     add(t3,7);
172     add(t3,27);
173
174     Sl* t4 = (Sl*)malloc(sizeof(Sl));                 //创建链表t4与t3相交
175     t4->size = 0;
176     t4->head = NULL;
177     init(t4, 8);
178     add(t4, 3);
179     add(t4, 2);
180     sl* w4 = add(t4, 1);
181     w4->next = w3;
182
183     Sl* t5 = (Sl*)malloc(sizeof(Sl));                  //创建链表t5,不与上相交
184     t5->size = 0;
185     t5->head = NULL;
186     init(t5, 8);
187     add(t5, 53);
188     add(t5, 42);
189 printf("\n SingList t1 and t2:");
190 Check(t1, t2);
191 printf("\n\n SingList t3 and t4:");
192 Check(t3, t4);
193 printf("\n\n SingList t1 and t3:");
194 Check(t3, t1);
195 printf("\n\n SingList t3and t5:");
196 Check(t5, t3);
197
198
199
200
201     system("pause");
202 }

执行效果图如下:

时间: 2024-10-19 22:24:46

C实现之单链表是否相交的相关文章

7_2判断两个单链表是否相交,若相交,求出第一个交点

转载请注明出处:http://www.cnblogs.com/wuzetiandaren/p/4251372.html 声明:现大部分文章为寻找问题时在网上相互转载,此博是为自己做个记录记录,方便自己也方便有类似问题的朋友,本文的思想也许有所借鉴,但源码均为本人实现,如有侵权,请发邮件表明文章和原出处地址,我一定在文章中注明.谢谢. 题目:7_2判断两个单链表是否相交,若相交,求出第一个交点. 题目分析: 创建A,B两个单链表,将B的尾部指向头部,若两个单链表相交,则交点必为环的入口,这就又变成

判断两个单链表是否相交及相交的第一个节点

/* 问题: 1.判断两个单链表是否相交 2.找出第一个相交节点 解题思路: 1.若连个链表相交则从相交节点开始以后节点都是一样的 2.通过链表长度判断然后去寻找 */ #include<stdlib.h> #include<stdio.h> /* 创建节点 */ typedef struct STU { char a; struct STU *next; }*SListNode; SListNode ListA; SListNode ListB; /* 创建链表A */ SLis

9.判断两个单链表是否相交

9.判断两个单链表是否相交 注意这里是判断是否相交.对于判断问题来讲,相对还是比较简单的.注意单链表并非不能有重复元素. 思路1:O(len1*len2) 把第一个链表的指针值逐项存在hashtable中,遍历第2个链表的每一项的指针值,如果能在第一个链表中找到,则必然相交.但是C++的STL模板中的hash不太会用.所以我使用了set集合,不过貌似set集合是使用遍历的方式来查找元素是否在集合中的,所以效率是比较低的,至少在O(len1*len2)级别. bool judgeIntersect

判断两个单链表是否相交

题目描述: 给定两个单链表的头节点head1和head2,如何判断两个链表是否相交?相交的话返回true,不想交的话返回false. 给定两个链表的头结点head1和head2.请返回一个bool值代表它们是否相交. 链表中节点的类型设置如下: class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } 思路: 1.首先判断是否有环, 若两个链表都没有环,则进行无环单链表判断是否相

单链表是否相交

题目:有两个带头结点的单链表L1,L2,判断它们是否相交(它们中是否有相同的结点) 解题思路: L1,L2中任何一个链表为空它们不相交 因为单链表中可能有环,所以分3种情况讨论 1.L1,L2中都没有环,那么可以通过判断它们中最后一个结点是否相同,来判断它们是否相交 2.L1,L2中一个有环,一个没有环,那么它们一定不相交 3.L1,L2中都有环,那么只有当它们的环相同时,它们才相交,当它们在进入环之前有相同的结点时,它们交点的个数大于环中结点的个数,当它们进入环时才有第一个相同的结点时,它们交

每日一题3:判断单链表是否相交

由于单链表的特殊性,如果某一链表与另一链表相交,那么从相交的节点开始,以后两个链表的每个节点都相同,因此判断两个链表是否相交,只需判断每条链表的最后一个节点是否相同即可! #include "stdafx.h" #include <iostream> using namespace std; struct list_node { int data; list_node* next; }; list_node* CreateList(int datas[],int n) {

判断2个单链表是否相交,并求出第一个相交结点

不考虑单链表有环的情况下 如果2个单链表相交,一定是Y型链表 1.遍历2个链表到尾结点,记录2个链表的长度x,y 2.尾结点相同,则相交. 3.从表头开始,长链表先走|x-y|步,之后2个链表一起走,判断第一个相同的点. 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 typedef struct student //定义链表结构 5 { 6 int num; 7 struct stu

1.11判断两个无环单链表是否相交

判断两个无环单链表是否交叉 题目描述: 如上图,这两个链表相交于结点5,要求判断两个链表是否相交,如果相交,找出相交处的结点. 解题思路: 方法一:Hash 法 如上图所示,如果两个链表相交,那么它们一定会有公共的结点,由于结点的地址或引用可以作为结点的唯一标识,因此,可以通过判断两个链表中的结点是否有相同的地址或引用来判断链表是否相交. 方法二:首尾相接法 将这两个链表首尾相连(例如把链表headl尾结点链接到head2的头指针),然后检测这个链表是否存在环,如果存在,则两个链表相交,而环入口

java判断两个单链表是否相交

转载于:http://blog.csdn.net/happymatilian/article/details/47811161 思路: 链表分有环链表和无环链表,如果两个链表存在相交,则只有两种可能,两个链表都无环或者都有环. (1)如果链表都无环,则先判断链表的尾指针是否一样,如果不一样,则没有相交.如果一样,则找出两个链表的长度差,将两个链表从距离尾节点同样的距离进行扫描,如果相交,则必然有一处扫描节点相同.实例数据List1:1->2->3->4->5->6->7