数据结构：1关于单向链表的基本操作

注：链表为不建立头结点型。

基本链表结构：

typedef int ElementType ;
typedef struct LNode *PtrToNode;
struct LNode{
	ElementType Data;
	PtrToNode Next;
};
typedef PtrToNode List;

1、建立单链表

（1）头插法，以9999为输入结尾，不算入链表指针中

#include<stdio.h>
#include<malloc.h>

typedef int ElementType ;
typedef struct LNode *PtrToNode;
struct LNode{
	ElementType Data;
	PtrToNode Next;
};
typedef PtrToNode List;

List read();
void print(List L);

//利用头插法建立单链表 
int main(void){
	List L;
	L = read();
	print(L);
	return 0;
} 

List read(){
	List L=NULL;
	int m;
	//输入数字9999插入结束 
	scanf("%d",&m);
	while(m!=9999){
		List link=(List)malloc(sizeof(struct LNode));
		link->Data=m;
		link->Next=L;
		L=link;
		scanf("%d",&m);
	}
	return L;
}

void print(List L){
	while(L){
		printf("%d ",L->Data);
		L=L->Next;
	}
	printf("\n");
	return;
}

运行结果：

（2）尾插法，9999为输入结束，把上面的read函数改成下面的即可。
※注意，尾插法需要建立三个list变量，L指向第一个结点

List read(){
	List L,s,r;
	int m;
	scanf("%d",&m);
	if(m!=9999){
		L=(List)malloc(sizeof(struct LNode));
		L->Data=m;
	}
	else{
		return NULL;
	}
	s=r=L;//r为表尾指针 
	scanf("%d",&m);
	while(m!=9999){
		s=(List)malloc(sizeof(struct LNode));
		s->Data=m;
		r->Next=s;
		r=s;
		scanf("%d",&m);
	}
	r->Next=NULL;  //注意，链表尾指针的next要赋值NULL
	return L;
} 

运行结果：

2、查找操作

（1）按序号查找结点值，返回结点地址

//按序号查找结点值 
List GetElem(List L, int i){
	int j=1;
	if(i<=0)
		return NULL;
	while(L&&j<i){
		L=L->Next;
		j++;
	}
	return L;
}

（2）按结点值查找表结点，返回结点地址

//按值查找表结点
List LocateElem(List L, ElementType e){
	while(L&&L->Data!=e)
		L=L->Next;
	return L;     //找到后返回该结点指针，否则返回NULL 
} 

3、插入操作

后插操作

//后插操作，在第i处插入结点s 
List Insert(List L,int i,List s) {
	//插在链表最前面 
	if(i==0){
		s->Next=L;
		return s;
	}
	//插在链表第一个元素后 
	else if(i==1){
		s->Next=L->Next;
		L->Next=s; 
	}
	//因为插入元素序号从1开始
	List p=GetElem(L,i-1);//插入后面，所以要找到其前驱结点
	s->Next=p->Next;
	p->Next=s;
	return L;
}

4、删除操作

（1）删除第i个结点

//删除操作，删除第i个结点
List Delete(List L,int i){
	List p=GetElem(L,i-1);
	List q=p->Next;
	p->Next=q->Next;
	free(q);
	return L;
} 

（2）删除结点p

要删除结点*p，通常的做法是从链表头开始顺序找到其前驱结点，然后再执行删除操作，复杂度为O(n)。

这里使用了删除p的后继节点来实现删除结点p的操作，实际就是将其后继结点的值赋予其自身删除后继结点，这样的时间复杂度为O(1)。

//删除操作，删除结点p
List Delete_(List L, List p){
	List q=p->Next;
	p->Data=p->Next->Data;
	p->Next=q->Next;
	free(q);
	return L;
} 

4、单链表逆转

//单链表逆转
List Reverse(List L){
	List p1,p2;
	p1=p2=NULL;
	while(L){
		p2=L->Next;
		L->Next=p1;
		p1=L;
		L=p2;
	}
	return p1;
} 

这种逆转将L全部清空了。

完整代码：

为了形成一个完整的代码，有些函数稍作改动。
这个main函数看起来惨不忍睹的… …

#include<stdio.h>
#include<malloc.h>

typedef int ElementType ;
typedef struct LNode *PtrToNode;
struct LNode{
	ElementType Data;
	PtrToNode Next;
};
typedef PtrToNode List;

List read();//读入操作 
void print(List L);
List GetElem(List L, int i);
List LocateElem(List L, ElementType e);
List Insert(List L,int i,List s);
List Delete(List L, int i);
List Delete_(List L, List p);
List Reverse(List L);

int main(void){
	List L;
	L = read();
	print(L);//输出整个链表元素 
	int loc;
	printf("输入寻找的结点序号，从1开始:"); 
	scanf("%d",&loc);//输入寻找的结点序号，从1开始 
	print(GetElem(L,loc));//输出序号结点及其后面的结点 
	ElementType e;
	printf("输入想找的结点的值,输出这个结点及其后面:"); 
	scanf("%d",&e);//输入想找的结点的值 
	print(LocateElem(L,e));//输出结点及其后面的结点 
	int i;
	printf("输入插入位置，插入的元素默认为0值,输出整个链表:"); 
	scanf("%d",&i);//输入插入位置，插入的元素默认为0值
	List k=L; 
	List s=(List)malloc(sizeof(struct LNode));
	s->Data=0;
	print(Insert(k,i,s));//输出插入后整个链表
	printf("输入删除结点序号，输出整个链表:"); 
	scanf("%d",&i) ;//输入删除结点序号 
	List n=L; 
	print(Delete(n,i));//输出删除后的链表
	printf("删除第二个结点，输出整个链表:\n"); 
	List m=L->Next,a=L;
	print(Delete_(a,m));//删除第二个结点
	printf("输出逆序后的链表:\n");
	print(Reverse(L));
	free(L);
	free(m);
	free(n); 
	free(k);
	free(s);
	free(a);
	return 0;
} 
创建链表操作,头插法 
//List read(){
//	List L=NULL;
//	int m;
//	//输入数字9999插入结束 
//	scanf("%d",&m);
//	while(m!=9999){
//		List link=(List)malloc(sizeof(struct LNode));
//		link->Data=m;
//		link->Next=L;
//		L=link;
//		scanf("%d",&m);
//	}
//	return L;
//}
//尾插法 
List read(){
	List L,s,r;
	int m;
	scanf("%d",&m);
	if(m!=9999){
		L=(List)malloc(sizeof(struct LNode));
		L->Data=m;
	}
	else{
		return NULL;
	}
	s=r=L;//r为表尾指针 
	scanf("%d",&m);
	while(m!=9999){
		s=(List)malloc(sizeof(struct LNode));
		s->Data=m;
		r->Next=s;
		r=s;
		scanf("%d",&m);
	}
	r->Next=NULL;
	return L;
} 

void print(List L){
	if(L==NULL)
		printf("NULL!\n");
	while(L){
		printf("%d ",L->Data);
		L=L->Next;
	}
	printf("\n");
	return;
}
//按序号查找结点值 
List GetElem(List L, int i){
	int j=1;
	if(i<=0)
		return NULL;
	while(L&&j<i){
		L=L->Next;
		j++;
	}
	return L;
}
//按值查找表结点
List LocateElem(List L, ElementType e){
	while(L&&L->Data!=e)
		L=L->Next;
	return L;     //找到后返回该结点指针，否则返回NULL 
} 
//后插操作，在第i处插入结点s 
List Insert(List L,int i,List s) {
	//插在链表最前面 
	if(i==0){
		s->Next=L;
		return s;
	}
	//插在链表第一个元素后 
	else if(i==1){
		s->Next=L->Next;
		L->Next=s; 
		return L;
	}
	List p=GetElem(L,i-1);
	s->Next=p->Next;
	p->Next=s;
	return L;
}
//删除操作，删除第i个结点
List Delete(List L,int i){
	if(i<=0){
		printf("输入有误!\n");
		return NULL; 
	}
	else if(i==1){
		List m=L;
		L=L->Next;
		free(m);
		return L;
	} 
	List p=GetElem(L,i-1);
	List q=p->Next;
	p->Next=q->Next;
	free(q);
	return L;
} 
//删除操作，删除结点p
List Delete_(List L, List p){
	List q=p->Next;
	p->Data=p->Next->Data;
	p->Next=q->Next;
	free(q);
	return L;
} 
//单链表逆转
List Reverse(List L){
	List p1,p2;
	p1=p2=NULL;
	while(L){
		p2=L->Next;
		L->Next=p1;
		p1=L;
		L=p2;
	}
	return p1;
} 

注：建立链表有头插法和尾插法，在源程序中都已给，直接注释替换使用。两种方法经过测试，都可以使用。
注：为了强行凑成一个大程序，可能有些函数会有一些改动，增强了一点点健壮性。