【数据结构】单链表王道例题

void f2(LinkList &L,int x){		//删除值为x的节点 
	if(L==NULL)
		return ;
	if(L->data==x){
		LinkList p;
		p=L;
		L=L->next;
		f2(L,x);
	}
	else
		f2(L->next,x);
} 

void f3(LinkList &L){			//逆序输出链表 
	if(L==NULL)
		return ;
	f3(L->next);
	cout << L->data << " ";
	cout << endl;
}

void f5_1(LinkList &L){			//头插法将线性表逆置 
	LinkList r,p;
	p=L->next;
	L->next=NULL;
	while(p!=NULL){
		r=p->next;
		p->next=L->next;
		L->next=p;
		p=r;
	}
}
void f5_2(LinkList &L){			//标记每个节点的前驱和后继节点 
	LinkList pre,r,p;			//逆置链表
	p=L->next;
	r=p->next;
	p->next=NULL;
	while(r!=NULL){
		pre=r->next;
		r->next=p;
		p=r;
		r=pre;
	}
	L->next=p;
} 

void f6_Sort(LinkList &L){	//链表元素排序，空间复杂度O(1),时间复杂度O(n^2)
	LNode *p,*pre,*r;				//或者进行空间换时间，申请一个数组进行一个O(nlog2n)的排序
	p=L->next;						//那么空间上就是O(n)
	r=p->next;
	p->next=NULL;
	p=r;					//令p作为移动指针在原链上进行移动 
	while(p!=NULL){
		r=p->next;			//p的下一个需要记录，避免断链 
		pre=L;
		while(pre->next!=NULL&&pre->next->data<p->data)
			pre=pre->next;	//找到此时p所指节点的位置，插入进去 
		p->next=pre->next;
		pre->next=p;
		p=r; 
	}
}

void f7(LinkList &L,int s,int t){	//删除链表中处于s和t之间的元素 
	LNode *p,*pre;
	p=L->next;
	pre=L;
	while(p!=NULL){
		if(p->data>=s&&p->data<=t){
			pre->next=p->next;
			free(p);
			p=pre->next; 
		}
		else{
			pre=p;
			p=p->next;
		}
	}
}

LinkList f8(LinkList &La,LinkList &Lb){	//找出两个链表的公共链 
	LinkList plong,pshort;			//因为一个节点只能有一个指针域 
	int k;							//所以到达第一个公共节点之后 
	int la=TraveList(La);			//后面所有的节点都相同。  
	int lb=TraveList(Lb);
	if(la>lb){
		k=la-lb;
		plong=La->next;
		pshort=Lb->next;
	}
	else{
		k=lb-la;
		plong=Lb->next;
		pshort=La->next;
	}
	k--;
	while(k--)
		plong=plong->next;cout << "++++++++" <<endl;
	while(plong!=NULL){
		if(plong->data==pshort->data)
			return plong;
		else{
			plong=plong->next;
			pshort=pshort->next;
		}
	}
	return NULL;
} 

void f9(LinkList &Head){
	LinkList pre,p,r;
	while(Head->next!=NULL){
		p=Head->next;
		pre=Head;				//pre指针从第一个位置开始往后找 
		while(p->next!=NULL){
			if(p->next->data<pre->next->data)
				pre=p;			//找到一个数值比自己小的之后更换 
			p=p->next;
		}						//一次循环遍历，找到最小的值 
		cout << pre->next->data << " ";
		r=pre->next;			//然后释放内存 
		pre->next=pre->next->next;
		free(r); 
	}
	cout << endl;
	free(Head);
}

LinkList f10(LinkList &La){			//按序号的奇偶将链表分为La和Lb 
	LNode *pa,*pb,*Lb;
	Lb=(LinkList)malloc(sizeof(LNode));
	Lb->next=NULL;
	pa=La;
	pb=Lb;
	//pb->next=La->next->next;
	pa=pa->next;
	pb->next=pa->next;
	while(pa!=NULL&&pb!=NULL){
		pb->next=pa->next;
		pb=pb->next;
		pa->next=pb->next;
		pa=pa->next;
	}
	//pa->next=NULL;
	//pb->next=NULL;
	return Lb;
}

最后是一个整体的带头结点的链表的框架；

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode *next;
}LNode ,*LinkList;

LinkList InitList(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	return L;
}
LinkList ListInsert_Head(LinkList &L,int n){
	LinkList p;
	while(n--){
		p=new LNode;
		cin >> p->data;
		p->next=L->next;
		L->next=p;
	}
	return L;
}
LinkList ListInsert_Tail(LinkList &L,int n){
	LinkList p;
	LinkList r;
	r=L;
	while(n--){
		p=new LNode;
		cin >> p->data;
		p->next=NULL;
		r->next=p;
		r=p;
	}
	return p;
}
int TraveList(LinkList &L){
	LinkList p;
	p=L->next;
	int k=0;
	while(p){
		cout << p->data << " ";
		p=p->next;
		k++;
	} 
	cout << endl;
	cout << "The length is " << k << endl;
	return k;
}

int main()
{
	LinkList L,La;
	int n,m;
	while(true){
		cin >> n;
		InitList(L);
		ListInsert_Tail(L,n);
		TraveList(L);
		//f2(L,2);
		//f3(L->next);
		//f5_2(L);
		//f6_Sort(L);
		
		/*int s,t;
		cin >> s >> t;
		f7(L,s,t);*/
		//L=f8(L,La);
		//f9(L);
		//cin >> m;
		InitList(La);
		//ListInsert_Tail(La,m);
		//TraveList(La);
		La=f10(L);
		TraveList(L);
		TraveList(La);
	}
	return 0;
}