算法习题42：修改append函数，求链表并集

请修改append函数，利用这个函数实现：
两个非降序链表的并集，1->2->3 和 2->3->5 并为 1->2->3->5
另外只能输出结果，不能修改两个链表的数据。

---------------------------------------------------------------

首先需要找出两个集合相交的部分，并且头尾相交，可是这里是链表结构，我们无法从后面往前找，想用递归似乎也无法实现。

这里先想到利用两个循环来遍历，找出他们共有的，经过改进可以把时间算法复杂度改成O(n) 

有一个很明显的规律，如果找到了一个相同的元素，那么我们需要判断的是剩下的元素是否也相同。例如

1 2 3 和2 3 5

当我们发现2相同，我们比较下一个元素，都是3，然后再比较时候发现有一个链表到结尾了，那么就可以链接成1 2 3 5

这样的复杂度只需要第一个链表的长度决定

算法：

假设第一个链表结尾和第二个链表首部相连：

我们只需遍历第一个链表的元素来和第二个链表的首位元素相比，相同则比较第一个链表下一个元素和第二个链表的下一个元素，如果能够比到第一个链表结尾，那么链接上，

如果中途不想等，则把第二个链表重新指回第一个元素，继续比较第一个链表剩余元素和第二个链表是否相连接，

如果比到最后不能链接，那么交换第一个和第二个链表，判断是否第二个链表和第一个链表相连接，

如果可以输出结果，不行则返回false

注：（有几个问题，我没有实现，但面试中希望大家能够想到）

1、链表是否存在环！

2、两个链表是否相交！

3、如果链表为空呢？

//============================================================================
// Name        : Append.cpp
// Author      : YLF
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

struct Node{
int value;
Node* next;
};

void Add(Node* &head, int value);
void PrintHead(Node* head);
bool Append(Node* head1, Node* head2);
void Print(Node* p1, Node* p2, int n);

int main() {

Node* head1 = NULL;
Node* head2 = NULL;

int input = 0;

while(true){
cin>>input;
if(input != -1)
Add(head1, input);
else
break;
}

while(true){
cin>>input;
if(input != -1)
Add(head2, input);
else
break;
}

if(!Append(head1, head2))
cout<<"no intercept!";
return 0;
}

void Add(Node* &head, int value){
Node* p = new Node();
p->value = value;
p->next = NULL;

if(head == NULL)
head = p;
else{
Node* temp = head;
while(temp->next != NULL)
temp = temp->next;
temp->next = p;
}
}
/*
* 时间复杂度O(n)
*/
bool Append(Node* head1, Node* head2){
Node* p1 = head1;
Node* p2 = head2;

int n = 0, tempN = 0;//n记录相交的位置，如果第一次相等的不是交集位置，那么n+tempN
bool flag = false;//标记前面的元素是否相等
bool isSwap = false;

while(true){
while(p1->value != p2->value){

if(flag){
p2 = head2;
flag = false;
n = n + tempN;
tempN = 0;
}else{
p1 = p1->next;
n++;
}

if(p1 == NULL){
//交换head1,head2
if(isSwap)
return false;
isSwap = true;
Node* temp = head1;
head1 = head2;
head2 = temp;

p1 = head1;
p2 = head2;
n=0;
flag = false;
continue;
}
}

flag = true;
p1 = p1->next;
p2 = p2->next;
tempN++;

if(p1 == NULL){
Print(head1,head2,n);
return true;
}
if(p2 == NULL){
p2 = head2;
n = n+tempN;
tempN = 0;
}
}
}

void Print(Node* p1, Node* p2, int n){
while(n-->0){
cout<<p1->value<<" ";
p1 = p1->next;
}

while(p2 != NULL){
cout<<p2->value<<" ";
p2 = p2->next;
}
}

给几个测试集

2 3 4 5 -1
1 2 3 1 2 3 4 5 -1
1 2 3 1 2 3 4 5

2 3 4 5 -1
2 3 4 2 3 4 1 -1
no intercept!