C++版数据结构-----线性表

最新推荐文章于 2024-09-01 12:50:42 发布
最新推荐文章于 2024-09-01 12:50:42 发布
阅读量1k 收藏 9
点赞数 3
分类专栏： C++ 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Johnor/article/details/128571140
版权
文章介绍了数据结构中的两种基本类型——顺序表和链表。顺序表是通过物理位置相邻存储逻辑上相邻的数据元素，适合随机访问，但插入和删除操作效率低。链表则允许元素在内存中任意位置，通过指针链接元素，插入和删除效率高但需要额外的指针存储空间，且不支持随机访问。文章还提到了链表的不同变体，如循环链表和双向链表，以及它们各自的优缺点。
摘要由CSDN通过智能技术生成

程序 = 数据结构 + 算法

Pascal语言之父-----Nicklaus Wirth，凭借一句话获得图灵奖

基本结构

image-20230105171439129

线性表

顺序表

线性表的顺序表示又称为顺序存储结构或顺序映像

顺序存储定义：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构

线性表的第1个数据元素a1的存储位置，称作线性表的起始位置或基地址

线性顺序存储占用一片连续的存储空间。知道某个元素的存储位置就可以计算其他元素的存储位置

image-20230105172352819

时间复杂度：查找、插入、删除算法的平均时间复杂度为O(n)

空间复杂度：顺序表操作算法的空间复杂度S(n)=O(1)(没有占用辅助空间)

优点：

存储密度大（结点本身所占存储量/结点结构所占存储量）

可以随机存取表中任意元素

缺点

在插入、删除某一元素时，需要移动大量元素

浪费存储空间

属于静态存储形式，数据元素的个数不能自由扩充

代码实现：

#include <iostream>
using namespace std;
#define Maxsize 100
template <class T>
class SqList//顺序表
{
public:
    SqList(T a[],int n);//构造函数
    ~SqList(){};//析构函数
    void ClearList();//将顺序表清空
    void ListInsert(int i,T e);//在顺序表中第i个位置插入新元素e
    T ListDelete(int i);//删除线性表中第i个位置元素并返回
    bool IsEmpty();//判断线性表是否为空
    int LocateElem(T e);//查找与给定值相等的元素若成功返回序号
    int GetLength();//获得线性表的表长
    T GetElem(int i);//返回线性表中第i个元素
    void printfSqList();//遍历线性表
private:
    T elem[Maxsize];//存储的元素
    int Length;//存储的元素的数量
};
template<class T>
SqList<T>::SqList(T a[],int n)//构造一个新的顺序表
{
    if(n>Maxsize) throw"溢出！";
    else
    {
        for(int i = 0;i<n;i++)
        {
            elem[i] = a[i];
        }
        Length = n;
    }

}
template<class T>
void SqList<T>::ClearList()
{
    Length = 0;
}

template<class T>
void SqList<T>::ListInsert(int i,T e)
{
    if(i<1||i>Length) throw"非法参数";
    if(Length == Maxsize) throw"线性表已满";
    for(int j = Length - 1;j>=i-1;j--)
        elem[j+1] = elem[j];
    elem[i-1] = e;
    Length++;
}

template<class T>
T SqList<T>::ListDelete(int i)
{
    T DE;
    if(i<1||i>Length) throw"非法参数";
    DE = elem[i-1];
    for(int j = i;j<=Length;j++)
        elem[j-1] = elem[j];//被删除的元素之后前移
    Length--;
    return DE;
}

template<class T>
bool SqList<T>::IsEmpty()
{
    if(Length==0) return true;
    else false;
}

//template<class T>
//int SqList<T>::LocateElem(T e)
//{
// int i;
// for(i = 0;i<Length;i++)
// {
//  if(elem[i]==e) return i+1;//查找成功
// }
// return false;//查找失败
//}

template<class T>
int SqList<T>::LocateElem(T e)
{
    int i = 0;
    while(i<Length&&elem[i]!=e) i++;
    if(i<Length) return i+1;
    return false;//查找失败
}

template<class T>
int SqList<T>::GetLength()
{
    return Length;
}

template<class T>
T SqList<T>::GetElem(int i)
{
    if(i<1||i>Length) throw"非法参数！";
    else
        return elem[i-1];
}

template<class T>
void SqList<T>::printfSqList()
{
    for(int i = 0;i<Length;i++)
        cout<<elem[i]<<" ";
    cout<<endl;
}
int main(void) {
    int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    SqList<int> S(a, 10);
    S.printfSqList();
    cout<<S.GetElem(1)<<endl;
    cout<<S.GetLength()<<endl;
    S.ListDelete(10);
    S.printfSqList();
    cout<<S.LocateElem(8)<<endl;
    cout<<S.IsEmpty()<<endl;
    S.ListInsert(2,10);
    S.printfSqList();
    return 0;
}

运行结果：

image-20230105173206200

链表

链式存储结构：结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻

线性表的链式表示又称为非顺序映像或链式映像

用一组物理位置任意的存储单元来存放线性表的数据元素

这组存储单元的位置是随机的

链表中元素的逻辑次序和物理次序不一定相同

各结点由两个域组成：

数据域：存储元素数值数据

指针域：存储直接后继结点的存储位置

image-20230105173645114

结点只有一个指针域的链表，称为单链表或线性链表

结点有两个指针域的链表，称为双链表

首尾相接的链表称为循环链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tucVifCP-1672927655442)(null)]

设置头结点的好处：

  1. 便于首元结点的处理

​ 首元结点的地址保存在头结点的指针域中，所以在链表的第一个位置上的操作和其他位置一致，无须进行特殊处理

  1. 便于空表和非空表的统一处理

​ 无论链表是否为空，头指针都是指向头结点的非空指针，因此空表和非空表的处理也就统一了

头结点不能计入链表长度值

查找：

​ 线性链表只能顺序存取，即在查找时要从头指针找起，查找的时间复杂度为O(n)

插入和删除：

​ 线性链表不需要移动元素，只需要修改指针，一般情况下时间复杂度为O(1)

​ 在单链表中进行前插或删除操作，由于要从头查找前驱结点，所耗时间复杂度为O(n)

程序示例

#include <iostream>
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 n,T a[]);//尾插法建立链表
    bool ListEmpty();//判断链表是否为空
    void DestroyList();//销毁单链表
    int ListLength();//求单链表的表长
    T GetElem(int i);//按位查找
    Node<T> *LocateElem(T e);//在线性表中查找值为e的元素
    int LocateElem_V(T e);//按值查找返回序号
    void ListInsert(int i,T e);//在i位置插入数据e
    T ListDelete(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>
bool LinkList<T>::ListEmpty() {
    if(first->next == NULL) return true;
    else return false;
}

template <class T>
void LinkList<T>::DestroyList() {
    Node<T> *p = first->next,*q;//p用于移动，q用于删除
    while(p)
    {
        q = p;//p的当前地址给q
        p = p->next;//p向后移动一个位置
        delete q;//删除p的前趋结点
    }
    first->next = NULL;
}

template <class T>
int LinkList<T>::ListLength() {
    Node<T> *p;//用于移动的工作指针
    int j = 0;
    p = first->next;//p指向第一个结点
    while(p)
    {
        j++;
        p = p->next;
    }
    return j;
}

template <class T>
T LinkList<T>::GetElem(int i) {
    Node<T> *p = first ->next;//初始化
    Node<T> e;
    int j = 0;
    while(p!=NULL&&j<i)
    {
        p = p->next;
        ++j;
    }
    if(p==NULL||j>i) throw"第i个元素不存在";
    e = p->data;
    return e;
}

template <class T>
Node<T> *LinkList<T>::LocateElem(T e) {
    Node<T> *p = first->next;
    while(p!=NULL&&p->data!=e)
    {
        p = p->next;
    }
    return p;
}

template <class T>
int LinkList<T>::LocateElem_V(T e) {
    Node<T> *p = first->next;
    int j = 1;
    while(p!=NULL&&p->data!=e)
    {
        p = p->next;
        j++;
    }
    if(p!=NULL) return j;
    else return 0;
}

template <class T>
void LinkList<T>::ListInsert(int i, T e) {
    Node<T>* p = first,*s;
    int j = 0;
    while(p&&j<i-1){p = p->next;++j;}//寻找第i-1个结点，p指向i-1结点
    if(!p||j>i-1) throw "插入位置非法";
    else
    {
        s = new Node<T>;
        s->data = e;
        s->next = p->next;//将新插入的结点与第原来i个结点连接起来
        p->next = s;//将第i-1个结点与新结点连接起来
    }

}

template <class T>
T LinkList<T>::ListDelete(int i) {
    Node<T>* p = first,*q;
    T e;
    int j = 0;
    while((p->next!=NULL)&&j<i-1){p = p->next;j++;}//寻找第i个结点，并另p指向其前驱，p实际指向的是i-1，p->next才是i
    if((p->next==NULL)||j>i-1) throw"非法位置！";
    q = p->next;//临时保存被删结点的地址以备释放
    p->next = q->next;//改变删除结点前驱结点的指针域
    e = q->data;
    delete q;
}

template <class T>
LinkList<T>::LinkList(T *a, int n) {
    Node<T> *s;//指向待插入结点
    first = new Node<T>;//创建头结点
    first->next = NULL;
    for(int i = 0;i<n;i++)
    {
        s = new Node<T>;
        s->data = a[i];
        s->next = first->next;//将新结点与原来第一个结点相连接
        first->next = s;//将新插入的结点与头结点相连接
    }
}

template <class T>
LinkList<T>::LinkList(int n, T *a) {
    first = new Node<T>;//创建头结点
    Node<T> *rear = first,*s;
    for(int i = 0;i<n;i++)
    {
        s = new Node<T>;//创建头结点
        s->data = a[i];
        rear->next = s;//连接最后一个结点和新插入的结点
        rear = s;//rear指向最后一个结点
    }
}

template <class T>
void LinkList<T>::PrintList() {
    Node<T>* p = first->next;
    while(p!=NULL)
    {
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}
int main() {
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    LinkList<int> L1(a,10);
    L1.PrintList();
    LinkList<int>L2(10,a);
    L2.PrintList();
    L1.ListDelete(1);
    L1.PrintList();
    L1.ListInsert(2,10);
    //L1.PrintList();
    L1.ListDelete(1);
    L1.PrintList();
    return 0;
}

运行结果：

image-20230105203059159

循环链表

是一种头尾相接的链表(即：表中最后一个结点的指针域指向头结点，整个链表形成一个环)

image-20230105203325495

优点：从表中任一结点触发均可找到表中其他结点

循环链表中没有NULL指针，涉及遍历操作时，其终止条件不再是判断p或p->next是否为空，而是判断它们是否等于头指针

程序：

#include <iostream>
using namespace std;
template<class T>
struct Node{
    T data;
    Node<T> *next;
};
template<class T>
class CirLinkList//带尾指针的循环链表
{
public:
    CirLinkList(){
        rear = new Node<T>;
        rear->next = rear;
    }
private:
    Node<T> *rear;
};
template<class T>
void Connect(CirLinkList<T> *Ta,CirLinkList<T> *Tb)
{
    Node<T> *p = Ta->rear->next;//p存表头Ta结点
    Ta->rear->next = Tb->rear->next->next;//Tb表头连接Ta表尾
    delete Tb->rear->next;//释放Tb表头结点
    Tb->rear->next = p;//修改指针
}
int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}
双向链表

为了克服单链表查找后继结点容易，找前驱结点困难的问题

双向链表：在单链表的每个结点里再增加一个指向其直接前驱的指针域prior，这样链表中就形成了有两个不同方向的链，故称为双向链表

image-20230105215144596

双向循环链表：

image-20230105215213948

程序：

#include <iostream>
using namespace std;
template<class T>
struct Node{
    T data;
    Node<T> *prior;//指向前驱的指针
    Node<T> *next;//指向后继的指针
};
template<class T>
class DoubleLinkList{
public:
    DoubleLinkList(){
        first = new Node<T>;
        first->prior = NULL;
        first->next = NULL;
    }
    void ListInsert(int i, T e)
    {
        Node<T> *p,*s;//p原i位置
        if(p)
        {
            s = new Node<T>;
            s->data = e;
            s->prior = p->prior;
            p->prior->next = s;
            s->next = p;
            p->prior = s;
            
        }
    }
    T ListDelete(int i)
    {
        T e;
        Node<T> *p;
        if(p)
        {
            e = p->data;
            p->prior->next = p->next;
            p->next->prior = p->prior;
            delete p;
        }
        return e;
    }
private:
    Node<T> *first;
};
int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

存储密度：

image-20230105220156801

链式存储结构的优点：

​ 结点空间可以动态申请和释放；

​ 数据元素和逻辑次序靠结点的指针来指示，插入和删除时不需要移动数据元素

链式存储结构的缺点：

​ 存储密度小，每个结点的指针域需额外占用存储空间。每个结点的数据域所占字节不多时，指针域所占存储空间的比重显得很大。

​ 链式存储结构是非随机存储结构。对任一结点的操作都要从头指针依指针链查找到该结点，这增加了算法的复杂度

      e = p->data;
        p->prior->next = p->next;
        p->next->prior = p->prior;
        delete p;
    }
    return e;
}

private:
Node *first;
};
int main() {
std::cout << “Hello, World!” << std::endl;
return 0;
}


存储密度：

[外链图片转存中...(img-rQkabrbg-1672927652818)]

链式存储结构的优点：

​		结点空间可以动态申请和释放；

​		数据元素和逻辑次序靠结点的指针来指示，插入和删除时不需要移动数据元素

链式存储结构的缺点：

​		存储密度小，每个结点的指针域需额外占用存储空间。每个结点的数据域所占字节不多时，指针域所占存储空间的比重显得很大。

​		链式存储结构是非随机存储结构。对任一结点的操作都要从头指针依指针链查找到该结点，这增加了算法的复杂度
计算机小混子
关注
专栏目录
C++线性表
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-30 915
包含的主要知识点： 1.C++模板类 友元函数的写法。 2.C++模板类 重载cout<< 的写法。 3.线性表的普通写法。 线性表的一般写法 废话少说，直接上代码 头文件： #pragma once #define MaxSize 100 #include #include using namespace std; template class LinearList; templat...
数据结构——线性表(C++)
dahulihuli的博客
03-04 1332
数据结构在逻辑结构上分为线性和非线性，例如链表、顺序表、串、数组都是线性的，他们的特点就是一对一，而非线性结构比如图和二叉树，他们的对应关系是一对多、多对多，这里介绍线性表的顺序表和链表、循环链表和双向链表，还有双向循环链表。链表尤其重要，很多结构都是以链表作为基础的，比如栈和队列。先写头文件，然后是功能实现的cppprivate:int length;return;i < n;
一篇讲完常用线性表及C++实现
最新发布
weixin_56520780的博客
09-01 356
包括一些开发中常用线性表： 静态顺序表 动态顺序表 单链表 双链表 链栈 链式队列
数据结构——线性表（C++）
DaMercy的博客
11-10 1042
线性表一、线性表的定义二、线性表的抽象数据类型三、线性表的顺序存储1. 顺序存储定义2.顺序存储的实现方式四、线性表的链式存储五、其他线性表参考 一、线性表的定义 线性表：零个或多个数据元素的有限序列。 线性表是最常用且是最简单的一种数据结构。形如：A1、A2、A3….An这样含有有限的数据序列，我们就称之为线性表。 线性表包括顺序表和链表。 顺序表（其实就是数组）里面元素的地址是连续的， 链表里面节点的地址不是连续的，是通过指针连起来的。 二、线性表的抽象数据类型 线性表的抽象数据类型定义如下： ADT
线性表（C++）
weixin_63198483的博客
11-14 3888
数据结构与算法--线性表的各项操作（C++)
c/c++数据结构-线性表-链表
04-26
数据结构实验线性表当中的链表结构实现，带有详细注释，小白也能看得懂
数据结构-C++在dev C++平台运行 线性表 链接存储结构
03-27
数据结构-C++在dev C++平台运行 线性表 链接存储结构，程序正常运行，用于教学 ，便于交流
C++ 数据结构线性表-数组实现
12-26
C++ 数据结构线性表-数组实现 线性表的数组实现，实现几个核心的功能，语言是C++，如果有更好的想法和意见，欢迎留言~~~ /* Author : Moyiii * 线性表的数组实现，仅作学习之用，当然如果 * 你想拿去用，随你好啦...
c/c++数据结构-线性表-顺序表
04-26
数据结构实验中线性表的顺序表代码，带有详细注释，小白也能看得懂
c++线性表
qi_programmer的博客
02-24 1512
线性表的分类 （简单 STL）一、长度可变数组 vector二、栈 stack （稍慢，最好手写栈）三、队列 queue四、链表 list 一、长度可变数组 vector 二、栈 stack （稍慢，最好手写栈） 三、队列 queue 四、链表 list ...
c++实现线性表
05-21
线性表的实现代码 #include<iostream> using namespace std; template <class Telem> class List { public: virtual void clear()=0;//清空 virtual int leng()=0;//求线性表的长度 virtual Telem gete(int loc,Telem &el;)=0;//返回第i个元素的值 virtual int loct(Telem& el)=0;//查找，若找到返回元素的值，否则返回0 virtual bool insert(int loc,Telem& el)=0;//将el插入在loc的位置上 virtual Telem dele(int loc)=0;//删除loc位置的值 virtual bool full()=0;//判断线性表是否为满 virtual bool empt()=0;//判断线性表是否为空 virtual void print_SqList()=0;//显示表中的元素 virtual void inver()=0;//表的逆置 virtual void sort()=0;//表的排序 virtual ~List(){};//释放动态空间 };
数据结构线性表（C++ ）
chaichai126的博客
10-24 660
我自由了
线性表(C++实现)
努力学习UE5ing。。。为了自己梦中的游戏而努力中
11-07 2907
具有相同数据类型的n个数据元素的有限序列，n是表长，当n为0的时候线性表是一个空表。如果用L命名线性表，那么其一般表示为L=(a1，a2，...，ai，ai+1，...，an)L=(a1​，a2​，...，ai​，ai+1​，...，an)式中，a1a_1a1​是唯一的"第一个"数据元素，称为表头元素，而ana_nan​是唯一的"最后一个元素"，称为表尾元素。
c++数据结构之线性表
sr_uncle的博客
02-22 580
之前完全靠自己的理解建立了一个单链表，但是思想并不怎么成熟，虽然是勉强做出来了，但是还是有很多地方自己把自己绕晕过去，所以过完年之后没那么多事儿了，就重新温习一遍上课时候使用的教材：李春葆的数据结构第四版。觉得自己应该把书上的数据结构都实现一遍，当然逻辑部分还是要学习一下，毕竟完全靠自己思考，有时会显得逻辑混乱。再一次拿起数据结构，感觉逻辑还是很容易理解的，之前学习的时候有什么感觉也记不住了，印象不
C++数据结构之线性表
念去去
07-25 1719
任务描述 本关任务：用户输入两个四位数以内的整数，请你对两个整数进行四则运算（为保证除法能正确计算，输入的第二个整数不能为0），要求输出的四则运算表达式是完整对齐的。 例如，给定输入1256和20，其符合上述对齐要求的四则运算的输出格式应该如下所示（为了让空格显示的更直观，这里暂用下划线_表示空格）： 1256 + 20__ = ___1276 1256 - 20 = ___1236 1256 * 20 = __25120 1256 / 20 = _______62 相关知识 程序的输出格式对用户体验影响很
线性表 - C++
OrPeel的博客
04-20 212
线性表是数据结构中的一种基本数据类型，它是由n 个数据元素组成的有限序列。表中元素个数有限表中元素具有逻辑上的顺序性，表中元素有其先后次序表中元素都是数据元素，每个元素都是单个元素除第一个元素外，每一个元素有且只有一个直接前驱元素，除了最后一个元素外，每一个元素有且只有一个直接后继元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

计算机小混子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值