// Given two linked list find and print the intersection of these two.
#include<iostream>
using namespace std;
class node
{
public:
int data;
node* next;
node(int data){
this->data = data;
next = NULL;
}
};
void InsertAtTail(node *&head, int data){
if(head==NULL){
head = new node(data);
return;
}
node *temp = head;
while(temp->next!=NULL){
temp = temp->next;
}
temp->next = new node(data);
return;
}
node* Intersection(node *a, node *b){
node *temp = NULL;
while(a!=NULL && b!=NULL){
if(a->data==b->data){
InsertAtTail(temp,a->data);
a = a->next;
b = b->next;
}
else if(a->data<b->data){
a = a->next;
}
else{
b = b->next;
}
}
return temp;
}
node* IntersectionRecursive(node *a, node *b, node *&temp){
if(a==NULL || b==NULL){
return temp;
}
if(a->data==b->data){
InsertAtTail(temp,a->data);
return IntersectionRecursive(a->next,b->next,temp);
}
else if(a->data<b->data){
return IntersectionRecursive(a->next,b,temp);
}
else{
return IntersectionRecursive(a,b->next,temp);
}
}
// Following commented function is not working! The dummy concept is not working here!.
// node* SortedIntersection(node *a, node *b){
// node dummy;
// node *temp = &dummy;
// while(a!=NULL && b!=NULL){
// if(a->data==b->data){
// InsertAtTail(temp->next,a->data);
// temp = temp->next;
// a = a->next;
// b = b->next;
// }
// else if(a->data<b->data){
// a = a->next;
// }
// else{
// b = b->next;
// }
// }
// return temp->next;
// }
void printLL(node *head){
while(head!=NULL){
cout<<head->data;
if(head->next!=NULL){
cout<<"->";
}
head = head->next;
}
cout<<endl;
}
int main()
{
node *first = NULL;
node *second = NULL;
int n,data;
cin>>n;
for(int i=0;i<n;i++){
cin>>data;
InsertAtTail(first,data);
}
cin>>n;
for(int i=0;i<n;i++){
cin>>data;
InsertAtTail(second,data);
}
node *temp = NULL;
temp = Intersection(first,second);
// temp = IntersectionRecursive(first,second,temp);
// temp = SortedIntersection(a,b,temp);
printLL(temp);
return 0;
}
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