线性表的链式存储结构

线性表的链式存储结构

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

    从上面可以看出，线性表的顺序存储结构，最大的缺点就是插入和移除时需要移动大量元素，这显然就需要耗费时间。链式存储结构就是为了弥补顺序存储结构在效率上的问题。

   线性表链式存储结构

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

    线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置。

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

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

    示意图：

    

    对于线性表来说，总得有个头有个尾，链表也不例外，我们把链表中第一个结点的存储位置叫做头指针。最后一个结点指针为“空”（通常用NULL或“^”符号表示)。

    线性链表的最后一个结点指针为“空”（通常用NULL或“^”符号表示），示意图：

    

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

    示意图：

    

    2.  头指针域、头结点的区别

    1）是否为必要元素：头指针是链表的必要元素，无论链表是否为空，头指针均不为空。头结点不一定是链表必须元素。

    2）作用方面：头指针是指向链表第一个结点的指针，若链表有头结点，则是指向头结点的指针。而且其具有标识作用，常用头指针冠以链表的名字。而头结点主要是为了操作的统一和方便而设立的，比如对第一元素结点前插入结点和

删除第一结点，其操作就和其它结点的操作统一了。

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

    若线性表为空表，则头结点的指针域为“空”，示意图：

    

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

   

    单链表操作

    1.  单链表的读取

    在单链表中，由于第 i 个元素到底在哪？没办法一开始就知道，必须得从头开始找。因此，对于单链表实现获取第 i 个元素的数据的操作GetElem，在算法上，相对要麻烦一些。

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

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

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

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

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

    C语言的实现：

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE
typedef int Status;
/*Status是函数的类型,其值是函数结果状态代码，如OK等*/
/*初始条件：顺序线性表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;             /*当前位置计数器设置为1*/
    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;
}

    PHP的实现：

<?php
    /**
     * 读取链表中第i个数据
     * @param $list object 待插入的链表
     * @param $i     int     节点序号
     */

    public function readIThNode($list,$i){
        // 如果链表为空或者i小等于0
        if($list == null || $i<=0){
            echo "输入参数不合法";
            exit;
        }
        // 第1步
        $p = $list->next;    // 设置p指向第一个节点（即头节点的后继节点））
        $j=1;                // 计时器必须初始化
        while($p && $j<$i ){
            $p = $p->next;
            ++$j;
        }

        // 第i步
        if($p == null || $j>$i){    // 说明链表已经结束，不存在i节点,过滤掉i大于链表长度的情况（因为节点是散列的，事先并不知道其长度）
            echo "i长度大于链表长度" ;
            exit;
        }else{
            $e = $p->data;   // 第i个节点存在，返回
            return $e;
        }

    }

    过程分析：

    1）其实就是从头开始找，直到找到第 i 个结点为止。这个算法时间复杂度取决于i的位置。当i=1时，不需要遍历，第一个就取出数据了，而当i=n时，则遍历n-1次才可以。因此最坏情况的时间复杂度是O(n)。

    2）由于单链表的结构没有定义表长，所以不能事先知道要循环多少次，因此也就不方便使用for来控制循环。其核心思想就是“工作指针后移”，这其实也是很多算法的常用技术。

    2.  单链表的插入

    

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

    1）声明一指针 p 指向链表头结点，初始化 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）返回成功

     C语言的实现：

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE
typedef int Status;
/*Status是函数的类型,其值是函数结果状态代码，如OK等*/
/*初始条件：顺序线性表L已存在，1<=i<=ListLength(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-1个结点*/
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return ERROR;                   /*第i个结点不存在*/
    s = (LinkList)malloc(sizeof(Node)); /*生成新结点(C标准函数)*/
    s->data = e;
    s->next = p->next; /*将p的后继结点赋值给s的后继*/
    p->next = s;       /*将s赋值给p的后继*/
    return OK;
}

     PHP的实现：

    /**
     * 在链表的第i个位置之前插入节点e
     * @param $list object 待插入的链表
     * @param $i     int     节点序号
     * @param $e    object 待插入的节点
     */
    public function Insert($list, $i, $e)
    {
        if ($e == null) {
            echo "待插入节点为空";
            exit;
        }
        $p = $this->head;      #设置p指向头节点
        $j = 1;                #计时器必须初始化

        while ($p && $j < $i) {
            $p = $p->next;    #保证节点在向后移动
            ++$j;
        }

        //第i步
        if ($p == null || $j > $i) {    #说明链表已经结束，不存在i节点,过滤掉i大于链表长度的情况（因为节点是散列的，事先并不知道其长度）
            echo "不存在i节点";
            exit;
        } else {
            /*    标准的插入语句（头插法）    */
            $e->next = $p->next;
            $p->next = $e;
            return $list;
        }
    }

    疑问：

    不知道大家有没有发现，在单链表读取的时候，声明的指针 p 指向链表第一个结点，而在单链表插入的时候，声明的指针p指向链表的头结点？

    分析：

    1）单链表读取的时候，是从头开始找，如果找到直接取出数据（p->data）返回，显然这个跟头结点没什么关系，直接从第一结点开始即可

    2）单链表插入的时候，查找到结点的情况下，是需要将 p 的后继结点 改成 s 的后继结点，再把结点 s 变成 p 的后继结点。声明 p 指针指向链表头结点，p的后继结点就是第一结点，就相当于从第一结点前插入，这显然符合当前要求。

如果声明的指针 p 指向第一结点，那通过这个插入语句后，就相当于插入了第二结点前，显然不符合要求。  

    3.  单链表的删除

    

    删除结点的算法思路：

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

    C语言的实现：  

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE
typedef int Status;
/*Status是函数的类型,其值是函数结果状态代码，如OK等*/
/*初始条件：顺序线性表L已存在，1<=i<=ListLength(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->next && j < 1) /*遍历寻找第i-1个结点*/
    {
        p = p->next;
        ++j;
    }

    if (!(p->next) && j < i)
        return ERROR; /*第i个结点不存在*/
    q = p->next;
    p->next = q->next; /*将q的后继赋值给p的后继*/
    *e = q->data;      /*将q结点中的数据给e*/
    free(q);           /*让系统回收此结点，释放内存*/
    return OK;
}

    PHP的实现：

<?php

    /**
     * 删除链表的第i个节点，并返回该节点的值
     * @param $list object 待插入的链表
     * @param $i    int    节点序号
     */
    public function Delete($list, $i)
    {
        if ($list == null || $i <= 0) {
            echo "输入参数不合法";
            exit;
        }
        $p = $this->head;      #设置p指向头结点
        $j = 1;                #计时器必须初始化

        while ($p && $j < $i) {
            $p = $p->next;    #保证节点在向后移动
            ++$j;
        }

        //第i步
        if ($p == null  || $j > $i) {    #说明链表已经结束，不存在i节点,过滤掉i大于链表长度的情况，以为若i大于链表长度，则上面循环会跳出直接进入判断然后返回
            echo "不存在i节点";
            exit;
        } else {
            /*    标准的删除语句    */
            $q = $p->next;
            $p->next = $q->next;
            $e = $q->data;
            unset($q);
            return $e;
        }
    }

    从上面的代码实现来看，我们发现，单链表插入和删除算法，其实都是由两部分组成：第一部分就是遍历查找第 i 个结点，第二部分就是插入和删除结点

    总结：从整个算法来说，我们很容易推导出：它们的时间复杂度都是O(n)。如果在我们不知道第 i 个结点的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构是没有太大优势的。但如果，我们希望从第 i 个位置，插入10个结点，对于顺序存储结构意味着，每一次插入都需要移动 n-i 个结点。每次都是 O(n)。而单链表，我们只需要在第一次时，找到第 i 个位置的指针，此时为O(n),接下来只是简单得通过赋值移动指针而已，时间复杂度都是O(1)。对于插入和删除数据越频繁的操作，单链表的效率优势就越是明显。

    下面附上：PHP中对单链表的实现

<?php
// 节点类
class Node {
    public $data;   // 节点数据
    public $next;   // 下一节点

    public function __construct($data) {
        $this->data = $data;
        $this->next = NULL;
    }
}
// 单链表类
class SingleLinkedList {
    private $header;    // 头节点

    function __construct($data) {
        $this->header = new Node($data);
    }
    // 查找节点
    public function find($item) {
        $current = $this->header;
        while ($current->data != $item) {
            $current = $current->next;
        }
        return $current;
    }
    // （在节点后）插入新节点
    public function insert($item, $new) {
        $newNode = new Node($new);
        $current = $this->find($item);
        $newNode->next = $current->next;
        $current->next = $newNode;
        return true;
    }

    // 更新节点
    public function update($old, $new) {
        $current = $this->header;
        if ($current->next == null) {
            echo "链表为空！";
            return;
        }
        while ($current->next != null) {
            if ($current->data == $old) {
                break;
            }
            $current = $current->next;
        }
        return $current->data = $new;
    }

    // 查找待删除节点的前一个节点
    public function findPrevious($item) {
        $current = $this->header;
        while ($current->next != null && $current->next->data != $item) {
            $current = $current->next;
        }
        return $current;
    }

    // 从链表中删除一个节点
    public function delete($item) {
        $previous = $this->findPrevious($item);
        if ($previous->next != null) {
            $previous->next = $previous->next->next;
        }
    }

    // findPrevious和delete的整合
    public function remove($item) {
        $current = $this->header;
        while ($current->next != null && $current->next->data != $item) {
            $current = $current->next;
        }
        if ($current->next != null) {
            $current->next = $current->next->next;
        }
    }

    // 清空链表
    public function clear() {
        $this->header = null;
    }

    // 显示链表中的元素
    public function display() {
        $current = $this->header;
        if ($current->next == null) {
            echo "链表为空！";
            return;
        }
        while ($current->next != null) {
            echo $current->next->data . "&nbsp;&nbsp;&nbsp;";
            $current = $current->next;
        }
    }
}

参考资料： 程杰《大话数据结构》