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

最新推荐文章于 2021-01-27 21:17:13 发布

程小智

最新推荐文章于 2021-01-27 21:17:13 发布

阅读量771

点赞数

分类专栏：基础知识复习笔记

本文链接：https://blog.csdn.net/sinat_22055459/article/details/50960207

版权

基础知识复习同时被 2 个专栏收录

36 篇文章 0 订阅

订阅专栏

笔记

18 篇文章 0 订阅

订阅专栏

线性表的顺序存储结构的最大缺点是插入和删除需要移动大量元素。

1.线性表链式存储结构定义

为了表示每个数据元素a_i与直接后继数据元素a_i+1直接按的逻辑关系。对数据元素a_i来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域为指针域。指针域中存储的信息称为指针或链。这两部分信息组成数据元素a_i的存储映像，称为结点（Node）。

n个结点（a_i的存储映像）链接成一个链表，即为线性表（a_1,…,a_i-1, a_i, a_i+1, …, a_n）的链式存储结构，因为此链表的每个结点中包含一个指针域，称为单链表。

对于线性表来说，总得有个头有个尾，链表也不例外，我们把链表中的第一个结点的存储位置叫做头指针。整个链表的存取就比于是从头指针开始进行，之后的每一个结点，其实就是上一个的后继指针指向的位置。最后一个结点的指针为空。通常用Null或“^”符号表示。

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

注意：头结点与头指针的异同点

头指针：

1.头指针是指指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。

2.头指针具有标识作用，所以常用头指针冠以链表的名字.

3.无论链表是否为空，头指针均不为空。头指针是链表的必要元素。

头结点：

1.头结点是为了操作的统一和方便而成立的，放在第一元素的结点之前，其数据域一般无意义（也可存放链表的长度）

2.有了头结点，对在第一元素结点前插入和删除第一结点，其操作和其他节点的操作就统一了。

3.头结点不一定是链表的必需元素。

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

若线性表为空表，则头结点的指针域为“空”。

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

/*线性表的单链表存储结构*/

typedef struct Node

{

ElemType data;

struct Node *Next;

} Node;

typedef struct Node *LinkList;/*定义：LinkList*/

从上面这个结构定义中，我们也就知道：结点由存放数据元素的数据域和存放后继结点地址的指针域。

3.单链表的读取：

获得链表第i个数据的算法思路:

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

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

3.若到链表末尾p为空，则说明第i个结点不存在。

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

实现代码算法如下：

    /*Status 是函数的类型，其值是函数结果的状态代码， 如OK 等*/
  
    /*操作结果用e返回L中的第i个数据元素的值*/
Status  GetElem（SqlList 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;
        }
        if (!p || j > i)     
            return ERROR;                        /*第i个节点不存在*/
        *e = p->data;                             /*取第i个结点的数据*/
        return OK;
        }
｝

时间复杂度O(n)

4.单链表的插入

单链表第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. 返回成功。

实现代码如下：

 /*初始条件：顺序线性表已经存在，1=<i<= ListLength(L)*/
      /*操作结果在L的第i个位置插入新元素e,L的长度加1*/
       Status  ListInsert(SqlList* L, int i, Elemtype e)
        {
                int j ;
                LinkList p,s;
                p = *L;
                j = 1;
                while(p && j < i)          /*寻找第i-1个节点*/
                {
                        p = p->next;
                        ++j;
                } 
                if (!p ||  j > i)                 /*第i-1个结点不存在*/
                        return ERROR;
               s = (LinkList)malloc(sizeof(Node));    /*生成新结点*/
               s->data = e;
               s->next = p->next;                            /*将p的后继结点赋值给s的后继*/
               p->next = s;             /*将s赋值给p的后继*/
               return OK; 
        }

5. 单链表的删除

单链表第i个数据删除结点的算法思路：

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

实现代码：

<strong>  </strong>/*操作结果在L的第i个位置插入新元素e,L的长度加1*/
       Status  ListDelete(SqlList* L, int i, Elemtype *e)
        {
                int j ;
                LinkList p, q;
                p = *L;
                j = 1;
                while(p->next && j < i)         /*寻找第i-1个节点*/
                {
                        p = p->next;
                        ++j;
                } 

                if (!p -> next ||  j > i)                 /*第i-1个结点不存在*/
                        return ERROR;
                q= p->next;
                p->next = q->next;                            /*将q的后继结点赋值给p的后继*/
                *e = q->data ;    /*q结点中的数据给e*/
                free(q);
                return OK; 
        }
      /*初始条件：顺序线性表已经存在，1=<i<= ListLength(L)*/

6.单链表的整表创建

算法思路：

1. 声明一指针p和计数器变量i；

2. 初始化一空链表L；

3. 设L的头结点的指针指向Null，建立一个带头结点的单链表；

4. 循环

生成一新结点赋值给p；
随机生成一数字赋值给P的数据域p->data；
将p插入到头结点与前一新结点之间。

实现代码：

 /*随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）*/
void CreateListHead（LinkList *L,int n）
{
    LinkList p;
    int j;
    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;                 /*插入到表头*/
    }
}

注意：这个算法用的是插队的办法，始终让最新的结点在第一个位置---- 头插法

还有一种就是尾插法，不断把新结点都放到最后。实现代码如下：

/*随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法）*/
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;  /*随机生成100以内的数字*/
        r->next= p;       /*将表尾终端结点的指针指向新结点*/
        r = p;                 /*将当前的新结点定义为表尾终端结点*/
    }
    r->next = NULL; /*表示当前链表结束*/
}

以便以后的遍历时可以确认其是尾部。

7.单链表的整表删除

单链表的整表删除算法思路：

1.声明一个结点p和q；

2.将第一个结点赋值给p；

3.循环：

将下一个结点给q；
释放q；
将q赋值给p。

实现代码如下：

/*初始条件：顺序线性表L已经存在，操作结果，将L充值为空表*/
void ClearList（LinkList *L）
{
    LinkList p， q;
     p = (*L)->next;    /*p指向第一个结点*/
    while (p)     /*没有表尾*/
    {
  
        q = p->next;       
        free(p) ;                
        p = q;
    }
    (*L)->next = NULL;      /*头结点指针域为空*/
    retuen OK;
}

注意：本算法常见错误，有人认为q变量没有必要存在，早循环体内直接书写free（p）； p = p -> next;即可。p是一个结点既有数据域又有指针域，在执行 free（p）；时，是对它整个结点进行删除和内存释放的工作。而q的存在使得下一个结点是谁得到了记录，以便于当前结点释放后，把下一结点拿回来补充。