数据结构与算法-表（单链表 循序表 ）

小孱弱弱分享一下线性表中的循序存储结构和链式存储结构，不足之处，请指教~
小老弟抱拳了~
先说一说线性表list的定义：0个或多个数据元素的有限序列。线性表的概念其实还是很大的，向量vector，链表list，栈stack，队列queue，都属于线性表，只不过他们性质不同，用处自然也不同了。
首先，介绍线性表的顺序存储结构-顺序表，顺序表的特色就是，所有的数据元素都存储在一段连续的存储单元中。一个数据元素紧挨着一个，类似于我们的一维数组和STL中的向量vector。
下面是顺序表c语言的实现：所谓数据结构的操作，不外乎增删改查！！

//定义 
struct SqList
{
 int data[MAXN];
 
 int length;//表长 
 
} ;
//查
int GetElem(SqList L,int i,int *e)
{
 if(L.length==0||i<1||i>L.length)
  return  0;
 *e=L.data[i-1];
 return 1;
}
//增
int ListInsert(SqList *L,int i, int e)
{
 int k;
 
 if(L->length==MAXN)
  return 0;
 if(i<1||i>L->length+1)
  return 0;
 if(L->length)
  for(k=L->length-1;k>=i-1;k--)
   L->data[k+1]=L->data[k];
  L->data[i-1]=e;
  L->length++;
  
  return 1;
  
} 
//删
int ListDelete(SqList *L,int i,int *e)
{
 int k;
 
 if(L->legth==0)
  return 0;
 if(i<1||i>L->length)
   return 0;
 *e=L->data[i-1];
 
 if(i<L->length)
  for(k=i;k<L->length;k++)
   L->data[k-1]=L->data[k];

 L->length--;

 return 1;


 } 

顺序表最大的特色就是查和改，它能够在平凡的时间复杂度找到合法的数据元素，改变合法数据，只需遍历整个表，最坏就是在最后一个位置找到，这似乎是很完美的，但是对于增删，由于一个萝卜一个坑，我们要改动一个一个数据结点，从他开始往后一直到尾节点都需要移动，这无疑是巨大的时间损耗。为了方便增删，我们引入单链表：
单链表，顾名思义，他是链式存储结构，为了方便的增加或者删除某个元素，我们存储每个元素的位置不能连续，那如何从一个结点找到它的后继呢？c语言提供了强大的武器—指针，我们可以在每一个元素上附带一个指针，指向下一个元素也就是该元素的后继，这样就可以方便的存储数据了，我们利用c语言中的结构体struct给他封装一下，每一个结点由数据域data和指针域next构成，为了方便遍历，我们设置一个头指针指向，第一个节点也就是头结点，至于最后一个结点也就是尾结点，他没有后继了，那他的指针域咋办，不收拾一下他他会成了野指针了，后果很严重，所以我们零尾结点的指针域指向NULL，也就是空指针。完美解决问题！！！棒棒哒~
上代码：

//定义
struct Node
{
	int data;	
	struct Node* next; 
	
};
typedef struct Node *LinkList;//换名字 
//查
int GetElem(LinkList L,int i,int *e)
{
	int j;
	LinkList p;
	p=L->next;
	j=1;	
	while(p&&j<i)
	{
		p=p->next;
		j++;
	}
	if(!p||j>i)//空指针 
		return false;
	*e=p->data;
	return true; 
 } 
//增
int LinkInsert(LinkList *L,int i, int e)
{//在第i个结点之前 
	int j;	
	LinkList p,s;//目标节点和要增加的结点 	
	p=*L;	
	j=1;	
	while(p&&j<i)
	{
		p=p->next;
		j++;
	} 
	if(!p||j>i)
		return false;
	s=(LinkList)malloc(sizeof(Node));	
	s->data=e;	
	s->next=p->next;	
	p->next=s;	
	return true;	
 } 
//删
int  ListDelete(LinkList *L,int i,int *e)
{
	int j;	
	LinkList p,q;	
	p=*L;	
	while(i<j||p)
	{
		p=p->next;
		j++; 
	}
	if(!(p->next||j>i))
		return false;		
	q=p->next;	
	p->next=q->next;	
	*e=q->data;	
	free(q);	
	return true;
}
//整表创建(头插法)
void CreateListHead(LinkList *L,int n)
{
	LinkList p;
	int i;
	srand (time(NULL));
	*L=(LinkList)malloc(sizeof(Node));//头结点 
	(*L)->next=NULL;
	for(i=0;i<n;i++)
	{
		p=(LinkList)malloc(sizeof(Node));
		p->data=rand()%100+1;//随机初始化1~100的数字
		p->next=(*L)->next;
		(*L)->next=p;  
	}
 } 
 //整表创建(头插法)
 void CreateListTail(LinkList *L,int n)
 {
 	LinkList p,r;
 	int i;
 	srand(teme(NULL));
 	*L=(LinkList)malloc(sizeof(Node));//尾节点 
 	r=*L;
	for(i=0;i<n;i++)
	{
		p=(Node*)malloc(sizeof(Node));
		p->data=rand()%100+1;
		r->next=p;
		r=p;//r重新是尾节点 
	}
 }
 //整表删除
int  GlearList(LinkList *L);
 {
 	LinkList p,q; 	
 	p=(*L)->next;	
	while(p)
	{
		q=p->next;		
		free(p);		
		p=q;
	}
	  (*L)->next=NULL;	  
	  return true; 
} 

最后我们分析一下这两种线性表：
从存储方式上：
顺序表采用一段连续的内存空间。
单链表采用任意位置存储数据元素。
从时间性能上：
查找：1.顺序表是O(1)2.单链表是O（n）
插入删除操作：1.顺序表是O(n)2.单链表是O（1）
从空间性能上：
顺序表需要提前分配内存空间，易发生空间浪费或者上溢。
单链表不需要提前分配内存，动态添加，较为方便。