数据结构-线性表（链式存储结构）

线性表（链式存储结构）

特点：

用一组任意的存储单元存储线性表的数据结构，这组存储单元可以是连续的，也可以是不连续的。

对数据结构ai来说，除了存储其本身的信息之外，还需存储一个指示其后继的信息（即直接后继的存储位置）。

数据域：存储数据元素信息的域。
指针域：存储直接后继位置的域。
数据域+指针域=结点

n个结点链结成一个链表，即为线性表的链式存储结构。因为此链表的每个结点只含一个指针域，所以叫做单链表。

链表中的第一个结点的存储位置（地址）也叫做头指针，最后一个结点指针为空，通常用NULL或者"^"表示。为了方便的对链表进行操作，会在单链表的第一个结点前附设一个头结点（可以不存储任何信息，头结点的指针域指向第一个结点的指针）

1⃣️头指针和头结点的异同

头指针

1.头指针是指向链表第一个结点的指针，若链表有头结点，则是指向头结点的指针
2.头指针具有标识作用，所以常用头指针冠以链表的名字。
3.无论链表是否为空，头指针均不为空。头指针是链表的必要元素

头结点

1.头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义。
2.有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其他结点的操作就统一了。
3.头结点不一定是链表的必要元素。

2⃣️单链表的读取

获取链表第i个数据的算法思路
1.声明一个指针p指向链表第一个结点，初始化j从1开始
2.当i<j时，就遍历链表，让p的指针向后移动，不断只想下一结点，j累加1。
3.若到链表末尾为空，则说明第i个结点不存在。
4.否则查找成功，返回结点p的数据。

/*初始条件：顺序线性表L已经存在，1<=i<=Listlength(L)*/
/*操作结果：用e返回L中第i个数据元素的值*/
Status Getelem(Linklist L,int i, ElemType *e)
{
	int j;
	Linklist p; /*声明一个结点p*/
	p=L->next; /*让p指向链表L的第一个结点*/
	j=1; /* j为计数器*/
	while (p && j<i){/*p不为空，且计数器j的值还没有等于i的时候开始遍历*/
	p=p->next;  /*p指向下一个结点*/
	++j; /*j加一*/
	}
	if (!p || j>i)/*若第I个结点不存在*/
		return error;
	*e = p->next; /*将第i个结点返回给e*/
	return OK;
}

6⃣️单链表的插入

 s->next=p-next; 
 p->next=s;

如果先p->next=s;再s->next=p->next;那么会使的p->next覆盖成s的地址，那么s->next=p->next，其实等于s->next=s;这样真正的拥有ai+1的数据元素结点就没了上级。

单链表第i个数据插入结点的算法思路：
1.声明一个指针指向链表头结点，初始化j从1开始。
2.当j<i时，就遍历链表，让p的指针向后移动，不断只想下一结点，j累加1。
3.若到链表末尾为空，则说明第i个结点不存在。
4.否则查找成功，在系统中生成一个空结点s。
5.将数据元素e 赋值给s->data。
6.单链表的插入标准语句

s->next=p->next;
p->next=s;

7.返回成功。

/*初始条件：顺序线性表L已经存在，1<=i<=Listlength(L)*/
/*操作结果：用e返回L中第i个数据元素的值*/
Status Getelem(Linklist L,int i, ElemType *e)
{
	int j;
	Linklist p; /*声明一个结点p*/
	p=L->next; /*让p指向链表L的第一个结点*/
	j=1; /* j为计数器*/
	while (p && j<i){/*p不为空，且计数器j的值还没有等于i的时候开始遍历*/
	p=p->next;  /*p指向下一个结点*/
	++j; /*j加一*/
	}
	if (!p || j>i)/*若第I个结点不存在*/
		return error;
	s=(Linklist)malloc(sizeof(Node));
	s->data=e;
	s->next=p->next;/*将p的后继结点复制给s的后继*/
	p->next=s;/*将s的值赋给p的后继*/
	return ok;
}

3⃣️单链表的删除

q=p->next;
p->next=q->next;

单链表第i个数据删除结点的算法思路
1.声明一个指针指向链表头结点，初始化j从1开始。
2.当j<i时，就遍历链表，让p的指针向后移动，不断只想下一结点，j累加1。
3.若到链表末尾为空，则说明第i个结点不存在。
4.否则查找成功，将欲删除的结点p->next赋值给q。
5.单链表的删除标准语句p->next=q->next。
6.将结点q中的数据赋值给e，作为返回。
7.释放q结点。

/*初始条件：顺序线性表L已经存在，1<=i<=Listlength(L)*/
/*操作结果：用e返回L中第i个数据元素的值*/
Status Getelem(Linklist L,int i, ElemType *e)
{
	int j;
	Linklist p; /*声明一个结点p*/
	p=L->next; /*让p指向链表L的第一个结点*/
	j=1; /* j为计数器*/
	while (p && j<i){/*p不为空，且计数器j的值还没有等于i的时候开始遍历*/
	p=p->next;  /*p指向下一个结点*/
	++j; /*j加一*/
	}
	if (!p || j>i)/*若第I个结点不存在*/
		return error;
	q=p->next;
	p->next=q->next;/*将q的后继赋值给p的后继*/
	*e=q->data;/*将q结点的数据给e*/
	free(q);/*释放结点q*/
	return ok;
}

4⃣️单链表的整表创建

单链表整表创建的算法思路：
1.声明一指针p和计数器变量i
2.初始化以空链表L
3.让L的头结点的指针指向NULL，即建立一个带头结点的单链表。
4.循环
(1)生成一新结点p
(2)随机生成一数字赋值给p的数据域p->data
(3)将p插入到头结点与前一新结点之间
ps:（头插法）

#include <stdio.h>
#include <stdlib.h>
#define N 10


struct Data{
   int num;
   struct Data *next;
};


int main ( int argc , char * argv[])
{
   int data,i;
   struct Data *head,*p;
   head = (struct Data *)malloc (sizeof(struct Data));
   head->next = NULL;
     for ( i = 0; i < N; i++)
     {
    scanf ("%d",&data);
p = ( struct Data *)malloc(sizeof(struct Data));
p->num = data;
p->next = head->next;
head->next = p;
}

尾插法：把每次新结点都插到终端结点的后面

/*随机产生n个元素的值，建立带头结点的单链线性表L(尾插法)*/
void CreatListTail (Linklist *L,int n)
{
	Linklist p,r;
	int i;
	srand(time(0)); /*初始化随机数种子*/
	*L = (Linklist)malloc(sizeof(Node));/*为整个线性表*/
	r = *L; /*r为指向尾部*/
	for (i=0;i<n;i++){
	p = (Node *)malloc (sizeof(Node)); /*生成新结点*/
	p->data = rand () %100+1; /*随机生成100以内的数字*/
	r->next = p; /*将表尾终端结点的指针指向新结点*/
	r = p; /*将当前的新结点定义为表尾终端结点*/
	}
	r->next = NULL; /*表示当前链表结束*/
}

5⃣️单链表的整表删除

单链表整表删除的算法思路：
1.声明结点p和q
2.将第一个结点赋值给p
3.循环
(1)将下一个结点赋值给q
(2)释放p
(3)将q赋给p

/*初始化条件：顺序线性表L已经存在，操作结果：将L重置为空表。*/
Status ClearList(LinkList *L)
{
	LinkList p,q;
	p=(*L)->next; /*p指向第一个结点*/
	while(p) /*没到表尾*/
	{
		q=p->next;
		free(p);	
		p=q;
	}
	(*L)->next=NULL; /*头指针指针域为空*/
	return ok;
}

6⃣️单链表结构与顺序存储结构优缺点

**存储方式：
顺序存储分配方式：用一段连续的存储单元依次存储线性表额度数据元素
单链表：采用链式存储结构，用一组任意的存储单元存放线性表的元素
时间性能：
*顺序存储结构需要平均移动表长一半的元素，时间为O(n);
*单链表在线出某位置的指针后，插入和删除时间仅为O(1);
空间性能：
顺序存储结构需要预分配存储空间，分大了，浪费，分小了容易发生上溢
单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制