数据结构-线性表

已于 2022-05-31 13:59:38 修改
阅读量875 收藏 4
点赞数 1
文章标签： 数据结构 链表 算法 c++
于 2022-05-31 13:58:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LWJLWJ_/article/details/125064006
版权

一、线性表(list)

线性表是最基本、最简单、也是最常用的一种数据结构。线性表*（linear list）*是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。

线性表的存储结构

  • 顺序表
  • 链表
    • 单链表
      • 动态单链表
      • 静态单链表
    • 双链表
    • 循环链表
      • 单循环链表
      • 双循环链表

以下我只实现了顺序表、单链表和双链表。

二、顺序表

顺序表是通过数组进行储存的结构

1. 结构模型图

顺序表

2.顺序表的常用接口

功能描述：顺序栈容器常用的对外接口

构造函数：

  • SeqList(); //构造函数
  • SeqList(SeqList &s); //拷贝构造

大小操作：

  • isEmpty();` //判断顺序表是否为空
  • isFull();` //判断顺序表是否已满
  • size(); ` //返回栈的大小
  • resize(); // 扩容

插入删除：

  • remove(int i)·; //在线性表中，位序为i[0…n-1]的位置删除元素

  • insert(int i, const Type& value); //在第i个位置插入元素value

  • clear(); //清空

查找遍历：

  • visit(int i); // 在线性表中，查找位序为i的元素并返回其值

  • search(const Type& value); //查找值为value的元素第一次出现的位序

  • traverse(); //遍历

逆置：

  • inverse(); // 逆置线性表

合并：

* Union(SeqList<Type>* lb); //两个单链表合并

3.代码实现

seqList.h

/**
 * @**Author: lwj**
 * @Date: 2022-05-28 13:04:41
 * @LastEditTime: 2022-05-28 13:04:41
 * @Description:数据结构---顺序表
 * @FilePath: /Linux_C_C-plus-plus/数据结构（C++）/list/seqList/seqList.h
 **/

#pragma once
#include <iostream>
#include <assert.h>

#define MAXSIZE 10
template <typename Type>
class SeqList
{
private:
    Type *data;  // 维护存储数据的指针
    int count;   // 记录元素个数
    int maxSize; // 数组容量
public:
    SeqList(int isSize = MAXSIZE);                   // 构造函数
    SeqList(const SeqList &s);                       // 拷贝构造
    ~SeqList() { delete[] data; }                    // 析构函数
    void clear() { count = 0; }                      // 清空表，只需修改count
    bool isEmpty() const { return count == 0; }      // 判空
    bool isFull() const { return count == maxSize; } // 判满
    int size() const { return count; }               // 返回顺序表的当前存储元素的个数
    void insert(int i, const Type &value);           // 在位置i上插入一个元素value，表的长度增1
    void remove(int i);                              // 删除位置i上的元素value，若删除位置合法，表的长度减1
    int search(const Type &value) const;             // 查找值为value的元素第一次出现的位序
    Type visit(int i) const;                         // 访问位序为i的元素值，“位序”0表示第一个元素，类似于数组下标
    void resize();                                   // 扩容
    void traverse() const;                           // 遍历顺序表
    void inverse();                                  // 逆置顺序表
    bool Union(SeqList<Type> &B);                    //合并两个表
};

template <typename Type>
SeqList<Type>::SeqList(int isSize) // 构造函数
{
    if (isSize < 0)
    {
        std::cout << "容量大小错误！" << std::endl;
        return;
    }
    this->maxSize = isSize;
    count = 0;
    data = new Type[maxSize]; //在堆区创建一个大小为maxSize的数组
}

template <typename Type>
SeqList<Type>::SeqList(const SeqList &s) // 拷贝构造
{
    maxSize = s.maxSize; // 也可以s有多少个元素就开辟多少空间
    count = s.count;
    data = new Type[maxSize];
    for (int i = 0; i < s.count; i++)
    {
        data[i] = s.data[i];
    }
}

template <typename Type>
void SeqList<Type>::insert(int i, const Type &value) // 在位置i上插入一个元素value，表的长度增1
{
    if (isEmpty())
    {
        cout << "已满！" << std::endl;
        return;
    }
    assert(i > 0 && i <= count); // i只能在[0~count]
    //在i处插入数据，i及其后面的元素向后移动一位
    for (int j = count; j > i; j--)
    {
        data[j] = data[j - 1];
    }
    data[i] = value;
    count++; //表长加一
}
template <typename Type>
void SeqList<Type>::remove(int i) // 删除位置i上的元素value，若删除位置合法，表的长度减1
{
    if (isEmpty())
    {
        std::cout << "为空！" << std::endl;
        return;
    }
    assert(i > 0 && i <= count - 1); // i只能在[0~count]
    for (int j = i; j <= count - 1; j--)
    {
        data[j] = data[j + 1]; //直接用后面一个数据覆盖所要删除的数据
    }
    count--; //表长减一
}
template <typename Type>
int SeqList<Type>::search(const Type &value) const // 查找值为value的元素第一次出现的位序
{
    for (int i = 0; i < count; i++)
        if (value == data[i])
            return i;
    return -1; // 查找失败返回-1
}
template <typename Type>
Type SeqList<Type>::visit(int i) const // 访问位序为i的元素值，“位序”0表示第一个元素，类似于数组下标
{
    assert(i > 0 && i <= count - 1); // i只能在[0~count-1]
    return data[i];
}
template <typename Type>
void SeqList<Type>::traverse() const // 遍历顺序表
{
    if (isEmpty())
    {
        std::cout << "数据为空！" << std::endl;
    }
    else
    {
        for (int i = 0; i < count; i++)
        {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }
}
template <typename Type>
void SeqList<Type>::resize() // 扩容
{
    Type *tmp = new Type[2 * maxSize];
    for (int i = 0; i < count; i++)
    {
        tmp[i] = data[i];
    }
    delete[] data;
    data = tmp;
    tmp = nullptr;
    maxSize = 2 * maxSize;
}
template <typename Type>
void SeqList<Type>::inverse() // 逆置顺序表
{
    Type tmp;
    for (int i = 0; i < count / 2; i++)
    {
        tmp = data[i];
        data[i] = data[count - i - 1];
        data[count - i - 1] = tmp;
    }
}

//把B表合并到A表，如果A表和B表的元素递增有序排列，插入B表后A表还保持递增的次序
template <typename Type>
bool SeqList<Type>::Union(SeqList<Type> &B)
{
    int m, n, k, i, j;
    m = this->count;              // 当前对象为线性表A
    n = B.count;                  // m，n分别为线性表A和B的长度
    k = m + n - 1;                // k为结果线性表的工作指针（下标）
    i = m - 1, j = n - 1;         // i，j分别为线性表A和B的工作指针（下标）
    while (m + n > this->maxSize) // 空间不够，扩大表空间到够为止
    {
        resize();
    }
    //下面的操作就是排序
    while (i >= 0 && j >= 0) // 合并顺序表，直到一个表为空
    {
        if (data[i] >= B.data[j]) //如果A的元素大于B的元素时
        {
            data[k--] = data[i--]; // A表下标为k元素等于下标为i的元素
        }
        else
        {
            data[k--] = B.data[j--]; // 默认当前对象，this指针可省略
        }
    }
    while (j >= 0) // 将B表的剩余元素复制到A表
    {
        data[k--] = B.data[j--];
    }
    count = m + n; // 修改A表长度
    return true;
}

main.cpp

/**
 * @Author: lwj
 * @Date: 2022-05-28 13:04:14
 * @LastEditTime: 2022-05-28 13:04:14
 * @Description:测试顺序表
 * @FilePath: /Linux_C_C-plus-plus/数据结构（C++）/list/main.cpp
 **/
#include "seqList.h"
using namespace std;

void testSeqList()
{
    SeqList<int> s1;
    SeqList<int> s2;

    cout << "insert插入测试：" << endl;
    for (int i = 0; i < 10; i++)
    {
        s1.insert(i, i);
        s2.insert(i, 99);
    }
    s1.traverse();

    cout << "测试返回表大小函数size（）：" << s1.size() << endl;

    cout << "拷贝构造函数测试：" << endl;
    SeqList<int> s3(s1);
    s3.traverse();

    cout << "表满扩大容量函数resize():" << endl;
    cout << "未扩大表时的容量：" << s1.size() << endl;
    for (int i = 0; i < 10; i++)
    {
        if (s1.isFull())
        {
            s1.resize();
        }
        s1.insert(0, 88);
    }
    cout << "扩大表后容量为：" << s1.size() << endl;
    s1.traverse();

    cout << "测试删除元素函数remove()：" << endl;
    s1.remove(s1.size()); //删除最后一个元素
    s1.traverse();

    cout << "测试visit()功能：" << s1.visit(5) << endl;

    cout << "测试查找value元素功能：" << s1.search(4) << " "
         << s1.search(99) << endl;

    cout << "测试逆置功能：" << endl;
    s1.inverse();
    s1.traverse();

    cout << "测试s3表插入s2表：" << endl;
    s2.clear();
    for (int i = 0; i < 10; i++)
    {
        s2.insert(i, i+4);
    }
    s2.Union(s3);
    s2.traverse();
}
int main()
{
    testSeqList();
    return 0;
}

二、单链表

顺序栈是使用数组存储方式的栈

说明一个问题，链表可以没有头结点，不影响链表的基本功能，更细节问题请自行百度，而我下面的代码实现的链表都有头结点。

1.结构模型图

QQ拼音截图20220529180122

2.单链表的常用接口

功能描述：单链表容器常用的对外接口

构造函数：

  • LinkList(); //构造函数

数据存取：

  • push_front(); // “头插法”创建单
  • push_back(); // “尾插法”创建单链表

大小操作：

  • isEmpty(); //判断顺序表是否为空
  • size(); //返回栈的大小

插入删除：

  • remove(int i); //在线性表中，位序为i[0…n-1]的位置删除元素

  • insert(int i, const Type& value); //在第i个位置插入元素value

  • clear(); //清空

查找遍历：

  • visit(int i); // 在线性表中，查找位序为i的元素并返回其值

  • search(const Type& value); //查找值为value的元素第一次出现的位序

  • traverse(); //遍历

逆置：

* inverse(); // 逆置线性表

3.代码实现

linkList.h

/**
 * @Author: lwj
 * @Date: 2022-05-29 16:04:26
 * @Description:实现单链表
 * @FilePath: /Linux_C_C-plus-plus/数据结构（C++）/list/LinkList/LinkList.h
 **/
#pragma once
#include <iostream>
#include <assert.h>

template <typename Type>
class LinkList //单链表
{
private:
    //这里我用结构体来做结点，也可以在LinkList类外在创建一个类实现，
    //类实现的话用到友元类，有兴趣的可以自己实现一下
    struct Node
    {
    public:
        Type data;                                //数据域
        Node *next;                               //指针域
        Node(const Type value, Node *p = nullptr) //结构体Node的两个参数的构造函数
        {
            this->data = value;
            this->next = p;
        }
        Node(Node *p = nullptr) //一个参数的构造函数,用创建头结点之类的使用
        {
            this->next = p;
        }
    };
    Node *head;                  //头指针
    Node *tail;                  //尾指针
    int count;                   //元素个数
    Node *getIndex(int i) const; //返回指向第i个元素的指针

public:
    LinkList();                                          //构造函数
    ~LinkList();                                         //析构函数
    bool empty() const { return head->next == nullptr; } //判空
    void clear();                                        //清空单链表
    int size() const { return count; }                   //返回元素个数
    void insert(int i, const Type &value);               //在第i个位置插入value
    void remove(int i);                                  //删除第i个元素
    int search(const Type &value) const;                 //查找value第一次出现的下标
    void traverse() const;                               //遍历
    Type visit(int i) const;                             // 在线性表中，查找位序为i的元素并返回其值
    void push_front();                                   // “头插法”创建单链表
    void push_back();                                    // “尾插法”创建单链表
    void inverse();                                      // 逆置线性表

};

template <typename Type>
LinkList<Type>::LinkList() //构造函数
{
    head = tail = new Node(); //创建一个空表，只有头结点，如果不需要头结点的话直接head=tail=nullptr;
    this->count = 0;
}

template <typename Type>
LinkList<Type>::~LinkList() //析构函数
{
    clear();
    delete head;
}

template <typename Type>
void LinkList<Type>::clear() //清空单链表，clear()和~LinkList()在于，clear()保留头结点
{
    Node *p, *tmp;
    p = head->next; // head->next指向首元结点
    while (p != nullptr)
    {
        tmp = p;
        p = p->next;
        delete tmp;
    }
    head->next = nullptr;
    tail = head;
    count = 0;
}
//
template <typename Type>
typename LinkList<Type>::Node *LinkList<Type>::getIndex(int i) const //返回指向第i个元素的指针
{
    Node *p = head;
    if (i < -1 || i > this->count - 1)
        return nullptr;

    int num = 0;
    while (num <= i)
    {
        p = p->next;
        num++;
    }
    return p;
}

template <typename Type>
void LinkList<Type>::insert(int i, const Type &value) //在第i个位置插入value
{
    if (i < 0 || i > this->count) //能插入的位置i的范围[0~cout]
    {
        std::cout << "outOfRange!" << std::endl;
        return;
    }
    Node *p = this->getIndex(i - 1);    // p指向原来i结点的元素
    Node *q = new Node(value, p->next); // q指向新插入的元素
    p->next = q;                        // p->next指向新插入的元素
    if (p == tail)
    {
        tail = q;
    }
    this->count++;
}

template <typename Type>
void LinkList<Type>::remove(int i) //删除第i个元素
{
    Node *pre, *p;
    if (i < 0 || i > this->count - 1) //只有在[0~count-1]范围内有data
    {
        std::cout << "outOfRange!" << std::endl;
        return;
    }
    pre = this->getIndex(i - 1); //返回指向的结点的指针
    p = pre->next;
    if (p == tail) //当删除的是尾结点时，让倒数第二个结点成为尾结点，尾指针指向它
    {
        tail = pre;
        pre->next = nullptr;
        delete p;
    }
    else
    {
        pre->next = p->next;
        delete p;
        this->count--;
    }
}

template <typename Type>
int LinkList<Type>::search(const Type &value) const //查找value第一次出现的下标
{
    Node *p = head->next;
    int num = -1;
    while (p != nullptr && p->data != value)
    {
        p = p->next;
        num++;
    }
    if (p->next == nullptr)
    {
        return -1;
    }
    else
    {
        return num;
    }
}

template <typename Type>
void LinkList<Type>::traverse() const //遍历单链表
{
    Node *p = head->next;
    cout << "traverse：" << endl;
    while (p != nullptr)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

template <typename Type>
Type LinkList<Type>::visit(int i) const // 在线性表中，查找位序为i的元素并返回其值
{
    Node *p = head->next;
    int num = 0;
    if (i < 0 || i > this->count - 1)
    {
        std::cout << "outOfRange!" << std::endl;
        assert(1);
    }
    while (i > num)
    {
        p = p->next;
        num++;
    }
    return p->data;
}

template <typename Type>
void LinkList<Type>::push_front() // “头插法”创建单链表,从首元结点开始插入
{
    Node *p = nullptr;
    Type value, flag;
    cout << "请输入结束标志flag的值:";
    cin >> flag;
    while (cin >> value, value != flag)
    {
        // cin>>value;
        // if(value==flag)
        // {
        //     break;
        // }
        p = new Node(value, head->next);
        head->next = p;
        if (head == tail) //成立说明表为空，此时头指针和尾指针现在都指向头结点，
        {
            tail = p;
        }
        count++;
    }
}

template <typename Type>
void LinkList<Type>::push_back() //尾插法
{
    Node *p;
    int value, flag;
    cin >> flag;

    while (cin >> value, flag != value)
    {
        p = new Node(value, nullptr);
        tail->next = p;
        tail = p;
        count++;
    }
}
//逆置单链表思路，先用头指针和头结点构建一个空表，然后把其它结点反着插入空表，参考一下头插法
template <typename Type>
void LinkList<Type>::inverse() // 逆置线性表
{
    Node *p, *tmp;
    p = head->next;       // 工作指针p记录首元结点位置
    head->next = nullptr; //让头结点的next指向空，构成空表
    if (p)                //如果p为空，说明表为空
    {
        tail = p;
    }
    while (p) //不为空表时
    {
        tmp = p->next;        // 指向旧首元结点的后继（下一个）
        p->next = head->next; // p->next指向头结点的next指向的位置
        head->next = p;       // 然后头结点的next指向刚插入的结点
        p = tmp;              //工作指针p重新指向其它未插入结点的开始位置
    }
}

main.cpp

/**
 * @Author: lwj
 * @Date: 2022-05-29 16:04:33
 * @Description:测试单链表
 * @FilePath: /Linux_C_C-plus-plus/数据结构（C++）/list/linkList/main.cpp
 **/
#include <iostream>
using namespace std;
#include "linkList.h"

void testlinkList()
{
    LinkList<int> L1;
    LinkList<int> L2;

    cout << "插入测试：" << endl;
    for (int i = 0; i < 4; i++)
    {
        L1.insert(i, i);
        L2.insert(i, i);
    }

    // cout << "测试插入操作：" << endl;
    // L1.insert(2, 99);
    // L1.traverse();

    // cout << "测试判空和返回单链表大小：" << endl;
    // if (L1.empty())
    // {
    //     cout << "单链表为空！" << endl;
    // }
    // else
    // {
    //     cout << "单链表不为空,其大小为：" << L1.size() << endl;
    // }

    // cout << "测试删除功能：" << endl;
    // L1.remove(2);
    // L1.traverse();

    // cout << "测试查找位序为2的元素的值：" << endl;
    // L1.clear();
    // cout << L1.visit(2) << endl;

    // // cout << "头插法测试：" << endl;
    // // L1.push_front();
    // // L1.traverse();
    // cout << "测试逆置操作：" << endl;
    // L1.inverse();
    // L1.traverse();

    cout << "测试两个单链表合并操作：" << endl;
    L1.Union(&L2);
    L1.traverse();
    L2.traverse();
}

int main()
{

    testlinkList(); //单链表测试
    return 0;
}

三、双链表

1.结构模型图

QQ拼音截图20220529182025

2.双链表的常用接口

功能描述：双链表容器常用的对外接口

构造函数：

  • doubleLinkList(); //构造函数

数据存取：

  • push_front(); // “头插法”创建单
  • push_back(); // “尾插法”创建单链表

大小操作：

  • isEmpty(); //判断顺序表是否为空
  • size(); //返回栈的大小

插入删除：

  • remove(int i); //在线性表中，位序为i[0…n-1]的位置删除元素

  • insert(int i, const Type& value); //在第i个位置插入元素value

  • clear(); //清空

查找遍历：

  • visit(int i); // 在线性表中，查找位序为i的元素并返回其值

  • search(const Type& value); //查找值为value的元素第一次出现的位序

  • traverse(); //遍历

逆置：

  • inverse(); // 逆置线性表

3.代码实现

doubleLinkList.h

/**
 * @Author: lwj
 * @Date: 2022-05-30 23:42:24
 * @Description:实现双链表
 * @FilePath: /Linux_C_C-plus-plus/数据结构（C++）/list/dobleLinkList/DoubleLinkList.h
 **/
#pragma once
template <typename Type>
class DoubleLinkList
{
private:
    struct Node
    {
    public:
        Type data;   //数据域
        Node *next;  //指向后继结点
        Node *prior; //指向前继结点
        Node(Node *p, const Type &value, Node *n)
        {
            this->data = value;
            this->next = n;
            this->prior = p;
        }
        Node() : prior(NULL), next(NULL) {} //用列表初始化方法初始化
        ~Node() {}
    };
    Node *head, *tail;
    int count;
    Node *getIndex(int i) const; //返回第i元素的前驱
public:
    DoubleLinkList();                                 //构造函数
    ~DoubleLinkList();                                //析构函数
    bool empty() const { return head->next == tail; } //判空
    Type size() const { return count; }               //返回
    void clear();                                     //清空
    void insert(int i, const Type &value);            //在第i个位置插入元素value
    int search(const Type &value) const;              //在线性表中，查找值为value的元素第一次出现的位序
    void traverse() const;                            //遍历双链表
    Type visit(int i) const;                          // 在线性表中，查找位序为i的元素并返回其值
    void remove(int i);                               //在线性表中，位序为i[0..n-1]的位置删除元素
    virtual void inverse();                           // 逆置线性表
};

template <typename Type>
DoubleLinkList<Type>::DoubleLinkList() //构造函数
{
    //有两个头结点，头指针和尾指针处各有一个
    head = new Node; //头部头结点
    tail = new Node; //尾部头结点
    head->next = tail;
    tail->prior = head;
    count = 0;
}

template <typename Type>
void DoubleLinkList<Type>::clear() //清空
{
    Node *p = head->next;
    Node *tmp;
    head->next = tail;
    tail->prior = head;
    while (p != tail)
    {
        tmp = p->next;
        delete p;
        p = tmp;
    }
    count = 0;
}

template <typename Type>
DoubleLinkList<Type>::~DoubleLinkList() //析构函数
{
    clear();
    delete head;
    delete tail;
}

template <typename Type>
typename DoubleLinkList<Type>::Node *DoubleLinkList<Type>::getIndex(int i) const //返回指向第i个元素的指针
{
    Node *p = head;
    int m = 0;
    if (i < -1 || i > this->count)
    {
        return nullptr;
    }

    while (m <= i)
    {
        p = p->next;
        m++;
    }
    return p;
}

template <typename Type>
void DoubleLinkList<Type>::insert(int i, const Type &value)
{
    Node *p, *tmp;
    if (i < 0 || i > count) // 合法的插入位置为[0..n]
    {
        std::cout << "outOfRange!" << std::endl;
        return;
    }
    p = getIndex(i);                    // 若i==n则定位到tail指向的尾结点
    tmp = new Node(p->prior, value, p); // tmp插入到p之前
    p->prior->next = tmp;
    p->prior = tmp;
    ++count;
}

template <typename Type>
void DoubleLinkList<Type>::remove(int i) // 在线性表中，位序为i[0..n-1]的位置删除元素
{
    Node *p;
    if (i < 0 || i > count - 1)
    {
        std::cout << "outOfRange!" << std::endl;
        return;
    }

    p = getIndex(i);
    p->prior->next = p->next;  //将i结点的前继的next指向i结点的后继
    p->next->prior = p->prior; //将i结点的后继的prior指向i结点的前继
    delete p;                  //删除i结点
    --count;
}

template <typename Type>
void DoubleLinkList<Type>::traverse() const //遍历双链表
{
    Node *p;
    p = head->next;
    std::cout << "遍历双链表：";

    while (p != tail)
    {
        std::cout << p->data << " ";
        p = p->next;
    }
    std::cout << std::endl;
}
template <typename Type>
int DoubleLinkList<Type>::search(const Type &value) const //在线性表中，查找值为value的元素第一次出现的位序
{
    Node *p = head->next;
    int num = 0;
    while (num <= count - 1 && p != tail)
    {
        if (value == p->data)
        {
            return num;
        }
        p = p->next;
        ++num;
    }
}

template <typename Type>
Type DoubleLinkList<Type>::visit(int i) const // 在线性表中，查找位序为i的元素并返回其值
{
    if (i < 0 || i > this->count - 1)
    {
        std::cout << "outOfRange!" << std::endl;
        return -1; //找不到
    }

    Node *p = this->getIndex(i);
    return p->data;
}

template <typename Type>
void DoubleLinkList<Type>::inverse() // 逆置线性表
{
    Node *p = head->next;
    Node *tmp;
    head->next = tail;
    tail->prior = head;
    while (p != tail)
    {
        tmp = p->next;
        p->next = head->next;
        p->prior = head;
        head->next->prior = p;
        head->next = p;
        p = tmp;
    }
}

main.cpp

/**
 * @Author: lwj
 * @Date: 2022-05-30 23:47:19
 * @Description:测试双链表功能
 * @FilePath: /Linux_C_C-plus-plus/数据结构（C++）/list/dobleLinkList/main.cpp
 **/

#include <iostream>
#include "doubleLinkList.h"
using namespace std;
void DoubleLinkList_test()
{
    DoubleLinkList<int> d1;

    for (int i = 0; i < 4; i++)
    {
        d1.insert(i, i);
    }
    cout << "判空和返回大小测试：" << endl;
    if (d1.empty())
    {
        cout << "双链表为空！" << endl;
    }
    else
    {
        cout << d1.size() << endl;
    }
    d1.traverse();

    cout << "删除函数remove()的测试：" << endl;
    d1.remove(0);
    d1.remove(3);
    d1.traverse();

    cout << "search()函数的测试：" << endl;
    cout << "元素3第一次出现的位序为：" << d1.search(3) << endl;

    // cout << "测试逆置功能：" << endl;
    // d1.inverse();
    // d1.traverse();
}
int main()
{
    DoubleLinkList_test(); //双链表测试
    return 0;
}

四、总结

1.数组

所申请的内存空间，必须是线性连续，且申请的空间大小必须提前确定。

插入和删除操作代价比较大，需要该位置后面的数据都向后移动，留出一个空位进行插入，或者都向前移动，把该空位的数据进行覆盖（也就是删除）；

查询代价较小，数组是连续存储的，知道该数组名称，可根据下标直接查询；

不利于扩展，数组空间是提前申请的，当存储空间不够时，需要重新申请空间。

2. 链表

申请内存中存储空间，不要求连续，只需要保存下一个存储空间的内存地址即可。

插入和删除操作比较容易，只需要改变指针的指向即可；

查询代价较大，不具备随机访问能力，需要从头到尾遍历查找；

扩展性较好，不用提前指定大小，插入删除比较随意。

千里狼～
关注
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
数据结构与算法 图
我的学习笔记分享
01-02 603
一、定义 图是一种比较常用的数据结构，有许多定义需要理解，下面一一介绍。 图：G = (V, E) Graph = (Vertex, Edge) V : 顶点（数据元素）的有穷非空集合； ...
数据结构与算法 排序算法(一) 附有详细动画流程分析图
高级开发者进阶ing... QaQ
05-29 1476
数据结构与算法 排序算法(一) Tips: 采用java语言, 关注博主,底部附有完整代码, 本篇介绍排序算法: 冒泡排序 选择排序 插入排序 基数排序 排序算法对比 算法名称 10万次测试 效果图 冒泡排序 10万次 / 20秒 选择排序 10万次 / 3秒 插入排序 10万次 / 800毫秒 基数排序 10万次 / 22毫秒 冒泡排序 冒泡排序应该是最常见,最简单的排序算法了! 要想学会冒泡排序,只需要记住 2 个重点 找出最大值 交换位置 即可 找
数据结构——线性表
odoaobo的博客
08-31 2051
线性表的顺序储存又称顺序表概念：用一组地址连续的存储单元依次存储线性表中的数据元素的线性表。特点：表中的元素逻辑顺序和物理顺序相同。1. 静态顺序表：使用定长数组存储元素。//定长数组//有效数据个数}SeqList2. 动态顺序表：使用动态开辟的数组存储。//指向开辟空间的数组int size;//有效数据的个数//容量空间的大小}SL;线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。链表的节点处理存储元素自身的信息外，还需要存放一个后继的指针。
数据结构线性表基本操作
lizhi20210729的博客
11-20 1万+
数据结构线性表基本操作基本内容线性表的顺序表示和实现线性表的顺序存储表示顺序表中基本操作的实现 基本内容 因为第一次数据结构阶段考写代码又想规范写又写不出规范的可读性强的代码，让我第一次意识到自己应该在这方面下一些功夫。这篇文章是记录自己把书上写的算法打到电脑上遇到的问题。 线性表的顺序表示和实现 线性表的顺序存储表示 将书中代码复刻如下： #define MAXSIZE 100//顺序表可能达到的最大长度 typedef struct { ElemType *elem;//储存空间的基地址
【华为OD机试 2023】 最多获得的短信条数/云短信平台优惠活动（C++ Java JavaScript Python）
m0_57042151的博客
08-15 1781
版权声明：本文为CSDN博主「算法大师」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。Pi为充值 i 元获得的短信条数。第二行给出售价表， P1, P2, …Pn , 其中 1 ≤ n ≤ 100 ,现在给出客户预算，和优惠售价序列，求最多可获得的短信总条数。第一行客户预算M，其中 0 ≤ M ≤ 10^6。某云短信厂商，为庆祝国庆，推出充值优惠活动。
数据结构与算法-顺序表
olunano的博客
01-27 336
文章目录2.顺序表2.1顺序表的基本形式 2.顺序表   在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。   对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。   这样的一组序列元素的组织形式，我们可以将其抽象为线性表。一个线性表是某类元素的一个集合，还记录着元素之
数据结构-线性表的链式存储
09-17
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。在实际应用中，线性表的数据元素可以是数字、字符串、对象等各种类型。线性表的链式存储是数据结构课程中的核心概念...
2.C-数据结构-线性表-线性表源码
最新发布
09-07
2.C-数据结构-线性表-线性表源码
2.C-数据结构-线性表-链表源码
09-07
2.C-数据结构-线性表-顺序表源码
数据结构-线性表的基本使用
10-26
线性表是数据结构中的基础概念，它是一种最简单但非常重要的数据组织形式。线性表是由n（n>=0）个相同类型元素构成的有限序列，这些元素在逻辑上是顺序排列的，可以通过索引访问。在计算机科学中，理解和掌握线性表...
数据结构 —— 顺序表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-04 4175
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
数据结构与算法 排序算法(二) 附有详细动画流程分析图!!
高级开发者进阶ing... QaQ
06-01 793
上一篇本篇介绍排序算法:重点:倒叙输出结果 (根据步长来倒叙)交换默认之前的数 始终是有序的始终和前面的数相比较原理:假设现在有10个数据,依次隔 length / 2次来排序第一次排序 隔5个元素来排序 (10 / 2 = 5)第二次排序 隔2个元素来排序(5 / 2 = 2)第三次排序 隔1个元素来排序(2 / 2 = 1)这样一来,就能将相邻的数字替换到大致位置, 减少了交换的次数效果图:交换和上一篇中的冒泡排序交换一样这段代码稍微有点复杂,多看几次就懂了!!这段代码懂了,在看希尔排序代码就十分清晰了
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
【数据结构 —— 线性表方法总结】
Dreamer2176的博客
11-24 224
遍历对比（可以使用上面的查询函数，也可以直接遍历）的位置是不是链表的最后一个位置（是则满不是则空）检查需要插入的位置是否合理（是否超出范围）是否小于0会长是否大于链表的最大长度。链表的角标从0开始算，因此此处的。始终处于最后一个，因此只需要验证。判断线性表是否为满（full）新建一个变量来接受验证是否相同。时该表任然为空，反之不为空。移动元素、更新last位置。判断该线性表是否为空表。定义数组中N为128。为链表的最后一个角标。的值还未发生改变，即。通过遍历查找对应的值。判断链表是否创建成功。
学习笔记-数据结构-线性表（2024-04-21）
XuJiaKai的博客
04-22 355
假设有两个元素值递增有序的线性表La和Lb，均以带头节点的单链表作为存储结构，编写算法将La表和Lb表合并为一个按元素值递减有序排列的线性表Lc，并要求利用原表（La和Lb表）的节点空间存放表Lc。: 在算法执行过程中，pa是一个遍历指针，用于顺序访问La链表中的节点。: 指向第二个有序单链表的头节点，该链表中的元素同样按递增顺序排列。: 指向第一个有序单链表的头节点，该链表中的元素按递增顺序排列。: 指向结果单链表的头节点，合并后的链表将按元素值递减有序排列。
线性表详细讲述（带图）
m0_64413166的博客
11-18 2990
线性表，有手就可以学废
数据结构: 顺序表和单链表的基本运算实现
m0_46669582的博客
10-28 4570
实验题1-1：实现并验证顺序表的各种基本操作 目的：领会顺序表存储结构和掌握顺序表中的各种基本运算算法设计。 内容： 1.首先，创建文件sqlist.h。 a)定义顺序表的结构体类型； b)定义并实现顺序表的基本运算（详见线性表ADT描述）。 2.然后，创建文件exp1-1.c，引用（#include）头文件sqlist.h，依次完成以下内容，对第一步中实现的顺序表进行测试。 （1）初始化顺序表L； （2）采用尾插法依次插入元素a，b，c，d，e； （3）输出顺序表L； （4）输出顺序表L的长度； （5）判
数据结构与算法 - 线性表
weixin_34038293的博客
12-19 317
这里我们只介绍线性表中 存储结构不同的 顺序表 和 链表，以及操作受限的 栈 和 队列 。 数据结构与算法系列文章 数据结构与算法 - 时间复杂度 数据结构与算法 - 线性表 目录 一、 概述 二、顺序表 2.1、 插入元素 2.2、 删除元素 2.3、 特点 三、链表 3.1、线性链表(单链表) 3.1.1、插入元素 3.1.2、删除元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

千里狼～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值