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

线性表的链式存储结构

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

存储数元素信息的域称为数据域，把存储直接位置的域称为指针域。指针域中存储的信息称作指针或链。这两个部分信息组成数据元素ai的存储映像，称为结点。（结点由存放数据元素的数据域存放后继结点地址的指针域组成）

 

头指针和头结点的异同

头指针：

l  头指针是指向链表第一个结点的指针，若链表有头结点，就是指向头结点的指针。

l  头指针具有标识作用，所以需要头指针冠以链表的名字。

l  无论链表是否为空，头指针均不为空。头指针是链表的主要元素。

 

头结点

l  为了操作的统一和方便设立的，放在第一元素的结点之前，其数据域一般无意义。

l  有了头结点，对在第一个元素前插入节点和删除第一节点，其操作与其他结点操作统一了。

l  头结点不一定是链表必须要素。

 

单链表的读取

获取单链表的思路：（核心思想：工作指针后移）

1.      声明一个结点p指向链表第一个结点，初始化j从1开始；

2.      当j < i时，就遍历链表，让p的指针向后移动，不断指向下一个节点，j累加1

3.      若链表末尾p为空，则说明第i个元素不存在

4.      否则查找成功，返回结点P的数据

 

 

单链表的插入与删除

插入

单链表第i个数据插入节点的算法思路：

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.      返回成功

 

//初始条件:顺序线性表L已存在，i <= i <= ListLenth(L)
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1

Status ListInsert(LinkList *L, int i, ElemType e)
{
    int j;
    LinkList p,s;
    p = *L;
    j = 1;
    
    while(p && j < i)    //寻找第i个结点
    {
         p = p->next;
         ++j;
    }
    if(!p || j > i)
    {
        return ERROR;    //第i个元素不存在
    }
    
    a = (LinkList)malloc(sizeof(Node));   //生成新结点
    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.      返回成功。

//初始条件:顺序线性表L已存在，i <= i <= ListLenth(L)
//操作结果：删除L中第i个数据元素，并用e返回其值，L的长度减1

Status ListDelete(LinkList *L, int i, ElemType e)
{
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    
    while(p && j < i)    //寻找第i个结点
    {
         p = p->next;
         ++j;
    }
    if(!(p->next) || j > i)
    {
        return ERROR;    //第i个元素不存在
    }
    
    q = p->next;
    p->next = q->next;
    
    *e = q->data;
    freee(q);
    return OK;
}    

单链表的整表创建

单链表不像顺序存储结构一样集中，是一种动态结构，占用的空间不用预先分配，可以根据系统的情况和实际需求即时生成。

所以创建单链表是一个动态生成链表的过程。即从空表的初始状态，依次建立个元素结点，并逐个插入链表。

单链表创建的算法思路：

1.      声明一结点p和计数器变量i;

2.      初始化一空链表L;

3.      让L的头结点的指针指向NULL，即建立一个带头结点的单链表

4.      循环：生成一个新节点赋值给p;

      给p的数据域赋值

      将p插入到头结点与前一新节点之间 

//随机产生n个元素的值，建立带表头结点的单链线性表L(头插法)
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 < n ; i++)
    {
       p = （LinkList）malloc(sizeof(Node));  //生成新结点
       p->data = rand() % 100 + 1;    //随机生成100以内的数字
       p->next = (*L)->next;
       (*L)->next = p;    //插入到表头
    }
}

单链表结构与顺序存储结构的优缺点

1.      存储分配方式：顺序存储结构用一段连续的存储单元依次存储线性表的数据元素

              链式存储，用一组任意的存储单元存储线性表的元素

2.      时间性能：查找顺序存储结构O(1)

               单链表O(n)

          插入和删除 顺序存储结构需要平均移动表长一般的元素O(n)

                     单链表在找出位置后 O(1)

3.      空间性能顺序存储结构预分配存储空间，可能浪费或不够

         单链表不需要分配