数据结构复习<2> 线性表的链接存储结构及其实现

最新推荐文章于 2023-05-22 20:10:44 发布
最新推荐文章于 2023-05-22 20:10:44 发布
阅读量502 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heyyun/article/details/80974470
版权

在此之前，我整理了用顺序表存储线性表的方法，但是顺序表具有以下缺点：

  • 列表内容插入和删除非常费劲。需要移动大量元素。
  • 表的容量难以确定。因为顺序表中数组的长度需要事先确定，所以难以确定合适的规模。
  • 造成存储空间的“碎片”。数组要求连续的存储空间，若不连续则不能使用，造成存储空间的“碎片”现象。

这一次，我们尝试用单链表存储线性表。
有空的话，可以尝试用循环链表和双链表来改善，是个很高级的东西。

一、 单链表的存储方法

通过每个指针的指针域连接线性表的数据元素。

二、单链表的实现

利用结构体类型来描述单链表的结点

template<class T>
struct Node
{
    T data;                     //指针域
    Node<T> * next;             //数据域
};

将线性表的抽象数据类型定义在单链表存储结构下用C++中的class实现。

template<class T>
class LinkList
{
public:
    LinkList();
    LinkList(T a[], int n);
    ~LinkList();
    int Length();              //求单链表的长度
    T Get(int i);              //按位查找，查找第i个结点的元素值
    int Locate(T x);           //按值查找，查找元素值为x的结点的位置
    void Insert(int i, T x);   //在第i个位置插入元素值为x的结点
    T Delete(int i);           //删除第i个结点
    void PrintList();          //遍历
private:
    Node<T> * first;           //单链表的头指针
};

1.构造函数

①无参构造函数

template<class T>
LinkList<T>::LinkList()
{
    first = new Node<T>;
    first->next = NULL;
}

②有参构造函数

template<class T>
LinkList<T>::LinkList(T a[], int n)
{
    first = new Node<T>;
    first->next = NULL;

    /*
        1.头插法建立单链表
    for(int i = 0; i < n; i++)
    {
        Node<T> * s = new Node<T>;
        s->data = a[i];
        s->next = first->next;  //将节点s插到头节点之后
        first->next = s;
    }
    */

    //  2.尾插法建立单链表
    Node<T> * r = first;        //尾指针初始化
    for(int i = 0; i < n; i++)
    {
        Node<T> * s = new Node<T>;
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

2.按位查找算法 Get

template<class T>
T LinkList<T>::Get(int i)
{
    //工作指针p和累加器count初始化
    Node<T> * p = first->next;
    int count = 1;

    while(p != NULL && count < i)
    {
        p = p->next;
        count++;
    }
    if(p == NULL)
        throw "位置异常";
    else
        return p->data;
}

3.按值查找算法 Locate

template<class T>
int LinkList<T>::Locate(T x)
{
    Node<T> * p = first->next;
    int count = 1;          //用来记录光标的位置
    while(p != NULL)
    {
        if(p->data == x)
            return count;
        p = p->next;
    }
    return 0;               //退出循环表示查找失败
}

4.插入算法

void LinkList<T>::Insert(int i, T x)    //在第i个位置插入元素x
{
    Node<T> * p = first;
    int count = 0;
    //找出第i-1个元素
    while(p != NULL && count < i - 1)
    {
        p = p->next;            //工作指针p向后移
        count++;
    }
    if(p == NULL)
        throw "位置异常";
    else
    {
        Node<T> * s = new Node<T>;
        s->data = x;
        s->next = p->next;
        p->next = s;
    }
}

5.删除算法

template<class T>
T LinkList<T>::Delete(int i)
{
    Node<T> * p = first;
    int count = 0;
    while(p != NULL && count < i - 1)
    {
        p = p->next;
        count++;
    }
    if(p == NULL)
        throw "位置异常";
    else
    {
        //暂存被删节点
        Node<T> * q = p->next;
        int x = q->data;

        p->next = q->next;
        delete q;
        return x;
    }
}

7.求链表的长度

int LinkList<T>::Length()
{
    //工作指针p和累加器count初始化
    Node<T> * p = first->next;
    int count = 0;

    while(p != NULL)
    {
        count++;
        p = p->next;
    }
    return count;
}

8.遍历

void LinkList<T>::PrintList()
{
    Node<T> * p = first->next;
    while(p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

9.析构函数算法

template<class T>
LinkList<T>::~LinkList()
{
    Node<T> *q = new Node<T>;
    while(first != NULL)        //释放单链表的每个结点的存储空间
    {
        q = first;              //暂存被释放结点
        first = first->next;    //first指向被释放结点的下一个结点
        delete q;
    }
}

完整代码如下：

#include <iostream>
#define maxSize 100
using namespace std;

template<class T>
struct Node
{
    T data;                     //指针域
    Node<T> * next;             //数据域
};
template<class T>
class LinkList
{
public:
    LinkList();
    LinkList(T a[], int n);
    ~LinkList();
    int Length();              //求单链表的长度
    T Get(int i);              //按位查找，查找第i个结点的元素值
    int Locate(T x);           //按值查找，查找元素值为x的结点的位置
    void Insert(int i, T x);   //在第i个位置插入元素值为x的结点
    T Delete(int i);           //删除第i个结点
    void PrintList();          //遍历
private:
    Node<T> * first;           //单链表的头指针
};
template<class T>
LinkList<T>::LinkList()
{
    first = new Node<T>;
    first->next = NULL;
}
template<class T>
LinkList<T>::LinkList(T a[], int n)
{
    first = new Node<T>;
    first->next = NULL;

    /*
        1.头插法建立单链表
    for(int i = 0; i < n; i++)
    {
        Node<T> * s = new Node<T>;
        s->data = a[i];
        s->next = first->next;  //将节点s插到头节点之后
        first->next = s;
    }
    */

    //  2.尾插法建立单链表
    Node<T> * r = first;        //尾指针初始化
    for(int i = 0; i < n; i++)
    {
        Node<T> * s = new Node<T>;
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}
template<class T>
void LinkList<T>::PrintList()
{
    Node<T> * p = first->next;
    while(p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}
template<class T>
int LinkList<T>::Length()
{
    //工作指针p和累加器count初始化
    Node<T> * p = first->next;
    int count = 0;

    while(p != NULL)
    {
        count++;
        p = p->next;
    }
    return count;
}
template<class T>
T LinkList<T>::Get(int i)
{
    //工作指针p和累加器count初始化
    Node<T> * p = first->next;
    int count = 1;

    while(p != NULL && count < i)
    {
        p = p->next;
        count++;
    }
    if(p == NULL)
        throw "位置异常";
    else
        return p->data;
}
template<class T>
int LinkList<T>::Locate(T x)
{
    Node<T> * p = first->next;
    int count = 1;          //用来记录光标的位置
    while(p != NULL)
    {
        if(p->data == x)
            return count;
        p = p->next;
    }
    return 0;               //退出循环表示查找失败
}
template<class T>
void LinkList<T>::Insert(int i, T x)    //在第i个位置插入元素x
{
    Node<T> * p = first;
    int count = 0;
    //找出第i-1个元素
    while(p != NULL && count < i - 1)
    {
        p = p->next;            //工作指针p向后移
        count++;
    }
    if(p == NULL)
        throw "位置异常";
    else
    {
        Node<T> * s = new Node<T>;
        s->data = x;
        s->next = p->next;
        p->next = s;
    }
}
template<class T>
T LinkList<T>::Delete(int i)
{
    Node<T> * p = first;
    int count = 0;
    while(p != NULL && count < i - 1)
    {
        p = p->next;
        count++;
    }
    if(p == NULL)
        throw "位置异常";
    else
    {
        //暂存被删节点
        Node<T> * q = p->next;
        int x = q->data;

        p->next = q->next;
        delete q;
        return x;
    }
}
template<class T>
LinkList<T>::~LinkList()
{
    Node<T> *q = new Node<T>;
    while(first != NULL)        //释放单链表的每个结点的存储空间
    {
        q = first;              //暂存被释放结点
        first = first->next;    //first指向被释放结点的下一个结点
        delete q;
    }
}
int main()
{
    int a[maxSize], i, SearchPos, NewPos, NewItem, DelPos ;
    int n = 0;

    //创建顺序表
    cout << "请输入顺序表长度:" ;
    cin >> n ;    //输入样本数目（表长）
    cout << "请输入表中所有元素:";
    for (i = 0 ; i < n; i++)
    {
        cin >> a[i] ;
    }
    LinkList<int> linkList(a, n);

    cout << "该顺序表为:";
    linkList.PrintList();   //显示顺序表
    cout << "请输入所查找的元素的位置:" ;
    cin >> SearchPos ;    //输入查找位置
    cout << "该位置的元素为:" << linkList.Get(SearchPos) << endl ;   //输出查找的数据元素值

    cout << "请输入所插入元素的值:" ;
    cin >> NewItem ;        //插入位置输入
    cout << "请输入所插入的元素的位置:" ;
    cin >> NewPos ;    //插入元素输入
    linkList.Insert(NewPos, NewItem) ;     //新数据插入顺序表中

    cout << "插入后的顺序表为:" ;
    linkList.PrintList();        //插入数据后，输出新的顺序表

    cout << "请输入所删除元素的位置:" ;
    cin >> DelPos ;        //输入删除元素位置
    linkList.Delete(DelPos) ;    //按位置删除数据

    cout << "删除后的顺序表为:" ;
    linkList.PrintList();
    return 0 ;
}
好运的云
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
educoder数据结构与算法线性表第2关：实现一个链接存储的线性表 定义线性表节点的结构.pdf
04-18
educoder数据结构与算法线性表第2关：实现一个链接存储的线性表 定义线性表节点的结构.pdf
2数据结构-链表及其应用
m0_73147943的博客
04-18 869
本关任务：已知两个单链表A和B，数据元素按值非递减有序排列，现将A和B归并成一个新的单链表C，使C中的数据元素仍按值非递减有序排列。例如： 设 A=(3,5,8,11) B=(2,6,9,15,20) 则 C=(2,3,5,6,8,9,11,15,20)为了完成本关任务，你需要掌握：1. 单链表的类型定义，2.单链表涉及的主要操作。为了完成本关任务，你需要掌握：1. 单链表的类型定义，2.链表涉及的主要操作。链表的初始化：构造一个带头结点的空的单链表。链表的初始化：构造一个带头结点的空的单链表。
实现一个链式存储的线性表
konnisan的博客
11-05 4918
实现一个链式存储的线性表任务描述相关知识编程要求测试说明代码实现 任务描述 本关任务：完成一个链接存储的线性表的小程序。 相关知识 线性表的存储也可以采用链接存储方式来实现。链接存储方式包括单链表、双链表和循环链表等形式。 下面描述了一种基于单链表的线性表实现方案： 为了讨论简单，假设数据元素的类型为整型： typedef int T; 在链表中，每个数据元素为一个链表结点，结点的具体定义为： struct LinkNode { T data; LinkNode* next; }; 如
线性表的链式存储结构和实现
leecam的博客
05-22 788
若front指向最后一个结点，有front.next=null，在front结点后插入一个结点，也可执行上述中间插入程序段，所以尾插入是中间插入的特例，中间插入或尾插入都不会改变单链表的头指针head。线性表采用链式存储结构，称为线性链表（Linked List），逻辑上相邻的元素是分散存储的，因此必须采用指针变量记载前驱或者后继元素的地址，来存储元素之间的线性关系。遍历单链表时从第0个结点开始，沿着结点的next链，依次访问单链表中每个结点，并且每个结点只访问一次。结点（结点域，地址域）
线性表的链接储存结构及实现
邵光亮的博客
09-22 1248
单链表 1 单链表的定义 单链表是用一组任意的存储单元来存放线性表的元素。存储单元可以连续，也可以不连续 为了正确的表示元素之间的逻辑关系，每个存储单元除了存储元素外 ，还需要存储后继元素的位置，这个地址信息用指针表示，称为指针；这两个元素组成了数据元素的存储映像，称为结点 也就是说节点有两个部分组成的 数据域 指针域 2 单链表结点c++实现 struct Node{ ...
【数据结构】线性表的链式存储结构及实现
SuperSources的博客
11-06 1156
链式存储分配的特点： 根据线性表的长度动态的申请存储空间，以解决顺序存储中存在的存储空间难以确定的问题。 指针变量的特点 变量的三要素 名字，内存地址，值 变量的左值，右值 左值指变量的内存地址 右值：值 在赋值表达式中，赋值号左边需要左值，右边需要右值；如a=a+100 指针变量 指针变量的右值本身又是一个左值。 1、链表结点数据类型的定义 template <typename T>...
线性表链式存储实现
qq_63913499的博客
10-17 406
线性表存储实现
实现一个链接存储的线性表（数据结构与算法 - 线性表）
韶言大雅
04-23 8430
完成一个链接存储的线性表的小程序。 相关知识 线性表的存储也可以采用链接存储方式来实现。链接存储方式包括单链表、双链表和循环链表等形式。 下面描述了一种基于单链表的线性表实现方案： 为了讨论简单，假设数据元素的类型为整型： typedef int T; 在链表中，每个数据元素为一个链表结点，结点的具体定义为： struct LinkNode { T data; LinkNode...
数据结构与算法 - 线性表(完整代码)
JKR10000的博客
03-27 5409
样例输入: 3 //输入一个数a，后面将输入a个数据元素 8 9 3 //a个数据元素，依次插入尾结点后。形成单链表结点序列：8,9,3 3 //输入一个数b，后面将再输入b个数据元素 10 89 22 //b个数据元素，依次插入0号结点后。形成单链表结点序列：8,22,89,10,9,3 89 //删除一个值为89的结点 1 //删除1号结点 样例输出: 8 10 9 3 #inc...
数据结构复习代码集合.rar
12-05
数据结构之线性结构的基本实现，包含线性表、栈和队列的顺序存储实现与链式存储的C语言代码实现。
数据结构实验2线性表答案.doc
07-11
实 验 报 告 院（系）：信息科学与技术学院 课程名称：数据结构 日期： "班级" "学号 " "实验室 " " "专业"计算机科学与技术"姓名 " "计算机号 " " "实验"顺序表的运算 "成绩评定 " " "名称" " " " "所用"V C或TC ...
数据结构总结（自学、期末复习或考研备用）.pdf
01-16
内容涵盖：第一章绪论、算法衡量指标、第二章线性表、顺序表、链表、第三章栈和队、栈、栈的应用举例、队列、循环队列、第四章串、串的模式匹配、第五章数组和广义表、稀疏矩阵的压缩存储方法:、广义表、第六章树和...
数据结构总复习.docx
02-03
是自己总结的数据结构总复习。 内容大致： 第一章 绪论 第二章 线性表 第三章第三章限定线性表----栈与队列 第四章 串 第五章 第五章数组与广义表 //扩展的线性数据结构 第六章 第六章树与二叉树 第七章 图 ...
数据结构复习（1）---线性表的顺序存储结构及实现
07-11
线性表的顺序存储结构及实现http://blog.csdn.net/eeeduo/article/details/37698615
起点小说解锁.js
04-27
起点小说解锁.js
299-煤炭大数据智能分析解决方案.pptx
04-27
299-煤炭大数据智能分析解决方案.pptx
299-教育行业信息化与数据平台建设分享.pptx
04-27
299-教育行业信息化与数据平台建设分享.pptx
基于Springboot+Vue酒店客房入住管理系统-毕业源码案例设计.zip
04-27
网络技术和计算机技术发展至今，已经拥有了深厚的理论基础，并在现实中进行了充分运用，尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代，所以对于信息的宣传和管理就很关键。系统化是必要的，设计网上系统不仅会节约人力和管理成本，还会安全保存庞大的数据量，对于信息的维护和检索也不需要花费很多时间，非常的便利。 网上系统是在MySQL中建立数据表保存信息，运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时，也能及时通过数据输入的有效性规则检测出错误数据，让数据的录入达到准确性的目的，进而提升数据的可靠性，让系统数据的错误率降至最低。 关键词：vue；MySQL；SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
时间复杂度的一些相关资源
最新发布
04-27
时间复杂度是计算机科学中用来评估算法效率的一个重要指标。它表示了算法执行时间随输入数据规模增长而变化的趋势。当我们比较不同算法的时间复杂度时，实际上是在比较它们在不同输入规模下的执行效率。 时间复杂度通常用大O符号来表示，它描述了算法执行时间上限的增长率。例如，O(n)表示算法执行时间与输入数据规模n呈线性关系，而O(n^2)则表示算法执行时间与n的平方成正比。当n增大时，O(n^2)算法的执行时间会比O(n)算法增长得更快。 在比较时间复杂度时，我们主要关注复杂度的增长趋势，而不是具体的执行时间。这是因为不同计算机硬件、操作系统和编译器等因素都会影响算法的实际执行时间，而时间复杂度则提供了一个与具体实现无关的评估标准。 一般来说，时间复杂度越低，算法的执行效率就越高。因此，在设计和选择算法时，我们通常希望找到时间复杂度尽可能低的方案。例如，在排序算法中，冒泡排序的时间复杂度为O(n^2)，而快速排序的时间复杂度在平均情况下为O(nlogn)，因此在处理大规模数据时，快速排序通常比冒泡排序更高效。 总之，时间复杂度是评估算法效率的重要工具，它帮助我们了解算法在不同输入规模下的性
线性表的顺序存储结构的实现及其应用项目策划书
06-04
2. 设计并实现基于线性表的顺序存储结构的数据结构。 3. 探究线性表的顺序存储结构的应用场景，如通讯录、学生成绩管理系统、电商平台商品管理等。 4. 实现一个通讯录应用，使用线性表的顺序存储结构来存储联系人...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值