顺序表--单链表,双向链表的c语言的基本操作

链表由各个结点链接而成
结点=数据域+指针域（数据域存储存储数据，指针域存储下一结点的地址）
头指针指向头结点，头结点不存储数据，首元结点为第一个保存数据的结点
下面是单链表用c语言表示的代码
单链表的定义：

typedef struct Lnode{		//声明结点的类型和指向结点的结点类型
	Elemtype data;		//结点的数据域，Elemtype为自己使用typedef定义的数据类型
	struct Lnode *next;	//结点的指针域
}Lnode,*Linklist;		//Linklist为指向Lnode的指针类型

如果用单链表存储学生信息，则可以定义为

typedef struct{
	char num[10]		//学号
	char name[20];		//性别
	int score			//分数
}Elemtype;			//定义学生类型
typedef struct Lnode{
	Elemtype data;
	struct Lnode *next;
}Lnode,*Linklist;

单链表的初始化（构造一个空表）
1.生成新结点作为头结点
2.将头结点的指针域置空

void Initlist(Linklist &L)		//链表初始化 
{L=(Linklist)malloc(sizeof(Lnode));
L->next=NULL;
}

插入

void Linklistinsert(Linklist &l,int i,Elemtype e)		//链表插入 
{	if(i>length+1)		//宏定义长度，只能在第1个到第length+1个内插入，要保证是连着的
		{printf("插入位置不合法");
		}
	else{
	Linklist s,b;
	Initlist(s);		//初始化链表
	Initlist(b);
	s=l;			
	int j=0;
	while(s&&j<i)
		{s=s->next;	
		j++; 
		} 		//找到第i-1个位置
	b->data =e;	
	b->next=s->next;		//b的next保存原来第i个元素的地址
	s->next=b;		//将第i-1个next域变为b（新结点的地址）
	length++;		//链表长度加一
	}
}

删除

void Linklistdelete(Linklist &l,Elemtype e)
{	if(e>length)
		{printf("删除位置不合法");
		}
	else{Linklist s,b;
	Initlist(s);
	Initlist(b);
	s=l;
	int j=0;
	while(s&&j<e)
		{s=s->next;	
		j++; 
		} //找到第e-1个结点
	b=s->next;		//b指向第e个结点，便于释放
	s->next=s->next->next;	//第e-1的next域指向下下个地址
	free(b);		//释放删除结点
	length--;//长度减一
	}
}

求单链表长度函数

int Listlength(Linklist &l)		//链表长度 
{
	Linklist p;
	int len=0;
	p=l->next->next;
	while(p)
	{len++;
	p=p->next;
	}
	return len;
 } 

删除单链表中大于等于min并且小于等于max的结点

void Linklistselect(Linklist &l,int max,int min) 
	{Linklist p,q;
	if(l->next->next!=NULL)
	{q=l->next;
	p=l->next->next;
		while(p)
		{if((p->data<=max)&&(p->data>=min))
		{	q->next=p->next;
		free(p);
		p=q->next;
		}
		else {
		q=p;p=p->next;
		}
		}	
	}
	}

判断链表是否为空（链表中无元素，成为空表）
判断头结点是否为空

int ListEmpty(Linklist L)
	{
		if(L->next==NULL)
			return 1;//是空的
		else return 0;//非空
	}

单链表的销毁（链表销毁后不存在）
从头指针开始依次释放所有结点（头指针指向头结点）

void DestroyList(Linklist &l)
{
	Linklist p;
	while(l)
	{
		p=l;
		l=l->next;
		free(p);
	}
}

清空链表（将链表置为空表）
头结点的指针域为空，有数据存在的结点全部释放

void clearList(Linklist &l)
{
	Linklist p,q;
	p=l->next;
	while(p)
	{
		q=p;
		p=p->next;
		free(q);
	}
	l->next=NULL;		//头指针的指针域为空
}

单链表查找元素在链表当中的第几个（第一次出现的位置）
返回第几个

int locationlist(Linklist l,Elemtype e)
{
	Linklist p;
	int a=0;
	p=l->next;
	while(p&&p->data!=e)
		{p=p->next;
		a++;
		}
	return a+1;
} 

返回地址

Linklist locationlist(Linklist l,Elemtype e)
{
	Linklist p;
	int l=0;
	p=l->next;
	while(p&&p->data!=e)
		{p=p->next;
		l++;
		}
	return p;
} 

双向链表的定义
双链表包含两个指针域和一个数据域，前一个指针域存放上一个结点的位置，后面的指针存放下一个结点的位置

typedef struct DuLnode
{
	Elemtype data;
	struct DuLnode *pri,*next; 
}DuLnode,*DuLinklist;

双向链表的初始化

void InitDuLnode(DuLinklist &l)
{
	l=(DuLinklist)malloc(sizeof(DuLnode));
	l->next=NULL;
	l->pri=NULL;
} 

双向链表的插入

void DuLnodeInsert(DuLinklist &L,int i,Elemtype e)
{	if(i>length+1)
		{printf("插入位置不当");
		exit(0);
		}
	DuLinklist q1,q2;
	q1=L;
	while(i--&&q1)
		{q1=q1->next;
		}
	InitDuLnode(q2);
	q2->data=e;
	q2->pri=q1;
	q2->next=q1->next;
	q1->next=q2;
	q2->next->pri=q2;
	length++;
}

双向链表的删除

void DuLnodeDelete(DuLinklist L,Elemtype e)
{	if(e>length)
		{printf("删除位置不当");
		exit(0);
		}
	DuLinklist q1,q2;
	q1=L->next;
	while(e--&&q1)
		{
			q1=q1->next;
		}
	printf("%d ",q1->data);
	q1->pri->next=q1->next;
	q1->next->pri=q1->pri;
	length--;
}