链表的基本操作

#include<iostream>
#include<algorithm>
using namespace std;
typedef struct LNode{
	int data;
	struct LNode * next;
}LNode, *LinkList;
//头插法 
void insertFromHead(LinkList &L)
{
	L = new LNode;
	L->next = NULL;
	int x ;
	cin >> x;
	while(x != -1)
	{
		LNode * s = new LNode;
		s->data = x;
		s->next = L->next;
		L->next = s;
		cin >> x;
	}
}


//数组初始化。方便调试  尾插法 
void insertA(LinkList &L, int a[])
{
	L = new LNode;
	L->next = NULL;
	LNode * r = L;
	int i = 0;
	while(i < 7)
	{
		LNode * s = new LNode;
		
		s->data = a[i++];
		r->next = s;;
		r = s;
		
	}
	r->next = NULL; 
}
//正向输出 
void show(LinkList &L)
{
	LNode * p = L->next;
	while(p)
	{
		cout << p->data << " ";
		p = p ->next;
	}
	cout << endl;
}
//递归删除链表 
void delete_digui(LinkList &L, int x)
{
	LNode * p;
	if(L == NULL) return;
	if(L->data == x)
	{
		p = L;
		L = L->next;
		delete p;
		delete_digui(L,x);
	}
	else
		delete_digui(L->next,x);
}
//逆向打印 
void show_digui(LinkList &L)
{
	if(L->next != NULL) 
	{
		show_digui(L->next);
	}
	if(L != NULL)
		cout << L->data << " ";
	
}
//删除最小值（唯一）
void delete_min(LinkList &L)
{
	LNode *p, *pre, *minp;
	p = L->next;
	pre = L;
	//删除时，每次比的当前节点的下一个节点，
	//如果小于，则当前节点就是前驱节点 pre=p
	while(p->next)
	{
		if(p->next->data < pre->next->data)	
			pre = p;
		p = p->next;
	}
	minp = pre->next;
	pre->next = pre->next->next;
	delete minp;	
 } 
 //头插法逆向 
void reverse_1(LinkList &L)
{
	LNode *p = L->next, *r;
	L->next = NULL;
	while(p)
	{
		r = p->next;
		p->next = L->next;
		L->next = p;
		p = r;
	}
}
//就地逆向
void reverse_2(LinkList &L)
{
	LNode *pre, *p, *r;
	pre = L;
	p = L->next;
	r = p->next;
	p->next = NULL;
	while(r)
	{
		pre = p;
		p = r;
		r = r->next;
		p->next = pre;
	}
	L->next = p;
 } 
 //直接插入排序 
void sort_insert(LinkList &L)
{
	LNode *p = L->next->next,*r, *pre;
	L->next->next = NULL;
	while(p)
	{
		r = p->next;
		pre = L;
		//每次检查节点的时候实际上拿的是
		//第一个大于p->data的前驱，也就是要插入的位置， 
		while(pre->next && pre->next->data < p->data)
		{
			pre = pre->next;
		}
		//链表当中的头插法 
		p->next = pre->next;
		pre->next = p;
		p = r;
		
	}
	 
}
//分割单链表
LinkList spilt(LinkList &A){
	LinkList B = new LNode;
	B->next = NULL;
	LNode *ra, *rb, *p;
	p = A->next;
	ra = A; rb = B; 
	A->next = NULL;
	int i = 0;
	while(p)
	{
		i++;
		if(i % 2 == 1)
		{
			ra->next = p;
			ra = p;
		 }
		 else
		 {
		 	rb->next = p;
		 	rb = p;
		 }
		 p = p->next;
		 
	}
	ra->next = NULL;
	rb->next = NULL;
	return B;
} 
//升序单链表合并为一个降序单链表 
LinkList merge_1(LinkList A, LinkList B)
{
	LNode *pa, *pb, *r;
	pa = A->next;
	A->next = NULL;
	pb = B->next;
	delete B;
	while(pa && pb)
	{
		
		if(pa->data <= pb->data)
		{
			
			r = pa->next;
			pa->next = A->next;
			A->next = pa;
			pa = r;
		}
		else
		{
			r = pb->next;
			pb->next = A->next;
			A->next = pb;
			pb = r;
		}
	}
	if(pa)
		pb = pa;
	while(pb)
	{
		r = pb->next;
		pb->next = A->next;
		A->next = pb;
		pb = r;
	}
	return A;
}
//求两个表的交集 
LinkList jiaoji(LinkList A, LinkList B)
{
	LNode *pa = A->next, *pb = B->next, *s, *r;
	LinkList C = new LNode;
	r = C;
	while(pa && pb)
	{
		if(pa->data < pb->data)
		{
			pa = pa->next;
		}
		else if(pa->data > pb->data)
		{
			pb = pb->next;
		}
		else
		{
			s = new LNode;
			s->data = pa->data;
			r->next = s;
			r = s;
			pa = pa->next;
			pb = pb->next;
		}
		
	}
	r->next = NULL;
	return C;	
} 



int main()
{
	LinkList A, B, C;
	//int a[] = {1,2,2,6,3,0,1} ;
	int a[] = {2, 4, 5, 7, 12, 15, 20};
	int b[] = {1, 3, 5, 11, 12, 23, 27};
	insertA(A, a);
	insertA(B, b);
	//show(ll);
	//C = merge_1(A, B);
	C = jiaoji(A, B);
	show(C);
	//LinkList B = spilt(A);
	//sort_insert(A);
	//show_digui(A->next);
	cout << endl;
	//delete_min(A);
	//reverse_1(A);
	//reverse_2(A);
	//show(A);
	//show_digui(B->next);
	//cout << endl;
	return 0;
 }