从零开始的数据结构学习日记（二）——1.2链表

1.1单链表

用内存域中连续或不连续的存储单元来存储线性表的数据元素，每个元素都含有一个数据域和一个指针域。

1.1.1单链表的类型

typedef 某个数据类型 datatype
{
	datatype data;
	struct node*next;
}linklist;
linklist*head,*p;//head为头指针，p为工作指针

1.1.2单链表的头结点

头结点是在单链表的第一个结点之前附设一个结点，头结点数据域可以存放一些特殊信息。其好处有：由于开始结点的位置被存放在头结点的指针域中，所以对链表第一个结点的操作同其他结点一样；无论链表是否为空，其头指针是指向头结点的非空指针，因此对于空表与非空表的处理统一化。

1.1.3单链表的基本运算

1.建立单链表

1.头插法建表

从空表开始，每次将输入的字符作为新结点插入到表头，链表中的结点的次序与输入的字符顺序相反。

linklist*CreateListF()//头插法，返回单链表的头指针
{
	linklist*head,*p;
	char ch;
	head=(linklist*)malloc(sizeof(linklist));//产生头结点
	head->next=NULL;
	while((ch=getchar())!='\n')
	{
		p=(linklist*)malloc(sizeof(linklist))//生成新的结点
		p->next=head->next;
		head->next=p;
		p->data=ch;
	}
	return *head;
}

循环体执行了n次，故时间复杂度为O(n).

2.尾插法

将新节点插入到表尾，链表中结点的次序与输入的字符的顺序相同。

linklist*CreateListR()//带头结点的尾插法，返回头指针
{
	linklist*head,*p,*r;
	char ch;
	head=(linklist*)malloc(sizeof(linklist));
	head->next=NULL;
	while(ch=getchar()!='\n')
	{
		p=(linklist*)malloc(sizeof(linklist));//创建新结点
		p->data=ch;//输入数据
		r->next=p;//将新节点链接至表尾
		r=p;//r指针重新指向表尾
	}
	r->next=NULL;
	return *head;
}

时间复杂度为O(n).

2.查找

1.按序号查找

链表只能从头指针出发，沿着结点的指针域进行搜索，直至找到第i个结点为止。

linklist*Get(linklist*head,int i)//感觉有点反人类...
{
	linklist*p=head;
	int j=0;
	while(p->next!=NULL&&j<i)
	{
		p=p->next;
		j++;
	}
	if(i==j)
	{
		return p;
	}
	else return NULL;
}

2.按值查找

linklist*Locate(linklist*head, datatype key)
{
	linklist*p=head->next;
	while(p!=NULL&&p->data!=key)
	{
		p=p->next;
	}
	return p;
}

3.插入

void Insert(linklist*L, datatype x, int i)
{
	linklist*p,*s;
	p=Get(L,i-1);//插入只能做“后插”，不能“前插”,所以是i-1
	if(p==NULL)
	{
		printf("查找不到第i-1个结点")；
	}
	else
	{
		s=(linklist*)malloc(sizeof(linklist));
		s->data=x;
		s->next=p->next;
		p->next=s;
	}
}

4.删除

void delete(linklist*L,int i)
{
	p=Get(L,i-1);
	if(p!=NULL&&p->next!=NULL)
	{
		r=p->next;
		p->next=r->next;
		free(r);//记得释放掉r结点
	}
	else printf("结点不存在")；
}

1.2循环链表

循环链表是一种首尾相接的链式存储结构，特点是单链表最后一个结点的指针域指向头结点或开始结点，整个链表形成一个环，从表中任一结点出发均可找到表中的其他结点。
采用尾指针的时间复杂度为O(1),代码如下：

linklist*connect(linklist*La,linklist*Lb)
{
	linklist*p=La->next;//指向a的头结点
	La->next=Lb->next->next;//将b连接到a的后面
	free(Lb->next);
	Lb->next=p;
	return Lb;
}

时间复杂度为O(1).

1.3双向链表

双向链表也可以采用循环链表，将头结点和终端结点链接起来，构成顺逆时针两个环。

1.3.1双向链表的类型

typedef struct dnode
{
	datatype data;
	struct dnode*rear,*next;
}dlinklist;

1.3.2双向链表的基本运算

1.后插(在结点p之后插入结点s)

void DInsertAfter(dlink*p,datatype x)
{//在带头结点的非空双向链表中，将值为x的结点插入*p之后
	dlinklist*s=(dlinklist*)malloc(sizeof(dlinklist));
	s->data=x;
	s->prior=p;
	s->next=p->next;
	p->next->prior=s;
	p->next=s;
}

2.前叉(在结点p之前插入结点s)

void DInsertBefore(dlinklist*p, datatype x)
{
	dlinklist*p=(dlinklist*)malloc(sizeof(dlinklist));
	s->data=x;
	s->prior=p->prior;
	s->next=p;
	p->prior->next=s;
	p->prior=s;
}

3.删除

void DDelete(dlinklist*p)
{
	p->prior->next=p->next;
	p->next->prior=p->prior;
	free(p);
}