静态链表的C++语言描述实现模板

已于 2023-02-12 13:12:14 修改
阅读量164 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法 链表 c++ c语言
于 2022-04-27 19:37:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62083249/article/details/124457732
版权

文章目录

前言

数据结构中静态链表的C++语言描述实现模板，有详细的步骤解析及使用示例。

代码仓库

sLinkList.cpp

//头文件————————————————————
#include <iostream>
using namespace std;

//宏————————————————————
#define MAX_SIZE 100 //最大大小
//为防止插入数据时溢出，通常数组建立得大一些

//自定义数据类型————————————————————
typedef int ELEM_TYPE; //数据的（数据）类型 依据数据的实际类型定义

//结构体
//定义
//静态链表/数组
typedef struct
{
    ELEM_TYPE data;    //数据
    int cur;           //游标 存储直接后继位置的数组下标
} SLinkList[MAX_SIZE]; //结构体数组
//数组中存在未被使用和已使用的位置/结点
//约定：
//数组的第一个和最后一个位置不存数据
//数组的第一个位置（数组下标为0）的游标存储未被使用位置中第一个位置的数组下标
//当数组位置的游标无直接后继位置时，存储数组下标0
//数组的最后一个位置（数组下标为MAX_SIZE-1）存储已被使用位置中第一个位置的数组下标  类比单链表的头结点
//数组为空时，数组的最后一个位置（数组下标为MAX_SIZE-1）存储数组下标0

//函数声明————————————————————
void use_example();                                               //使用示例
void init_list(SLinkList &sLinkList);                             //初始化
int get_length(SLinkList sLinkList);                              //获取表长
int allot(SLinkList &sLinkList);                                  //分配
bool insert_list(SLinkList &sLinkList, int posi, ELEM_TYPE elem); //插入
void release(SLinkList &sLinkList, int del_cur);                  //释放
bool delete_list(SLinkList &sLinkList, int posi);                 //删除
void traverse(SLinkList sLinkList);                               //遍历

//主函数————————————————————
int main()
{
    use_example(); //使用示例

    return 0;
}

//函数定义————————————————————
//使用示例
void use_example()
{
    //创建
    SLinkList sLinkList;

    //初始化
    init_list(sLinkList);

    //插入  默认成功，未接收返回值
    insert_list(sLinkList, 1, 300);
    insert_list(sLinkList, 1, 200);
    insert_list(sLinkList, 1, 100);
    //元素在数组中排列：300，200，100
    //元素在链表中排列：100，200，300

    for (int i = 1; i < 4; i++)
    {
        cout << sLinkList[i].data << endl; //输出：300，200，100
    }

    int move_cur; //移动游标

    move_cur = MAX_SIZE - 1;

    while (1) //遍历
    {
        move_cur = sLinkList[move_cur].cur; //移动移动游标

        cout << sLinkList[move_cur].data << endl; //输出：100，200，300

        if (sLinkList[move_cur].cur == 0) //移动游标到数组的最后一个位置，输出数据后退出
        {
            break;
        }
    }

    //获取表长
    int length; //表长

    length = get_length(sLinkList); //获取表长

    cout << length << endl; //输出：3

    //删除  默认成功，未接收返回值
    delete_list(sLinkList, 2); //删除

    //注意：
    //删除只是修改元素删除位置的前一个位置的游标存储的数组下标，并将元素删除位置置为未被使用位置
    //是在逻辑上删除，但在物理上元素删除位置仍存储原数据
    //元素在数组中排列：300，200，100
    //元素在链表中排列：100，300

    for (int i = 1; i < 4; i++)
    {
        cout << sLinkList[i].data << endl; //输出：300，200，100
    }

    //遍历
    traverse(sLinkList); //遍历 输出：100，300

    return;
}

//函数定义————————————————————
//初始化
void init_list(SLinkList &sLinkList) //参数：数组（还未形成静态链表）
{
    for (int i = 0; i < MAX_SIZE; i++) //遍历各数组位置
    {
        sLinkList[i].cur = i + 1; //游标存储数组下一位置的数组下标
    }
    //由代码逻辑，初始化后若直接使用插入操作，一般按照数组下标1-MAX_SIZE-1的位置依次插入元素

    sLinkList[MAX_SIZE - 1].cur = 0;
    //遍历后数组最后一个位置的游标存储：sLinkList[MAX_SIZE-1].cur = MAX_SIZE
    //约定：数组为空时，数组的最后一个位置（数组下标为MAX_SIZE-1）存储数组下标0
    //修改数组最后一个位置的游标存储

    return;
}

//获取表长
int get_length(SLinkList sLinkList) //参数：数组    返回值：表长
{
    int length = 0; //表长
    int move_cur;   //移动游标   当前数组位置的数组下标

    move_cur = sLinkList[MAX_SIZE - 1].cur; //初始化移动游标    存储数组已被使用位置中第一个位置的数组下标
    //约定：数组的最后一个位置（数组下标为MAX_SIZE-1）存储已被使用位置中第一个位置的数组下标  类比单链表的头结点

    while (move_cur != 0) //遍历
    {
        move_cur = sLinkList[move_cur].cur; //更新移动游标   存储数组已被使用位置中下一个位置的数组下标

        length++; //表长+1
    }

    return length; //返回表长
}

//静态链表需要模拟动态链表的存储空间分配，需要时申请
//思路：将数组中未被使用的位置链成链表，需要时取第一个位置，记录游标存储下一个未被使用的位置
//分配
int allot(SLinkList &sLinkList) //参数：数组    返回值：数组未被使用位置中第一个位置的数组下标
{
    int posi; //数组未被使用位置中第一个位置的数组下标

    posi = sLinkList[0].cur; //获取数组未被使用位置中第一个位置的数组下标

    //约定：数组的第一个位置（数组下标为0）的游标存储未被使用位置中第一个位置的数组下标
    //约定：当数组位置的游标无直接后继位置时，存储数组下标0
    //从数组的第一个位置（数组下标为0）的游标获取未被使用位置中第一个位置的数组下标
    //若存在数组未被使用位置中第一个位置，值>0，不存在，值==0

    //数组未被使用位置中第一个位置的游标存储数组未被使用位置中第二个位置或者0（已不存在数组未被使用位置）
    //修改数组的第一个位置（数组下标为0）的游标存储下一个数组未被使用位置的数组下标
    if (sLinkList[0].cur != 0)
    {
        sLinkList[0].cur = sLinkList[posi].cur;
    }

    return posi; //返回数组未被使用位置中第一个位置的数组下标
}

//插入
//参数：数组，元素插入的位置，元素 返回值：操作失败返回false，成功返回true
bool insert_list(SLinkList &sLinkList, int posi, ELEM_TYPE elem)
{
    int length; //表长

    length = get_length(sLinkList); //获取表长

    if (posi < 1 || posi > length + 1) //元素插入的位置不合法
    {
        return false;
    }
    //元素的合法插入位置为数组已被使用位置的第一个位置到最后一个位置的后一个位置

    int unused_cur; //数组未被使用位置中第一个位置的数组下标

    unused_cur = allot(sLinkList); //获取数组未被使用位置中第一个位置的数组下标

    //约定：数组的第一个位置（数组下标为0）的游标存储未被使用位置中第一个位置的数组下标
    //约定：当数组位置的游标无直接后继位置时，存储数组下标0
    // allot()从数组的第一个位置（数组下标为0）的游标获取未被使用位置中第一个位置的数组下标
    //若存在数组未被使用位置中第一个位置，值>0，不存在，值==0
    if (unused_cur != 0)
    {
        sLinkList[unused_cur].data = elem; //赋值数据域

        //插入需要修改数组位置的游标域  类比链表的插入
        int move_cur; //移动游标    当前数组位置的数组下标

        //需要查找当前元素插入位置的前一个位置和后一个位置
        //约定：数组的最后一个位置（数组下标为MAX_SIZE-1）存储已被使用位置中第一个位置的数组下标  类比单链表的头结点
        //从数组的最后一个位置（数组下标为MAX_SIZE-1）按照游标存储的数组下标依次遍历1-posi-1个位置
        move_cur = MAX_SIZE - 1;

        for (int i = 1; i <= posi - 1; i++) //遍历  查找当前元素插入位置的前一个位置
        {
            move_cur = sLinkList[move_cur].cur; //移动移动游标
        }
        //遍历后，move_cur是元素插入位置的前一个位置的数组下标

        sLinkList[unused_cur].cur = sLinkList[move_cur].cur;
        // 1.链接当前元素插入位置的后一个位置
        //当前元素插入位置的游标存储的是当前元素插入位置的前一个位置的游标存储的数组下标
        //类比s->next=p->next;

        sLinkList[move_cur].cur = unused_cur;
        // 2.链接当前元素插入位置的前一个位置
        //当前元素插入位置的前一个位置的游标存储的是当前元素插入位置的的数组下标
        //类比p->next=s;

        return true;
    }

    return false;
}

//释放
void release(SLinkList &sLinkList, int del_cur) //参数：数组，元素删除的位置
{
    //约定：数组的第一个位置（数组下标为0）的游标存储未被使用位置中第一个位置的数组下标
    //思路：头插法
    sLinkList[del_cur].cur = sLinkList[0].cur; //元素删除位置的游标记录数组未使用位置中第一个位置的数组下标

    sLinkList[0].cur = del_cur; //数组的第一个位置（数组下标为0）的游标记录元素删除位置的数组下标

    return;
}

//删除
//注意：
//删除只是修改元素删除位置的前一个位置的游标存储的数组下标，并将元素删除位置置为未被使用位置
//是在逻辑上删除，但在物理上元素删除位置仍存储原数据
//参数：数组，元素删除的位置    返回值：操作失败返回false，成功返回true
bool delete_list(SLinkList &sLinkList, int posi)
{
    int length; //表长

    length = get_length(sLinkList); //获取表长

    if (posi < 1 || posi > length) //元素删除的位置不合法
    {
        return false;
    }
    //元素的合法删除位置为数组已被使用位置的第一个位置到最后一个位置

    //删除需要修改数组位置的游标域  类比链表的删除
    int move_cur; //移动游标    当前数组位置的数组下标

    //需要查找元素删除位置的前一个位置和后一个位置
    //约定：数组的最后一个位置（数组下标为MAX_SIZE-1）存储已被使用位置中第一个位置的数组下标  类比单链表的头结点
    //从数组的最后一个位置（数组下标为MAX_SIZE-1）按照游标存储的数组下标依次遍历1-posi-1个位置
    move_cur = MAX_SIZE - 1;

    for (int i = 1; i <= posi - 1; i++) //遍历  查找元素删除位置的前一个位置
    {
        move_cur = sLinkList[move_cur].cur; //移动移动游标
    }
    //遍历后，move_cur是元素删除位置的前一个位置的数组下标

    int del_cur; //元素删除位置的数组下标

    del_cur = sLinkList[move_cur].cur;
    //使用元素删除位置的前一个位置的数组下标定位元素删除位置的前一个位置
    //使用元素删除位置的游标定位元素删除位置的数组下标

    sLinkList[move_cur].cur = sLinkList[del_cur].cur;
    //链接当前元素删除位置的前一个位置和后一个位置
    //使用元素删除位置的前一个位置的数组下标定位元素删除位置的前一个位置
    //使用元素删除位置的的数组下标定位元素删除位置
    //使用元素删除位置的的游标定位元素删除位置的后一个位置
    //使用元素删除位置的前一个位置的游标记录元素删除位置的后一个位置
    //类比：p->next=p->next->next;

    release(sLinkList, del_cur); //释放空间

    return true;
}

//遍历
void traverse(SLinkList sLinkList) //参数：数组
{
    int move_cur; //移动游标

    move_cur = MAX_SIZE - 1;

    while (1) //遍历
    {
        move_cur = sLinkList[move_cur].cur; //移动移动游标

        cout << sLinkList[move_cur].data << endl; //输出：100，200，300

        if (sLinkList[move_cur].cur == 0) //移动游标到数组的最后一个位置，输出数据后退出
        {
            break;
        }
    }

    return;
}

总结

  • 静态链表是为给没有指针的高级语言设计的一种实现单链表的方法
  • 静态链表的操作在链表的基础上多了一层抽象、不易理解。作者也极难选择用词，以能够将其含义通俗易懂的表述出来，还望理解
  • 许多参考资料中往往只有对静态链表定义的代码示例，少有对操作的代码示例。静态链表少有使用，但其设计思想是巧妙的。我们需理解学习，扩展思维的同时也以备不时之需
  • 作者使用规范的变量命名、提供详细的步骤解析及使用示例，应用C++语言将其整合成模板，以帮助理解记忆。

作者的话

  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获

参考资料

《大话数据结构》作者：程杰

夜悊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构C++语言描述 刘卫东
11-30
《数据结构C++语言描述》这本书，由刘卫东、Willian Ford和Willian Topp共同撰写，深入浅出地介绍了如何使用C++来实现和操作各种数据结构。 该书首先会引导读者理解数据结构的基本概念，如数组、链表、栈和队列。...
【008】数据结构：线性表之链式存储结构——C++单向链表的代码实现（使用模板类）
mengyu_0317的博客
10-21 322
线性表： 最基本和最常用的一种数据结构，由零个或多个数据元素组成的有限序列，表示线性结构。分为顺序存储结构和链式存储结构两种。 特点： 1.数据元素的数据类型相同 2.位顺从1开始 3.由唯一前驱和后继（除第一个和最后一个元素外） 顺序存储结构： 用一段不连续的内存空间存储线性表中的数据元素。 C++单向链表的代码实现 DynamicArray.h 链表类的定义 #include <iostream> //链表节点 template <typename T> class LinkN
C++类的使用实例（链表类、普通类的使用）
m0_61886762的博客
10-11 2632
其中包含一些相同函数名但调用的参数不同所以类对象可以根据参数的不同来调用不同的函数，因为这里在类中的成员为char指针类型所以不可以输入汉字如果大家想使用输入汉字则可以将其改为string类型，将相关的内容都更改为string类型即可。该类中使用了类与结构体的嵌套，在类中又定义了一个受保护的数据指向结构体的指针，也就是这里的结构体的头指针。个人认为用类去书写链表一个优点在于，它可以对链表的函数进行封装即外部不可以去调用类中关于链表的函数，因为结构体和类的默认成员不同，类中默认成员为private。
C++ 自定义模板详解
最新发布
fckbb的博客
05-20 1649
来编写通用的代码。模板可以使程序员编写出与类型无关的代码，从而使程序更具可重用性和灵活性。📖在C++中，有两种类型的模板：函数模板和类模板。函数模板可以定义一个通用的函数，使它适用于多种不同的数据类型。
静态链表模板
石前有座桥的博客
05-16 260
参照算法笔记P263.甲级1052 //定义静态链表 struct Node{ int address; typedname data; int next; XXX;//结点的某个性质 }; //初始化 for(i=0;i<maxn;i++){ node[i].XXX=0;//设置一个正常情况下达不到的数字 } //修改XXX int p=begin
数据结构——静态链表模板类实现
razorEdge的博客
10-13 765
数据结构笔记2.6 最近总算把静态链表的模板class整理出来了，之所以耽误时间，一方面是因为……，另一方面是静态链表和普通链表在思考上还是有差别的，把无序的东西（普通链表的每个节点）联系起来，还比较自然，但是把有序的东西（静态链表的物理存储）硬生生拆分成不按照其常规顺序的总是感觉别扭，但是认真想一下，其实二者在道理上是统一的。例如，在静态链表中Insert一个节点，其实就是在空闲数组中拿
数据结构 C++ 语言描述
04-16
本资料《数据结构 C++ 语言描述》由【美】William Ford 和 William Topp撰写，并由刘卫东、沈官林翻译，严蔚敏校对，由清华大学出版社出版，旨在深入讲解如何使用C++实现和操作各种数据结构。 首先，数据结构包括...
数据结构用面向对象方法与c++语言描述
09-04
《数据结构用面向对象方法与C++语言描述》是一本深度探讨如何利用C++编程语言来实现和理解数据结构的著作。这本书的核心在于将面向对象编程的理念与数据结构的理论相结合，为学习者提供了一种现代化的教学方式。通过...
数据结构C++语言描述
11-04
数据结构是计算机科学中的核心概念，它涉及到如何有效地组织、存储和检索数据，这对于编写...通过阅读《数据结构C++语言描述》这本书，读者不仅可以深入理解数据结构，还能掌握C++在实现这些结构时的技巧和最佳实践。
静态链表类模板的实现
桐小目的秘密基地
01-15 1010
相信你如果能找到这里，最起码单链表循环链表是什么你应该已经知道了，静态链表其实就是在单链表的基础上修改了每个函数的实现方法，使其基于数组实现。那么我就先介绍一下静态链表。   静态链表是利用数组来模拟存储空间来实现链表的，因为在整个运算过程中它的存储空间的大小不会改变，所以我们称之为 静态链表。    特点：        1.由数组模拟存储空间，实现链表。        2.可以不改变物
CPP中链表代码
08-26
CPP中链表代码
静态链表的C++实现
shiwazone的专栏
07-22 5485
静态链表是使用数组实现的可以快速插入和删除数据的链表，静态链表和链式单链表比的缺点在于链表的长度只能初始化设置好，而相对应普通的顺序存储的链表，静态链表不能实现快速的读写任意的元素。 当然静态链表给了我们一种思考方式，当我们在特定状态下，不能使用指针操作时，我们可以使用一种替代指针的方法，静态链表使用的cur来表示当前节点的下一个节点的下标。 #pragma once #define MAXS
静态链表（基础模板）
桃夭丶的博客
07-09 87
一、定义静态链表。代码如下： struct Node{ int address; //节点地址 typename data; //数据域 int next; //指针域 XXX; //节点的某个性质，不同的题目会有不同的设置，详见例题 }node[maxn]; 二、在程序开始，对静态链表进行初始化。一般来说，需要对定义中的XXX进行初始化，将其定义为正常情况下达不到的数字，列如对结点是...
静态链表类模板实现（带测试代码）
weixin_62802660的博客
10-27 198
cout
单链表模板类c++实现
SWC0619的博客
03-23 3721
c++实现单链表
C/C++实现静态链表
catofblack的博客
01-03 645
静态链表一般是创建在栈上的，出了栈，就不能访问，所有一般不适用静态链表，动态链表使用的更多 //创建链表节点 struct LinkNode { int num;//数据域 struct LinkNode* next;//指针域 }; void test() { //创建节点 struct LinkNode node1 = {10,NULL}; struct LinkNode node2 = {20,NULL}; struct L...
C++链表类模板解析及使用
showswoller的博客
08-25 1019
C++链表类模板解析及使用
静态链表的实现
rujin_shi的博客
03-07 3526
静态链表 用数组来代替指针，来描述单链表 将数组元素分成两个数据域，data和cur。data用来存放数据元素，cur存放该元素的后继在数组中的下标(游标)。&lt;游标实现法&gt; 1.基本结构 /*线性表的静态链表存储结构*/ #define MAXSIZE 1000 typedef struct { ElemType data; int cur; /*游标(Cursor)，...
C++实现链表、链式栈、链式队列、链表快速排序（模版）
热门推荐
concyclics的博客
04-28 3万+
C++实现链表、链式栈、链式队列、链表快速排序一、实现链表1. 什么是链表2. 单向链表和双向链表单向链表双向链表3. 代码实现头文件定义（List.hpp）实现代码(List.cpp) 一、实现链表 1. 什么是链表 百度百科 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺
C++程序设计中的线性表应用解析
教程中还涵盖了C++语言的发展历史，强调C语言的结构化特点、高效性、可移植性和灵活性，同时也指出C语言对于初学者的挑战在于其语法结构的自由度较高，调试程序需要一定的技巧。" 在C++中，线性表是一种基本的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值