【学习笔记----数据结构03--线性链表】_一些随机产生的数采用线性链表存储-CSDN博客

顺序存储结构不足的解决办法

前面我们讲的线性表的顺序存储结构。它是有缺点的，最大的缺点就是插入和删除时需要移动大量元素。

线性表链式存储结构定义

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置。
为了表示每个数据元素a_i与其直接后继数据元素a_i+1之间的逻辑关系，对数据元素a_i来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息(即直接后继存储的存储位置)。

我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称做指针或链。这两部分信息组成数据元素ai的存储映像，称为结点。

n个结点(a_i的存储映像)链结成一个链表，即为线性表（a₁,a₂,…,a_n）的链式存储结构，因为此链表的每个结点中只包含一个指针域，所以叫做单链表。单链表正是通过每个结点的指针域将线性表的数据元素按其逻辑次序链接在一起。

我们把链表中第一个结点存储的位置叫做头指针，那么整个链表的存取就必须是从头指针开始进行了。线性链表的最后一个结点的指针为“空”通常用NULL或^符号表示

有时，我们为了更加方便地对链表进行操作，会在单链表的第一个结点前附设一个结点，称为头结点。头结点的灵气域可以不存储任何信息。也可以存储线性表的长度等附加信息，头结点的指针域存储指向第一个结点的指针。
头指针与头结点的异同

头指针

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

头结点

头结点是为了操作统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义（也可以存放链表长度）
有了头结点，对在第一个元素结点前插入结点的和删除第一结点，其操作与其它结点的操作就统一了
头结点不一定是链表的必须要素。

线性表链式存储结构代码描述

单链表中，我们在C语言中可以用结构指针来描述：

typeof struct Node
{
  ElemType data;
  struct Node *next;
} Node;
typeof struct Node *LinkList /*定义LinkList*/

由这个结构我们可知：结点由存放数据元素的数据域和存放后继结点的地址的指针域组成。
单链表的读取

在线性表的顺序存储结构中，我们要计算任意一个元素的储存位置是很易。但在单链表中，由于第i个元素到底在哪？没办法一开始就知道，必须得从头开始找。因此对于单链表实现获取第i个元素的数据的操作GetElem，在算法上，相对要麻烦一些，思路：

声明一个结点p指向链表第一个结点，初始化j从1开始；
当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1；
若到链表未必p为空，则说明第i个元素不存在；
否则查找成功，返回结点p的数据

/*初始条件：顺序线性表L已存在，1<=i<=ListhLength(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;
     ++j;
   }
   if(!p || j>i) return   ERROR;
    *e = p->data;
   return OK;
}

单链表的插入与删除

单链表的插入

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

Status  ListInsert(LinkList   *L,int  i,ElemTye e)
{
  int   j;
  LinkList  p,s;
  p  =  *L;
  j  =1;
  while(p  &&   j<i)
   {
     p = p->next;
     ++j;
   }
  if(!p || j>i) return ERROR;
  s= (LinkList)malloc(sizeof(Node)) ; //生成新结点（c标准函数）
  s->data = e;
  s->next = p->next;
  p->next = s;
  return OK;
}

单链表的删除

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

Status  ListDelete(LinkList  *L,int  i,ElemType *e)
{
  int  j;
  LinkList  p,q;
  p = *L;
  j = 1;
  while(p->next&&  j<i)
  {
    p = p->next;
    ++j;
  }
 if(！(p->next) || j>i)  return ERROR;
 q = p->next;
 p->next=q->next;
 *e = q->data;
 free(q);
 return OK;
}

对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显。
单链表的整表创建

思路：
1. 声明一结点p和计数器变量i;
2. 初始化一空链表L；
3. 让L的头结点的指针指向NULL，即建立一个带头结点的单链表；
4. 循环：生成一新结点赋值给p
随机生成一数字赋值给p的数据域p->data;
将p插入到头结点与前一新结点之间。
代码如下：

void CreateListHead(LinkList   *L,int n)
{
  LinkList  p;
  int   i;
   srand(time(0));//初始化随机数种子
  *L= (LinkList)malloc(sizeof(Node));
  (*L)->next= NULL;
  for(i=0;i<len;i++)
   {
      p=(LinkList)malloc(sizeof(Node)); //生成新结点
     p->data = rand()%100+1;
     p->next = (*L)->next;
     (*L)->next = p;
    }
}

该方法始终让新结点在第一的位置。我也可以是这种算法简称为头插法
每次把新结点插在终端结点的后面这种算法称之为尾插法。

void CreateListTail(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;
      r->next = p
      r=p;
   }
    r->next =NULL;
}

r->next=p的意思，其实就是将刚才的表尾终端结点r的指针指向新结点p。
r=p;的意思:本来r是在ai-1元素上，可是它已经不是最后的结点了，现在最后的结点是ai，所以应该要让将p结点这个最后的结点赋值给r。此时r又是最终的尾结点了。循环结束后，那么应该让这个节点的指针域置空，因此有了r->next = NULL;
单链表的整体删除

思路：

声明一结点p和q
将第一个结点赋值给p;
循环：
将下一结点赋值给q;
释放q赋值给p。

Status  ClearList(LinkList  *L)
{
    LinkList    p,q;
    p= (*L)->next;
   while(p)
   {
      q = p->next;
      free(p);
      p = q;
   }
   (*L)->next =NULL;
   return OK;
}

单链表结构与顺序存储结构的优缺点
存储分配方式
时间性能
空间性能