给定两个单链表，编写算法找出两个链表的公共结点

算法思路：首先知道什么是公共结点，公共结点其实就是从链表的某个结点开始，他们的next都指向同一个结点，之后他们所有的结点都是重合的，所以有两个公共结点部分重合的单链表，他们看起来应该是Y型，而不是x型

方法一：暴力破解，就是两个链表，在第一个链表上面顺序遍历每个结点，每遍历一个然后再第二个链表上面顺序遍历所有结点，找到是否相同的结点

#include<stdio.h>
#include<stdlib.h>
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*LinkList; 
int a[10]={1,2,3,7,8};
int b[5]={3,7,8};
int n1=5,n2=3;
void InitList(LinkList &L,int a[],int n){
	L=(LinkList)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=s;
		
	}
	r->next=NULL;
}
int length(LinkList L){
	int k=0;
	lnode *s=L->next;
	while(s){
		k++;
		s=s->next;
	}
	return k;
}

LinkList public_node(LinkList L1,LinkList L2){
 //因为这里是暴力解法，所以不需要求他们的长度直接遍历就是
			lnode *s1=L1->next;
			while(s1){
				lnode *s2=L2->next;
				while(s2){
					if(s1->data==s2->data&&s1->next->data==s2->next->data)
					//s1->next->data==s2->next->data这里可以不要，因为公共结点只有一个next域，
					 
					return s1; 
					//只能是Lnode *或者LinkList链表 
					else s2=s2->next;
				}
				s1=s1->next;
			} //复杂度为O(n2) 
			return 0;
}
//下面给出更优的算法
LinkList search_common(LinkList L1,LinkList L2){
	int len1=length(L1),len2=length(L2);
	LinkList LongList,shortList;
	int dist=0;
	if(len1>len2){
		dist=len1-len2;
		LongList=L1->next;
		shortList=L2->next; 
	}
	else{
		LongList=L2->next;
		shortList=L1->next;
		dist=len2-len1;
	}
	//这里求出谁长了，然后长的先走dist,然后再同步 
	while(dist!=0){//dist--意思其实就是dist!=0 
		LongList=LongList->next;
		dist--;
	}
	while(LongList!=NULL){
		if(LongList->data==shortList->data) return LongList;
		else {
			LongList=LongList->next;
			shortList=shortList->next;
		}
	}
	return NULL;
}

int main(){
	LinkList L1,L2;
	InitList(L1,a,n1);
	InitList(L2,b,n2);
	//LinkList L3=public_node(L1,L2);
	LinkList L3=search_common(L1,L2);
	printf("%d",L3->data);
	return 0;
}