第九课，静态链表

最新推荐文章于 2022-05-03 20:27:49 发布
最新推荐文章于 2022-05-03 20:27:49 发布
阅读量499 收藏
点赞数
分类专栏： 数据结构 文章标签： 静态链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuyadeCS/article/details/73556185
版权

专题三：渐入佳境。包括以下章节：

  1. 无招胜有招-静态链表
  2. 气宗门道-循环链表
  3. 剑宗门道-双向链表
  4. 课后练习

思考

单链表完美解决了顺序表的问题！还有其它改进顺序表的方法吗？

单链表的相对劣势

单链表的实现严重依赖指针！
数据元素中必须包含一个额外的指针域！
没有指针的程序设计语言无法实现！

顺序表的改进

静态链表的定义

  • 顺序表数组中的元素由两个数据域组成：data和next
  • data域用于存储数据
  • next域用于存储下一个元素在数组中的下标

这里写图片描述

静态链表的逻辑结构

静态链表是在顺序表的基础上利用数组实现的单链表！

这里写图片描述

静态链表相关定义

结点结构体定义

typedef struct _tag_StaticListNode
{
    unsigned int data;
    int next;
}TStaticListNode;

静态链表结构体定义

typedef struct _tag_StaticList
{
    int capacity;
    TStaticListNode header;
    TStaticListNode node[];
}TStaticList;

静态链表操作

1.获取第pos个元素操作

  • 判断线性表是否合法
  • 判断位置是否合法
  • 由表头开始通过next域移动pos次后，当前元素的next域即要获取元素在数组中的下标
sList->node[0] = sList->header;

for(i=0;i<pos;i++)
{
    current = sList->node[current].next;
}
object = sList->node[current].next;

2.插入元素到位置pos操作

  • 判断线性表是否合法
  • 判断插入位置是否合法
  • 在数组中查找空闲位置index
  • 由表头开始通过next域移动pos次后，当前元素的next域为要插入的位置
  • 将新元素插入
  • 线性表长度加1
for(i=0;(i<pos)&&(sList->node[current].next != 0);i++)
{
    current = sList->node[current].next;
}
sList->node[index].next = sList->node[current].next;
sList->node[current].next = index

这里写图片描述

3.删除第pos个元素操作

  • 判断线性表是否合法
  • 判断删除位置是否合法
  • 获取第pos个元素
  • 将第pos个元素从链表中删除
  • 线性表长度减1

这里写图片描述

小结

  1. 静态链表其实是单链表的另一种实现方式
  2. 静态链表的实现“媒介”不是指针而是数组
  3. 静态链表主要用于不支持指针的程序设计语言中
  4. 静态链表的实现是一种内存管理的简易方法

创建可复用静态链表

StaticList.h

#ifndef _STATICLIST_H_
#define _STATICLIST_H_

typedef void StaticList;
typedef void StaticListNode;

StaticList* StaticList_Create(int capacity);

void StaticList_Destroy(StaticList* list);

void StaticList_Clear(StaticList* list);

int StaticList_Length(StaticList* list);

int StaticList_Capacity(StaticList* list);

int StaticList_Insert(StaticList* list, StaticListNode* node, int pos);

StaticListNode* StaticList_Get(StaticList* list, int pos);

StaticListNode* StaticList_Delete(StaticList* list, int pos);

#endif

StaticList.c

#include <stdio.h>
#include <malloc.h>
#include "StaticList.h"

#define AVAILABLE -1

typedef struct _tag_StaticListNode
{
    unsigned int data;
    int next;
} TStaticListNode;

typedef struct _tag_StaticList
{
    int capacity;
    TStaticListNode header;
    TStaticListNode node[];
} TStaticList;

StaticList* StaticList_Create(int capacity) // O(n)
{
    TStaticList* ret = NULL;
    int i = 0;

    if( capacity >= 0 )
    {
        ret = (TStaticList*)malloc(sizeof(TStaticList) + sizeof(TStaticListNode) * (capacity + 1));
    }

    if( ret != NULL )
    {
        ret->capacity = capacity;
        ret->header.data = 0;
        ret->header.next = 0;

        for(i=1; i<=capacity; i++)
        {
            ret->node[i].next = AVAILABLE;
        }
    }

    return ret;
}

void StaticList_Destroy(StaticList* list) // O(1)
{
    free(list);
}

void StaticList_Clear(StaticList* list) // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    int i = 0;

    if( sList != NULL )
    {
        sList->header.data = 0;
        sList->header.next = 0;

        for(i=1; i<=sList->capacity; i++)
        {
            sList->node[i].next = AVAILABLE;
        }
    }
}

int StaticList_Length(StaticList* list) // O(1)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = -1;

    if( sList != NULL )
    {
        ret = sList->header.data;
    }

    return ret;
}

int StaticList_Capacity(StaticList* list) // O(1)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = -1;

    if( sList != NULL )
    {
        ret = sList->capacity;
    }

    return ret;
}

int StaticList_Insert(StaticList* list, StaticListNode* node, int pos)  // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = (sList != NULL);
    int current = 0;
    int index = 0;
    int i = 0;

    ret = ret && (sList->header.data + 1 <= sList->capacity);
    ret = ret && (pos >=0) && (node != NULL);

    if( ret )
    {
        for(i=1; i<=sList->capacity; i++)
        {
            if( sList->node[i].next == AVAILABLE )
            {
                index = i;
                break;
            }
        }

        sList->node[index].data = (unsigned int)node;

        sList->node[0] = sList->header;

        for(i=0; (i<pos) && (sList->node[current].next != 0); i++)
        {
            current = sList->node[current].next;
        }

        sList->node[index].next = sList->node[current].next;
        sList->node[current].next = index;

        sList->node[0].data++;

        sList->header = sList->node[0];
    }

    return ret;
}

StaticListNode* StaticList_Get(StaticList* list, int pos)  // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    StaticListNode* ret = NULL;
    int current = 0;
    int object = 0;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->header.data) )
    {
        sList->node[0] = sList->header;

        for(i=0; i<pos; i++)
        {
            current = sList->node[current].next;
        }

        object = sList->node[current].next;

        ret = (StaticListNode*)(sList->node[object].data);
    }

    return ret;
}

StaticListNode* StaticList_Delete(StaticList* list, int pos) // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    StaticListNode* ret = NULL;
    int current = 0;
    int object = 0;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->header.data) )
    {
        sList->node[0] = sList->header;

        for(i=0; i<pos; i++)
        {
            current = sList->node[current].next;
        }

        object = sList->node[current].next;

        sList->node[current].next = sList->node[object].next;

        sList->node[0].data--;

        sList->header = sList->node[0];

        sList->node[object].next = AVAILABLE;

        ret = (StaticListNode*)(sList->node[object].data);
    }

    return ret;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "StaticList.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[])
{
    StaticList* list = StaticList_Create(10);

    int index = 0;

    int i = 0;
    int j = 1;
    int k = 2;
    int x = 3;
    int y = 4;
    int z = 5;

    StaticList_Insert(list, &i, 0);
    StaticList_Insert(list, &j, 0);
    StaticList_Insert(list, &k, 0);

    for(index=0; index<StaticList_Length(list); index++)
    {
        int* p = (int*)StaticList_Get(list, index);

        printf("%d\n", *p);
    }

    printf("\n");

    while( StaticList_Length(list) > 0 )
    {
        int* p = (int*)StaticList_Delete(list, 0);

        printf("%d\n", *p);
    }

    printf("\n");

    StaticList_Insert(list, &x, 0);
    StaticList_Insert(list, &y, 0);
    StaticList_Insert(list, &z, 0);

    printf("Capacity: %d Length: %d\n", StaticList_Capacity(list), StaticList_Length(list));

    for(index=0; index<StaticList_Length(list); index++)
    {
        int* p = (int*)StaticList_Get(list, index);

        printf("%d\n", *p);
    }

    StaticList_Destroy(list);

    return 0;
}
第1-7课：基础开胃菜
oRbIt 的专栏
09-22 1081
本系列前几课分别介绍了算法的常用设计模式、建立数据模型的常用思路和方法。其实，用代码实现的算法肯定还会包含一些代码特有的技巧，这一课就来介绍一些这样的技巧。这些巧妙构思的代码技巧，有些体现了效率，有些体现了程序设计的一致性原则，有些则体现了软件架构的一些好思想；这些技巧，都可以在今后的算法设计中直接或间接使用，即使用不上，了解这些内容对于开阔思维还是很有益处的，更不用说其中一些技巧都是常见或不常见...
2-4课：从最最最最简单的数据结构开始：数组和链表
YeJuliaLi的博客
09-22 276
在实际运用中，不同编程语言对于同一理论性数据结构的实现可能有所不同。在我们后面具体编程的过程中，用到的实践性数据结构和理论性数据结构也有可能不同。 本章里讲的数组和链表，是理论上的数据结构，我们关注的是逻辑层面的数据组织方式和其上操作的运行方式。 数据结构的定义 我们先来看看数组和链表的定义。 数组 在计算机科学中，数组是一种由若干元素组成的集合，每一个元素被至少一个索引（index）或者关键字（...
静态链表
热门推荐
scu_daiwei的专栏
01-16 1万+
今天学习了下静态链表，简单总结如下：   静态链表相当于是用一个数组来实现线性表的链式存储结构，大概结构图如下                                      在静态链表中，每一个结点包含两部分内容，一部分是data（即有意义的数据），另一部分是cur（存储该元素下一个元素所在数组对应的下标）。 有几个特殊的结点： 首先是下标为0的结点中不包含有意义的数据，它
【静态链表】
m0_67691566的博客
05-03 912
静态链表 用数组描述的链表叫做静态链表；让数组的元素由两个数据域组成，data和；数据域data，cur相当于单链表中的next指针，存放该元素的后继在数组中的下标。 定义静态链表： 初始化静态链表： 静态链表的插入： 静态链表的删除： 全部代码： 运行结果： ...
静态链表实现Josephus（约瑟夫环问题）
Justdoforever的博客
08-28 1995
问题描述 假设n个竞赛者排成一个环形。给定一个正整数m&lt;=n,从指定的第一个人开始，沿环计数，每遇到第m个人就让其出列，且计数继续进行下去。这个问题一直进行到所有人都出列为止，最后出列者为优胜者。 例如：（7,3）Josephus排列为3,6,2,7,5,1,4. 下面是代码： #include &lt;cstdio&gt; #include&lt;iostream&gt;...
链表-数据结构与算法的第一课
财经博主
02-16 358
前言 在学习了C++基础以及算法复杂度分析方法（NP完整性笔者也没有理清，待到吃透再更）后，我们开始学习第一种数据结构——链表。在学习链表之前，相信熟练使用C语言的各位已经掌握了数组这一数据结构 。其有两个局限： 编译前就需要知道大小。 数组中的每个元素占据的内存单元数是相同的。 链表就不存在这些问题，所以它可以分散存储于内存的任何位置，对于双向链表，每一个节点都存有两个地址，分别存放上一个节点...
青岛大学--复试--专业课问题
04-09
### 青岛大学复试——专业课问题解析 #### 一、主键与外键 在关系型数据库中，为了确保数据的完整性和一致性，通常会使用主键和外键来约束数据。**主键**是指在一个表中能够唯一标识每一行记录的一个或一组字段。...
C语言实现静态链表及内存管理
本文主要介绍了如何使用C语言实现静态链表，强调了静态链表与动态链表在内存管理上的区别，并提供了一种基于全局数组的静态链表实现方法。 在计算机科学中，链表是一种数据结构，它通过节点间的指针连接元素，而非...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值