链表C语言实现

链表

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

下图为单链表的逻辑结构类型：

链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向：

2：带头和不带头：

3：循环和不循环

顺序表和链表对比：

C语言基本操作：

头文件：

#include <stdio.h>
#include <stdlib.h>

初始化：

typedef struct LNode *List;
struct LNode{
	ElementType Data;
	List Next;
};
struct LNode L;
List Next;

 求表长：

int Length(List PtrL )
{
	List p=PtrL;//p指向的第一个结点
	int j=0;
	while(p)
	{
		p=p->Next;
		j++;//当前p指向的是第j个结点	
	} 
	return j; 
}

2.查找

(1)按序号查找：FindKth()

List FindKth(int K,List PtrL )
{
	List p=PtrL;//p设为链表表头 
	int i=1;
	while(p!=NULL && i<K)
	{
		p=p->Next;
		i++;	
	}	
	if(i == K) return p;
		//找到第K个，返回指针
	else return NULL;
		//否则返回空 
} 

(2)按值查找：Find()

List Find(ElementType X,List PtrL)
{
	List p=PtrL;
	while(p!=NULL && p->Data !=X )
		p=p->Next;
	return p; 
	//若找到则返回X所在地址p，否则返回NULL 
 } 
 

3.插入(在第i-1（1<=i<=n+1）个结点后插入一个值为X的新结点)

算法描述

(1)先构造一个新结点，用s指向
(2)再找到链表第i-1个结点，用p指向
(3)然后修改指针，插入结点(p之后插入新结点是s)

代码：

List Insert(ElementType X,int i,List PtrL)
{
	List p,s;
	if( i==1 )	//新结点插入在表头 
	{
		s=(List)malloc(sizeof(struct LNode));//申请、填装结点
		s->Data=X;
		s->Next = PtrL;
		return s; 
	 } 
	p = FindKth(i-1,PtrL);//查找第i-1个结点
	if(p==NULL)
	{//第i-1个不存在，不能插入 
		printf("参数i错误");
		return NULL; 
	} 
	else
	{
		s=(List)malloc(sizeof(struct LNode));//申请、填装结点 
		s->Data=X;
		s->Next=p->Next;//新结点插在第i-1个结点后面
		p->Next=s;
		return PtrL; 
	}
} 

4.删除(删除链表的第i(1<=i<=n)个位置上的结点)

算法描述

(1)先找到链表的第i-1个结点，用p指向
(2)再用指针s指向要被删除的结点(p的下一个结点)
(3)然后修改指针，删除s所指结点
(4)最后释放s所指结点的空间

代码：

List Delete(int i,List PtrL)
{
	List p,s;
	if(i == 1)
	{//若要删除的是表第一个结点 
		s=PtrL;//s指向第1个结点
		if(PtrL!=NULL)//从链表中删除 
			PtrL =PtrL->Next; 
		else
			return NULL;
		free(s);	//释放被删除结点 
		return PtrL; 
	}
	p=FindKth(i-1,PtrL);//查找第i-1个结点
	if(p==NULL) 
	{
		printf("第%d个结点不存在",i-1);
		return NULL;
	}	
	else if(p->Next==NULL)
	{
		printf("第%d个结点不存在",i);
		return NULL;
	}
	else
	{
		s=p->Next;//s指向第i个结点 
		p->Next=s->Next;//从链表中删除 
		free(s);//释放被删除结点 
		return PtrL;
	}
}

一、双向链表定义

双向链表（double linked list）是在单链表的每个结点中，再设置一个指向其前驱结点的指针域

二、空表的判断条件

//head的是头结点
p->next = head;
//或者
p->prior = head;

三、双向链表的基本操作

typedef int ElemType;
typedef struct DNode
{
	ElemType data;
	struct DNode* next; //直接后继指针
	struct DNode* prior; //直接前继指针
}DNode, * DLinkList;

1.整表的创建

void CreateDCLinkList(DCLinkList* L,int n)
{
	DCLinkList r,s;
	int data;
	(*L) = (DCLinkList)malloc(sizeof(DNode)); //创建头结点
	(*L)->next = (*L);  //初始化头结点的后继指针指向自己
	(*L)->prior = (*L);  //初始化头结点的前驱指针指向自己
	r = (*L); //工作指针
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &data);
		s = (DCLinkList)malloc(sizeof(DNode));
		s->data = data;
		s->prior = r;     //连接上一结点
		s->next = (*L);  //新结点的后继指向头结点
		r->next = s;     //上一结点连接新结点
		(*L)->prior = s; //头结点的前继指向新节点
		r = s; //更新工作指针
	}
}

2.结点的获取

/*初始条件：表已经存在*/
/*操作结果：返回第i个位置的结点*/
DLinkList GetDNode(DLinkList DL, int i)
{
	if (i == 0)
		return DL;
	int j = 1;
	DLinkList p = DL->next;  //从第一个结点开始
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	//p等于NULL说明已经遍历完整个链表也没有找到，j大于i说明i不合法
	if (p == NULL || j > i) 
		return NULL;
	return p;
}

3.求表长

/*初始条件：表已经存在*/
/*操作结果：返回表长*/
int GetLength(DLinkList DL)
{
	int count = 0;
	//画图细细体味
	while(DL->next)  
	{
		DL = DL->next; 
		count++;
	}
	return count;
}

4.插入结点

/*初始条件：表已经存在*/
/*操作结果：在第i个结点插入结点*/
int ListInsert(DLinkList* DL, int i, ElemType e)
{
	DLinkList p, s;
	p = GetDNode((*DL), i - 1); //找到第i个结点的上一结点，方便插入操作
	if (p == NULL)
		return 0;
	s = (DLinkList)malloc(sizeof(DNode));
	s->data = e;
	s->prior = p; //把p赋值给s的前驱，如图①
	s->next = p->next;  //把p的后继赋值给s的后继，如图②
	p->next->prior = s; //把s赋值给p的下一结点的前驱，如图③
	p->next = s; //把s赋值给p的后继，如图④
	return 1;
}

5.结点的删除

/*初始条件：表已经存在*/
/*操作结果：删除第i个位置上的结点，并用e回收删除结点的数据域*/
int ListDelete(DLinkList* DL, int i,ElemType* e)
{
	DLinkList p;
	p = GetDNode((*DL), i); //注意，这里直接找到要删除结点的位置，不需要像插入一样找前驱结点
	if (p == NULL)
		return 0;
	if (i == GetLength(*DL))   //最后一个结点的删除方式，删除最后一个结点于其他结点的操作不同
	{
		p->prior->next = NULL;
	}
	else
	{
		p->prior->next = p->next; //图①
		p->next->prior = p->prior; //图②
	}
	*e = p->data;
	free(p);
	return 1;
}

6.整表删除

/*初始条件：表已经存在*/
/*操作结果：删除所有数据元素，将表重置为空表*/
void ClearList(DLinkList* DL)
{
	DLinkList p, s;
	p = (*DL)->next; //从第一个结点开始删除
	while (p)
	{
		s = p; //备份要删除的结点
		p = p->next; //移动到下一个结点
		free(s); //删除备份结点
	}
	(*DL)->next = NULL; //重置头结点的后继为空
}