简单数据结构的妙用（一）：静态链表

最新推荐文章于 2022-08-10 20:51:55 发布

zjzytnn

最新推荐文章于 2022-08-10 20:51:55 发布

阅读量505

点赞数

分类专栏：数据结构文章标签：数据结构链表指针

本文链接：https://blog.csdn.net/zjzytnn/article/details/112394560

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

// 将一维数组space中各分量链成一备用链表，space[0].cur是头指针
Bool InitList(StaticLinkList space) {
    for(int i = 0; i < MAXSIZE - 1; i++) {
        space[i].cur = i + 1;
    }
    space[MAXSIZE - 1].cur = 0;  // 目前静态链表为空，最后一个元素的cur为0 
    return true;
}

假设将数据存入静态链表，比如分别存放着"甲”、“乙”、“丁”、“戊”、“己”、“庚"等数据，如图所示：

此时，”甲“存有下一元素”乙“的游标2，”乙“存有下一元素”丁“的下标3，”庚“是最后一个有值的元素，所以它的cur是0。最后一个元素的cur因为”甲“是第一个有值的元素而存它的下标1。第一个元素因空闲空间的第一个元素下标为7，所以它的cur存7。

四、插入操作

静态链表中要解决的是：如何用静态模拟动态链表结构的存储空间的分配，需要时申请，无用时释放。

在动态链表中，结点的申请和释放分别借用malloc()和free()两个函数来实现。在静态链表中，操作的是数组，不存在像动态链表的结点申请和释放问题，所以需要自己实现这两个函数。

为辨明数组中哪些分量未被使用，解决的办法是将所有未被使用过的及已被删除的分量用游标链成一个备用的链表，每当进行插入时，便可以从备用链表上取得第一个结点作为待插入的新结点。

节点申请的代码如下：

// 若备用链表非空，则返回分配的结点下标，否则返回0
int Malloc_SLL(StaticLinkList space) {
    int i = space[0].cur;  // 当前数组第一个元素cur的值，就是要返回的备用链表的第一个元素下标
    if (space[0].cur) {
        space[0].cur = space[i].cur;  // 由于拿出一个分量来使用了，就得把它的下一个分量用来做备用
    }
    return i;
}

现在如果需要在”乙”和“丁“之间插入一个值为”丙“的元素，按照以前顺序存储结构的做法，应该要把“丁”、“戊”、“己”、“庚"这些元素都往后移一位，但目前不用，因为有了新的手段。

新元素”丙“想插队是吧？可以，让它先排在队伍最后第7个游标的位置，然后，将“乙”原先的cur是游标为3的“丁”，现在改成7，再将“丙”的cur设置为3即可。这样，在绝大多数元素都没有变动的情况下，整个链表的次序发生了改变，如图所示：

插入的代码如下：

// 在L中第i个元素之前插入新的元素e
Bool ListInsert(StaticLinkList L, int i, ElemType e) {
    if (i < 1 || i > ListLength(L) + 1) {
        return false;        
    }
    int j, k, l;
    k = MAX_SIZE - 1;   // 注意k首先是最后一个元素的下标
    j = Malloc_SLL(L);  // 获得空闲分量的下标
    if (!j) {
        return false;
    }
    L[j].data = e;      // 将数据赋值给此分量的data
    for (l = 1; l < i; l++) {  // 找到第i个元素之前的位置
        k = L[k].cur;
    }
    L[j].cur = L[k].cur;  // 把第i个元素之前的cur赋值给新元素的cur
    L[k].cur = j;         // 把新元素的下标赋值给第i个元素之前元素的cur
    return true;
}

这样，就实现了在数组中，不移动元素，却插入了数据的操作。

五、删除操作

和前面一样，删除元素时，是需要释放结点的函数free()。现在也需自己实现：

// 删除在L中第i个数据元素e
Bool ListDelete(StaticLinkList L, int i) {
    if (i < 1 || i > ListLength(L)) {
        return false;
    }
    int j, k;
    k = MAX_SIZE - 1;
    for (j = 1; j < i; j++) {
        k = L[k].cur;
    }
    j = L[k].cur;
    L[k].cur = L[j].cur;
    Free_SSL(L, j);
    return true;
}

// 将下标为k的空闲结点回收到备用链表
void Free_SLL(StaticLinkList L, int i) {
    L[i].cur = space[0].cur;  // 把第一个元素cur值赋给要删除的分量cur
    L[0].cur = i;             // 把要删除的分量下标赋值给第一个元素的cur
}

六、链表长度

静态链表的ListLength实现：

// 初始条件：静态链表L已存在。操作结果：返回L中数据元素个数
int ListLength(StaticLinkList L) {
    int j = 0, i = L[MAX_SIZE - 1].cur;
    while (i) {
        i = L[i].cur;
        j++;
    }
    return j;
}

七、优缺点

优点：在插入和删除操作时，只需要修改游标，不需要移动元素，从而改进了在顺序存储结构中的插入和删除操作需要移动大量元素的缺点。
缺点：
- 没有解决连续存储分配带来的表长难以确定的问题（必须事先知道元素个数来分配内存，单链表则无需如此）；
- 失去了顺序存储结构随机存取的特性（原先通过下标可直接存取）；