c++ 实现线性表_数组_链表_顺序存储结构_链式存储结构

最新推荐文章于 2022-11-10 20:31:54 发布
最新推荐文章于 2022-11-10 20:31:54 发布
阅读量212 收藏
点赞数 1
分类专栏： 数据结构-实现 文章标签： c++ 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mamor/article/details/119981941
版权 
`在这里插入代码片`# c++ 实现线性表_数组_链表_顺序存储结构_链式存储结构

## 数组

~~~c++
#include <iostream>
#include "stdlib.h"
using namespace std;
#define MAXSIZE 20 //设置存储空间初始分量
#define OK 1
#define ERROR 0
typedef int ElemType;//ElemType 相当与int
typedef int Status;
class list1
{
public:
    list1();
    //~list1();
    Status GetElem(int i,ElemType &e); //获取
    Status ListInsert(int i,ElemType e);//插入
    Status show();
    Status ListDelete(int i,ElemType &e);//删除位置i的元素，并用e返回值
private:
    ElemType data[MAXSIZE];
    int length;
};
//构造函数用于初始化
list1::list1() {
    length = 0;
}
//获取指定位置元素的值
Status list1::GetElem(int i,ElemType &e) {
    if(length==0||i<1||i>length) return ERROR;
    e=data[i-1];
    return 0;
}
//在数组指定位置插入元素
Status list1::ListInsert(int i,ElemType e) {
    int k;
    if(length==MAXSIZE||i<1||i>length+1) //当数组满或者当要求插入位置小于1或者要求插入位置在数组最后以为后面时
        return ERROR;
    if(i<=length) {
        //将前面位置的元素均向后移动一位
        for(k=length-1;k>=i-1;k--) {
            data[k+1]=data[k];
        }
    }
    data[i-1]=e;
    length++;
    return OK;
}
//删除
Status list1::ListDelete(int i,ElemType &e) {
    int k;
    if(length==0||i<1||i>length) {
        cout<<"ERROR"<<endl;
        return ERROR;
    }
    e = data[i-1];
    if(i<length) for(k=i;k<length;k++) data[k-1]=data[k];
    length--;
    return OK;
}
Status list1::show() {
    if(length == 0) {
        cout<<"data is empty"<<endl;
        return ERROR;
    }
    else {
        cout<<"length is "<<length<<endl;
        cout<<"data is ";
        for(int i=0;i<length;i++) cout<<data[i]<<"  ";
        cout<<endl;
        return OK;
    }
}
int main()
{
    //构造函数用于初始化
    list1 q;
    q.show();
    //1.插入
    for(int i=0;i<=10;i++) q.ListInsert(i,i+1);
    q.show();
    /*q.ListInsert(1,22);
    q.show();*/
    //2.获取
    int e;
    q.GetElem(2,e);//使用了引用的方法
    cout<<"e is "<<e<<endl;
    //3.删除
    q.show();
    q.ListDelete(3,e);
    q.show();
    return 0;
}
~~~

## 静态链表

~~~c++
#include <iostream>
using namespace std;
#define MAXSIZE 1000 //假设链表的最大长度是1000
struct Node
{
    int data;
    int cur; 
};
class list3_oneself
{
public:
    list3_oneself();
    list3_oneself(int a[],int n);
    void show();//打印当前链表
    void show_real();//打印真实的顺序列表
    int length();//获当前链表长度
    void Insert(int n, int x);//在指定位置n前面插入元素x
    void Delete(int n);// 删除第i个节点
    int Get(int n);//获取指定位置的元素
    int Locate(int x);// 查找值为x的元素
private:
    Node StaticLinkList[MAXSIZE];
};
list3_oneself::list3_oneself() {
    for(int i=0;i<MAXSIZE-1;i++) StaticLinkList[i].cur = i+1; 
    StaticLinkList[MAXSIZE-1].cur = 0;
}
list3_oneself::list3_oneself(int a[],int n) {
    for(int i=0;i<MAXSIZE-1;i++) StaticLinkList[i].cur = i+1; 
    for(int i=1;i<n+1;i++) StaticLinkList[i].data = a[i-1];
    StaticLinkList[0].cur = n+1;//头节点存放备用链表第一个节点的下标
    StaticLinkList[MAXSIZE-1].cur = 1;//数组尾节点存放第一个插入元素的下标
    StaticLinkList[n].cur=0;//下一个数据为空则用0表示
}
void list3_oneself::show() {
    int len = length();
    cout<<"StaticLinkList's length is "<<len<<endl;
    cout<<"StaticLinkList is ";
    int k=StaticLinkList[MAXSIZE-1].cur;
    for(int i=1;i<=len;i++) {
        cout<<StaticLinkList[k].data<<"  ";
        k=StaticLinkList[k].cur;
    }
    //cout<<endl<<"cur is "<<StaticLinkList[len].cur<<endl;
    cout<<endl;
}
void list3_oneself::show_real() {
    int len = length();
    cout<<"StaticLinkList's length is "<<len<<endl;
    cout<<"real StaticLinkList is ";
    for(int i=1;i<=len;i++) {
        cout<<StaticLinkList[i].data<<"  ";
    }
    //cout<<endl<<"cur is "<<StaticLinkList[len].cur<<endl;
    cout<<endl;
}
int list3_oneself::length() {
    int k=StaticLinkList[MAXSIZE-1].cur;
    int num=0;
    while(k) {
        k=StaticLinkList[k].cur;
        num++;
    }
    return num;
}
void list3_oneself::Insert(int m,int x) {
    if(m>length()+1 || m<1 || m>MAXSIZE-2) {
        cout<<"overstep the boundary!!!"<<endl;
        exit(1);
    }
    int Cur=StaticLinkList[0].cur;//找到备用链表的第一个节点的下标
    ++StaticLinkList[0].cur;//备用链表的下标+1
    StaticLinkList[Cur].data = x;//插入新节点
    int k=MAXSIZE-1;
    for(int i=1;i<m;i++) { //找到第m个位置之前的位置
        k=StaticLinkList[k].cur;
    }
    StaticLinkList[Cur].cur=StaticLinkList[k].cur;//第m个位置
    StaticLinkList[k].cur=Cur;//指向插入节点的下标
}
void list3_oneself::Delete(int m) {
    if(m>length() || m<1) {
        cout<<"overstep the boundary!!!"<<endl;
        exit(1);
    }
    int k=MAXSIZE-1;
    for(int i=1;i<m;i++) {
        k=StaticLinkList[k].cur;//找到第m个元素的下标
    }
    int Cur=StaticLinkList[k].cur;//当前元素的下标
    StaticLinkList[k].cur = StaticLinkList[Cur].cur;//前一个元素的下标指向下一个元素
    StaticLinkList[Cur].cur = StaticLinkList[0].cur;//当前位置元素的下一个元素的下标指向原备用链表的第一个元素的位置
    StaticLinkList[0].cur = Cur;//将删除的元素的位置加入备用链表
}
int main()
{
    int arry[30];
    for(int i=0;i<30;i++) arry[i]=i;
    list3_oneself *StaticList = new list3_oneself(arry,30);
    StaticList->show();
    StaticList->Insert(1,100);
    StaticList->show();
    StaticList->Insert(32,101);
    StaticList->show();
    StaticList->show_real();
    StaticList->Delete(1);
    StaticList->show();
    StaticList->show_real();

    /*cout<<"StaticLinkList is ";
    for(int i=0;i<MAXSIZE;i++) {
        if(i%20==0) cout<<endl;
        cout<<StaticList.StaticLinkList[i].data<<"  ";
    }*/
    return 0;
}
~~~

## 链式存储结构

~~~c++
#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);// 有参构造函数，建立有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>
inline 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;        // 初始化一个空链表
    for (int i = 0; i < n; i++)
    {
        Node<T>* S = new Node<T>;
        S->data = a[i];        // 为每个数据元素建立一个节点
        S->next = first->next;
        first->next = S;    // 将节点S插入头节点之后
    }
}
// 尾插法建立单链表
/*template<class T>
LinkList<T>::LinkList(T a[], int n)
{
    first = new Node<T>;// 建立头节点
    first->next = NULL;
    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;                // 插入节点S，并将尾指针指向S节点
    }
    r->next = NULL;            // 单链表建立完毕之后，将尾指针置空
}*/

template<class T>
LinkList<T>::~LinkList()
{
    while (first != NULL)
    {
        Node<T>* p = first;        // 暂存将被释放节点
        first = first->next;    // 指向下一个节点
        delete p;
    }
}

template<class T>
int LinkList<T>::Length()
{
    int count = 0;                // 计数
    Node<T>* p = first->next;    // 将工作指针指向第一个节点
    while (p != NULL)
    {
        count++;
        p = p->next;
    }
    return count;
}

template<class T>
T LinkList<T>::Get(int i)
{
    int count = 0;                // 计数
    Node<T>* p = first->next;    // 将工作指针指向第一个节点
    while (p != NULL)
    {
        count++;
        if (count == i)
            return p->data;
        p = p->next;
    }
    return -1;                    // 越界
}

template<class T>
int LinkList<T>::Locate(T x)
{
    int count = 0;                // 计数
    Node<T>* p = first->next;    // 将工作指针指向第一个节点
    while (p != NULL)
    {
        count++;
        if (p->data == x)
            return count;
        p = p->next;
    }
    return 0;                // 查找失败
}

template<class T>
void LinkList<T>::Insert(int i, T x)
{
    int count = 0;                // 计数
    Node<T>* p = first;            // 将工作指针指向头节点
    while (p != NULL)
    {
        if (count == i - 1)        // 找第i-1个节点
        {
            Node<T>* S = new Node<T>;
            S->data = x;
            S->next = p->next;
            p->next = S;
        }
        p = p->next;
        count++;
    }
    if (p == NULL)
        throw "位置越界";
}

template<class T>
T LinkList<T>::Delete(int i)
{
    int count = 0;                // 计数
    Node<T>* p = first;            // 将工作指针指向头节点
    while (p != NULL)
    {
        if (count == i - 1)
        {
            Node<T>* q = p->next;// 暂存被删节点
            T x = q->data;
            p->next = q->next;
            delete q;
            return x;
        }
        p = p->next;
        count++;
    }
    return -1;
}

template<class T>
void LinkList<T>::PrintList()
{
    Node<T>* p = first->next;    // 将工作指针指向第一个节点
    while (p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
}
int main()
{
    int arry[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    LinkList<int>* linklist = new LinkList<int>(arry, 10);
    cout << linklist->Length() << endl;
    cout << linklist->Get(5) << endl;
    cout << linklist->Locate(6) << endl;
    linklist->Insert(3, 11);
    linklist->Delete(10);
    linklist->PrintList();

    //system("pause");
    return 0;
}
~~~

### 链式存储结构

~~~c++
#include <iostream>
using namespace std;
struct Node
{
    int data;
    Node *next;
};
class list2_oneself
{
public:
    list2_oneself();
    list2_oneself(int a[],int n);
    //~list2_oneself();
    void PrintList();//打印当前链表
    int length();//获当前链表长度
    int Get(int n);//获取指定位置的元素
    int Locate(int x);//查找值为x的元素
    void Insert(int n, int x);//在指定位置插入元素x
    void Delete(int n);//删除第i个节点
private:
    Node *first;
};
list2_oneself::list2_oneself() {
    first = new Node;
    first->next = NULL;
}
//头插法
/*list2_oneself::list2_oneself(int a[],int n) {
    first = new Node;
    first->next = NULL;
    for(int i=0;i<n;i++) {
        Node *s=new Node;
        s->data = a[i];
        s->next = first->next;
        first->next = s;
    }
}*/
//尾插法
list2_oneself::list2_oneself(int a[],int n) {
    first = new Node;
    first->next = NULL;
    Node* r = first;     //尾指针初始化,尾指针指first
    for(int i=0;i<n;i++) 
    {
        Node* S = new Node;
        S->data = a[i];     //为每个数据元素建立一个节点
        r->next = S;        //指针r指向的节点（first）指向s
        r = S;              //将新的节点插入链表,此时r代表s
    }              
    r->next = NULL;         //单链表建立完毕之后，将尾指针置空
}
//打印数据
void list2_oneself::PrintList() {
    Node* p = first->next;    // 将工作指针指向第一个节点
    while(p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout<<endl;
}
//求长度
int list2_oneself::length() {
    int count =0;
    Node* p=first->next;
    while(p!=NULL) {
        count++;
        p=p->next;
    }
    return count;
}
//获得指定位置的数据
int list2_oneself::Get(int n) {
    int count = 0;
    Node* p=first->next;
    while(p!=NULL) {
        count++;
        if(count == n) return p->data;
        p=p->next;
    }
    return -1;
}
//查找值为x的元素
int list2_oneself::Locate(int n) {
    int count =0;
    Node* p=first->next;
    while(p!=NULL) {
        count++;
        if(p->data == n) return count;
        p=p->next;
    }
    return 0;
}
//在指定位置插入元素
void list2_oneself::Insert(int n,int x) {
    int count=0;
    Node* p=first->next;
    while(p!=NULL) {
        count++;
        if(count == n) {
            Node* S = new Node;
            S->data = x;
            S->next = p->next;
            p->next = S;
        }
        p=p->next;
    }
}
//删除第i个节点
void list2_oneself::Delete(int n) {
    int count=0;
    Node* p=first->next;
    while(p!=NULL) {
        //count++;
        if(count == n-1) {
            Node* q=p->next;//要删除的节点
            p->next=q->next;
            delete(q);
        }
        count++;
        p=p->next;
    }
}
int main()
{
    int arry[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    list2_oneself *linklist = new list2_oneself(arry, 10);
    linklist->PrintList();
    cout<<"length is "<<linklist->length()<<endl;
    cout<<"data[5] is "<<linklist->Get(6)<<endl;
    cout<<"5 is on "<<linklist->Locate(5)<<endl;
    linklist->Insert(5,226);
    linklist->PrintList();
    cout<<"length is "<<linklist->length()<<endl;
    cout<<"delete 4"<<endl;
    linklist->Delete(4);
    linklist->PrintList();
    cout<<"length is "<<linklist->length()<<endl;
    return 0;
}
~~~
LovG-Sco-Tec
关注
专栏目录
数据结构之线性表（数组实现）
SurpriseKuang的博客
03-15 486
为了符合数据结构的核心思想，个人认为需要按照 ADT 来实现数据结构，ADT 就是抽象的数据结构，这个可以避免语言限制，更加通用描述了数据结构，不再被限制只能使用特定语言来实现数据结构（以后的有关数据结构的文章都是按照 ADT 来实现），下面将展示一下关于线性表的 ADT。下面是使用 C++ 来实现 ADT，使用了纯虚类，目的就是为了和 ADT 定义的一致，**关于 clear 的实现，这里实现只是把所有元素清楚，但是内存依然在，不知道这样是否合理，如有不合理的地方可以探讨一下。需要的头文件如下所示。
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++实现线性表完整代码
11-07
c++实现线性表完整代码，内涵注释，可视化操作线性表。
线性表(C++实现)
努力学习UE5ing。。。为了自己梦中的游戏而努力中
11-07 2794
具有相同数据类型的n个数据元素的有限序列，n是表长，当n为0的时候线性表是一个空表。如果用L命名线性表，那么其一般表示为L=(a1，a2，...，ai，ai+1，...，an)L=(a1​，a2​，...，ai​，ai+1​，...，an)式中，a1a_1a1​是唯一的"第一个"数据元素，称为表头元素，而ana_nan​是唯一的"最后一个元素"，称为表尾元素。
用C++语言实现线性表
qq_45234177的博客
04-20 1585
1.用数组实现 #include<iostream> #include "utility.h" using namespace std; const int max_list = 5000; template <class List_entry> //模板 class List { public: List(); //构造函数 int size() co...
C++实现数据结构——线性表
最新发布
qq_63058205的博客
11-10 1789
本次实验主要采用顺序表中的线性表的知识来进行实验，运用了线性表相关操作的声明和实现，如增删改查等。
C++ 数据结构线性表-数组实现
08-30
总的来说，C++中的线性表数组实现涉及到了动态内存分配、对象生命周期管理、数组操作以及基本数据结构的操作方法实现。这样的实现允许高效地访问和修改数组内的元素，但由于数组大小固定，插入和删除操作在表满或...
《数据结构与算法》课程上机实验一（线性表）_C++_数据结构与算法_线性表_
10-03
线性表是由n（n>=0）个相同类型元素构成的有限序列，其顺序存储结构通常使用一维数组来实现。 线性表的顺序存储结构是指在内存中连续分配一块空间，用于存放线性表的所有元素。这种存储方式的优点在于访问效率高，...
实验一终稿_基本操作_C++_线性表_
10-01
线性表存储结构（五选一）：1、 带头结点的单链表2、 不带头结点的单链表3、 循环链表4、 双链表5、 静态链表线性表的基本功能：1、 构造：使用头插法、尾插法两种方法2、 插入：要求建立的链表按照关键字从小到大...
基于链式存储结构的线性表实现.rar_Table_cameramjx_data structure
09-20
链式存储结构不同于顺序存储结构，如数组。在链式存储中，每个元素称为节点，每个节点包含两部分：数据域和指针域。数据域存储实际的数据，而指针域则存储指向下一个节点的地址。这种方式使得线性表中的元素可以不...
C++实现线性表（顺序表和链表）
qq_42820064的博客
06-11 5604
线性表 线性表示是由称为元素的数据项组成的一种有限且有序的序列。 下面代码显示了线性表的ADT的定义。 //声明List基类 template <typename E> class List { private: void operator = (const List &){ }//protect assignment List(const List&){...
C++实现线性表
twg123456的专栏
10-22 1143
-------------------------SqList.h------------------------------------/*构造线性表*/#include#ifndef SqList_H_#define SqList_H_//定义头文件#define initSize 100//初始化大小#define increment 10//增长步长typedef int ElemType
使用C++实现的线性表
hongbochen1223的专栏
03-27 4682
现在大三下学期了，由于参加了阿里巴巴的大四实习生校园招聘，第一轮电话面试就被刷下来了，这让我意识到了自己的能力还很不足，意识到了自己与那些大公司需要的人还有很长的路要走。 在电话面试中，基本上是根据我填写的简历来的，我写的是对linux内核非常感兴趣，所以，面试官问我了一些关于内核的一些问题，我竟头脑发蒙，啥都想不起来了。第一个问题就是问我从计算机上电开始，linux内核的启动过程。这一下我竟然
C++ 线性表（Array）实现
qq_53745697的博客
11-21 780
C++线性表的实现
线性表的C++实现
weixin_43207320的博客
03-30 834
一、实现功能 返回链表长度 在链表为尾部添加元素 插入元素 删除元素 按链表值从尾到头的顺序打印链表 清空链表 二、各功能详解 1、
【C++】c++实现线性表、链表
SuLiJuan66的专栏
10-02 1745
C++
C++使用模板类创建线性表（顺序、链式）并应用
Ai_King的博客
10-23 1666
在讨论线性表的顺序及链式存储映像，并在此基础上给出其基本操作的实现之前，先以模板的形式为ADT List建立一个抽象类。 //List.h #pragma once template <class ElemType> class List { public: //后面加个const 表明该函数不会改变成员函数的值！该函数可以被常量对象访问(const)。 //注意 加了const...
C++用类实现线性表(保姆级教你从0到封装一个SeqList类，附源码)
m0_51510934的博客
11-12 4047
[着急用代码的直接拿] （线性表（非链表）源码网盘链接：https://pan.baidu.com/s/1SbzGBK0Cv3nV3q14yUhDBw 提取码：s51t 链表源码网盘链接：https://pan.baidu.com/s/1dhd7Lvcd3yhC5nzcVzWTyA 提取码：zdzn） 1.什么是线性表 何谓线性表呢？先看一手百度的解释： 扯白了线性表就是一种序列并且其长度是作为它本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

LovG-Sco-Tec

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

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

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

打赏作者

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

抵扣说明：

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

余额充值