实验3 链表的基本操作

最新推荐文章于 2022-12-06 15:56:16 发布
最新推荐文章于 2022-12-06 15:56:16 发布
阅读量214 收藏
点赞数
分类专栏： 数据结构学习笔记 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40772639/article/details/109144560
版权

头文件

//
// Created by 23518 on 2020/10/25.
//

#ifndef TEST_EXPRIMENT3_MYLIST_H
#define TEST_EXPRIMENT3_MYLIST_H

#include <iostream>

using namespace std;

template<typename T = int>
class MyList {
private:
    struct Node {
        T data;
        Node* prior = nullptr;
        Node* next = nullptr;
    };
    Node LNode;
    Node* front = &LNode;
    Node* rear = &LNode;

    int size_ = 0;
public:
    MyList() = default;

    MyList(const MyList<T>&);

    MyList(const MyList<T>&&) = delete;

    MyList& operator=(const MyList&);

    MyList& operator=(const MyList&&) = delete;

    ~MyList();

    T operator[](int index) const noexcept(false);

    T& operator[](int index) noexcept(false);

    void clear();

    [[maybe_unused]] [[nodiscard]] bool isEmpty() const;

    [[nodiscard]] int size() const;

    int index(T) noexcept;

    T priorElem(T) noexcept(false);

    T nextElem(T) noexcept(false);

    void add(T) noexcept;

    void addAsPre(T) noexcept;

    void mylistInsert(int index, T t) noexcept(false);

    void mylistDelete(int index) noexcept(false);
};

template<typename T>
MyList<T>::MyList(const MyList<T>& li) : MyList() {
    size_ = li.size_;
    Node* p = li.LNode.next;
    Node* tmp = LNode;
    while (p) {
        Node* node = new Node;
        tmp->next = node;
        node->data = p->data;
        node->prior = tmp;
        tmp = node;
        p = p->next;
    }
    rear = tmp;
}

template<typename T>
MyList<T>& MyList<T>::operator=(const MyList& li) {
    if (this == &li)
        return *this;
    clear();
    size_ = li.size_;
    Node* p = li.LNode.next;
    Node* tmp = LNode;
    while (p) {
        Node* node = new Node;
        tmp->next = node;
        node->data = p->data;
        node->prior = tmp;
        tmp = node;
        p = p->next;
    }
    rear = tmp;
    return *this;
}

template<typename T>
MyList<T>::~MyList() {
    clear();
}

template<typename T>
T MyList<T>::operator[](int index) const noexcept(false) {
    if (index < 0 || index > size_ - 1)
        throw out_of_range("The index is illegal!");
    Node* p = LNode.next;
    int i = 0;
    while (i != index) {
        p = p->next;
        i++;
    }
    return p->data;
}

template<typename T>
T& MyList<T>::operator[](int index) noexcept(false) {
    if (index < 0 || index > size_ - 1)
        throw out_of_range("The index is illegal!");
    Node* p = LNode.next;
    int i = 0;
    while (i != index) {
        p = p->next;
        i++;
    }
    return p->data;
}

template<typename T>
void MyList<T>::clear() {
    Node* p = LNode.next;
    while (p) {
        Node* tmp = p->next;
        delete p;
        p = tmp;
    }
    LNode.next = nullptr;
    size_ = 0;
    rear = front;
}

template<typename T>
[[maybe_unused]] bool MyList<T>::isEmpty() const {
    return front == rear;
}

template<typename T>
int MyList<T>::size() const {
    return size_;
}

template<typename T>
int MyList<T>::index(T t) noexcept {
    Node* p = LNode.next;
    int i = 0;
    while (p) {
        if (p->data == t)
            return i;
        i++;
        p = p->next;
    }
    return -1;
}

template<typename T>
T MyList<T>::priorElem(T t) noexcept(false) {
    Node* p = LNode.next;
    if (p && p->data == t)
        throw logic_error("该元素在第一位，没有前驱！");
    if (p)
        p = p->next;
    while (p) {
        if (p->data == t)
            return p->prior->data;
        p = p->next;
    }
    throw logic_error("没有该元素！");
}

template<typename T>
T MyList<T>::nextElem(T t) noexcept(false) {
    Node* p = LNode.next;
    while (p) {
        if (p->data == t) {
            if (p->next)
                return p->next->data;
            throw invalid_argument("该元素在最后，没有后继！");
        }
        p = p->next;
    }
    throw invalid_argument("该元素没有后继！");
}

template<typename T>
void MyList<T>::add(T t) noexcept {
    size_++;
    Node* node = new Node;
    node->data = t;
    node->prior = rear;
    rear->next = node;
    rear = node;
}

template<typename T>
void MyList<T>::mylistInsert(int index, T t) noexcept(false) {
    if (index < 0 || index > size_ - 1)
        throw domain_error("位置不正确，插入失败！");
    ++size_;
    Node* p = LNode.next;
    int i = 0;
    while (i != index) {
        p = p->next;
        i++;
    }
    Node* node = new Node;
    node->data = t;
    node->next = p;
    node->prior = p->prior;
    p->prior->next = node;
    p->prior = node;
}

template<typename T>
void MyList<T>::mylistDelete(int index) noexcept(false) {

    if (index < 0 || index > size_ - 1)
        throw out_of_range("位置不正确，删除失败！");
    --size_;
    Node* p = LNode.next;
    int i = 0;
    while (i != index) {
        p = p->next;
        i++;
    }
    p->prior->next = p->next;
    if (!p->next)
        rear = p;
    else
        p->next->prior = p->prior;
    delete p;
}

template<typename T>
void MyList<T>::addAsPre(T t) noexcept {
    Node* node = new Node;
    size_++;
    node->data = t;
    node->prior = front;
    if (size_ == 1)
    {
        node->next = nullptr;
        front->next = node;
        rear = node;
        return;
    }
    node->next = front->next;
    front->next->prior = node;
    front->next = node;
}


#endif //TEST_EXPRIMENT3_MYLIST_H

主程序文件

#include <iostream>
#include<memory>
#include "MyList.h"

using namespace std;

template<typename T>
class MyList;

shared_ptr<MyList<int>> p;

void show_menu();

int main() noexcept {
    show_menu();
    int opt;
    while (true) {
        cout << "请输入你的选择：";
        cin >> opt;
        switch (opt) {
        case 1: {
            if (!p)
                p = make_shared<MyList<int>>();
            else
                p->clear();
            cout << "链表已初始化或重置成功！\n";
            break;
        }
        case 2: {
            if (!p)
                cout << "未初始化链表或链表已被销毁。\n";
            else {
                p.reset();
                cout << "链表销毁成功！\n";
            }
            break;
        }
        case 3: {
            if (!p)
                cout << "未初始化链表或链表已被销毁。\n";
            else {
                p->clear();
                cout << "链表清空成功！\n";
            }
            break;
        }
        case 4: {
            if (!p)
                cout << "请先初始化一个链表！\n";
            else
                cout << "链表长度为" << p->size() << endl;
            break;
        }
        case 5: {
            if (!p)
                cout << "请先初始化一个链表！\n";
            else {
                while (true) {
                    try {
                        cout << "请输入位序：";
                        int i = 0;
                        cin >> i;
                        printf_s("位序%d上的元素是%d\n", i, p->operator[](i));
                        break;
                    }
                    catch (const exception& e) {
                        cout << e.what();
                        cout << "\n请重新输入位序！\n";
                    }
                }
            }
            break;
        }
        case 6: {
            if (!p)
                cout << "请先初始化一个链表！\n";
            else {
                cout << "请输入元素：";
                int n = 0;
                cin >> n;
                int index = p->index(n);
                if (index == -1)
                    cout << "不存在元素" << n << endl;
                else
                    printf_s("元素%d的位序是%d\n", n, index);
            }
            break;
        }
        case 7: {
            if (!p)
                cout << "请先初始化一个链表！\n";
            else {
                while (true) {
                    try {
                        cout << "请输入元素：";
                        int n = 0;
                        cin >> n;
                        printf_s("元素%d的前驱是%d\n", n, p->priorElem(n));
                        break;
                    }
                    catch (const exception& e) {
                        cout << e.what();
                        cout << "请重新输入\n";
                    }
                }
            }
            break;
        }
        case 8: {
            if (!p)
                cout << "请先初始化一个链表！\n";
            else {
                while (true) {
                    try {
                        cout << "请输入元素：";
                        int n = 0;
                        cin >> n;
                        printf_s("元素%d的后继是%d\n", n, p->nextElem(n));
                        break;
                    }
                    catch (const exception& e) {
                        cout << e.what();
                        cout << "请重新输入\n";
                    }
                }
            }
            break;
        }
        case 9: {
            if (!p)
                cout << "请先初始化一个链表！\n";
            else {
                try {
                    cout << "请输入位置：";
                    int index = 0;
                    cin >> index;
                    cout << "请输入元素：";
                    int n = 0;
                    cin >> n;
                    p->mylistInsert(index, n);
                    cout << "插入成功！\n";
                }
                catch (const exception& e) {
                    cout << e.what() << endl;
                }
            }
            break;
        }
        case 10: {
            if (!p)
                cout << "请先初始化一个链表！\n";
            else {
                try {
                    cout << "请输入位置：";
                    int index = 0;
                    cin >> index;
                    p->mylistDelete(index);
                    cout << "删除成功！\n";
                }
                catch (const exception& e) {
                    cout << e.what();
                }
            }
            break;
        }
        case 11: {
            if (!p)
                cout << "请先初始化一个链表！\n";
            else {
                cout << "该链表的元素有：";
                for (int i = 0; i < p->size(); ++i)
                    cout << p->operator[](i) << " ";
                cout << endl;
            }
            break;
        }
        case 12: {
            if (!p) {
                p = make_shared<MyList<>>();
                cout << "链表初始化成功，";
            }
            else {
                p->clear();
                cout << "已经清空已初始化的链表，";
            }
            cout << "请选择插入方式：1. 头插法 2. 尾插法" << endl;
            int selection = 0;
            while (selection != 1 && selection != 2) {
                cout << "请输入1或2：";
                cin >> selection;
            }

            cout << "请输入元素(以空格分隔，任意字母结尾，示例：1 2 3 4 5 6 q[ENTER])：";
            int n = 0;
            if (selection == 2)
                while (cin >> n) p->add(n);
            else
                while (cin >> n) p->addAsPre(n);
            cin.clear();
            cin.sync();
            while (cin.peek() != '\n') cin.get();
            cout << "元素添加成功！\n";
            break;
        }
        case 13: {
            if (!p)
                cout << "请先初始化一个链表！";
            else {
                for (int i = 0; i < p->size() / 2; ++i) {
                    int tmp = p->operator[](i);
                    p->operator[](i) = p->operator[](p->size() - 1 - i);
                    p->operator[](p->size() - 1 - i) = tmp;
                }
                cout << "单链表的逆序存放已完成" << endl;
            }
            break;
        }
        case 14:
            system("cls");
            show_menu();
            break;
        default:
            cout << "请输入1-12以内的数！\n";
        }
        cout << endl << endl;
    }
}

void show_menu() {
    std::cout << "可执行的操作有：" << endl;
    cout << "************************************************************\n"
        << "************   1.初始化或重置链表                   ***********\n"
        << "************   2.销毁链表                         ***********\n"
        << "************   3.清空链表                         ***********\n"
        << "************   4.链表长度                         ***********\n"
        << "************   5.指定位置的元素值                   ***********\n"
        << "************   6.链表已存在元素的位序                ***********\n"
        << "************   7.求输入元素的直接前驱                ***********\n"
        << "************   8.求输入元素的直接后继                ***********\n"
        << "************   9.在第i个位置插入一个元素             ***********\n"
        << "************   10.删除第i个元素                    ***********\n"
        << "************   11.输出所有的链表元素                  ***********\n"
        << "************   12.初始化并用头插法（或尾插法）输入元素  ***********\n"
        << "************   13.实现单链表的逆序存放               ***********\n"
        << "************   14.清屏                             ***********\n"
        << "************************************************************\n";
}
遇水叠桥
关注
专栏目录
数据结构 实验二 链表的基本操作
TXYGoodluck的博客
09-25 9116
链表的基本操作 任务一：单链表的生成和输出 任务描述： 从键盘输入数据，创建一个初始链表。通过调用定义的基本操作函数来实现单链表上的插入、删除元素等操作。调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果。加深对有关算法的理解。 相关知识： 为了完成本关任务，你需要掌握： 1.尾插法建立单链表 2.单链表的遍历（输出） - 尾插法建立单链表 本关任务：尾插法是通过将新结点逐个插入到链表的尾部来创建链表。同前插法一样,每次申请一个新结点,读入相应的数据元素值。不同的是,为了使新结点能够插入
实验三：单链表及其操作
jingz_courses的博客
09-14 944
一、实验内容 1.   通过C语言结构体定义链表结点 2.   定义并实现创建空链表操作 3.   定义并实现向链表指定位置插入结点操作 4.   定义并实现从链表指定位置删除结点操作 二、实验步骤 1.   在VC++中创建名为LinkList的空项目，并将commons.h文件添加到头文件目录中 2.   在工程的头文件目录
数据结构 单链表的基本操作实现代码
wu____nai的博客
10-30 1797
实验3、单链表的基本操作实现 （1）实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验3对比，掌握线性结构两种不同存储方式的区别。 （2）实验内容 编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要分别能够测试第一个元素的前驱、其他正常的元素的前驱、输入一个在表中不存在的元素求其前驱，这三种情况应给出相应的提示
链表的操作实验
夏日漱石的博客
05-12 1525
单链表
数据结构实验3---单链表的基本操作实现
qq_62474991的博客
12-06 504
重点： 链表的定义和实现 难点： 单链表的逆序存放
数据结构学习三：链表（基本操作）
欢迎来到小骆的空间
04-01 514
前提： 链表 线性链式存储的特点： 动态存储分配 结点总不顺序存放(与可变长数组的差别) 基本概念 结点(Node) 一个链表由若干个结点组成 每个结点包含两个域：数据域和指针域 数据域：存放数据 指针域：用于存放指向该链表的下一个结点的指针 单链表： 它指通过一组任意的存储单元来存储线性表中的数据元素。 头结点： 在链表的第一个结点之前附加一个结点(不算在数组索引中，数据域为空，指...
[实验二] 单链表的基本操作
哦绝影
03-22 4050
一、 实验目的 1、掌握线性表的逻辑结构 2、熟练掌握线性表的链式存储结构定义及基本操作 3、理解循环链表和双链表的特点和基本运算 4、加深对链式存储数据结构的理解，逐步培养解决实际问题的编程能力 二、 实验结果 1、演示程序运行结果 2、分析调试过程中出现的现象 3、总结单链表基本操作的特点 4、分析算法的时间复杂度 三、 实验收获 1、掌握单链表的定义及基本操作 2、掌
实验二 链表基本操作的实现
12-18
在这个实验“链表基本操作的实现”中，我们将深入理解链表的概念，学习如何创建、插入、删除节点，以及进行其他基本操作。 链表不同于数组，它不连续存储元素，而是通过节点间的指针链接。每个节点包含两部分：数据...
数据结构实验代码链表的基本操作.rar
05-01
这个"数据结构实验代码链表的基本操作.rar"文件包含了关于链表操作的实践代码，这将有助于我们深入理解链表的工作原理。 链表分为单链表、双链表和循环链表等类型，其中单链表是最基础的形式。单链表的每个节点包含...
实验二链表的基本操作.doc
10-06
链表的基本操作实验报告 本实验报告主要介绍了链表的基本操作，包括链表的创建、插入、删除和查找等操作。实验使用 Visual C++ 6.0 编程语言，实现了链表的基本操作，并对链表的数据元素进行了读取、写入和删除等...
实验二：链表的基本操作的实验报告
12-04
源代码： #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define flag 0 typedef int ElemType; typedef struct linkList { ElemType data; struct linkList *next; }LinkList; #include #include //#include //#include "linkList.h" void init_LinkList(LinkList *head)
链表基本操作实验报告.doc
10-12
链表基本操作实验报告 链表是一种基本的数据结构，它广泛应用于计算机科学和软件开发领域。链表的基本操作包括链表的创立、输出、插入、删除、查找等。本实验报告的主要目的是通过实验和编程实践，掌握链表的基本...
单链表的基本操作及其应用(实验2.1)
weixin_40105282的博客
10-11 853
一．实验目的  巩固单链表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二. 实验内容  建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。用单链表来实现，分别输出结果。  为了以后的对代码的修改、优化和复用，这里采用了C++中的模板来实现，下面是模板的实现。 #
实验三 链表的实现和应用（第4-5周）
我要吃木耳的博客
10-17 397
实验目的： 掌握线性表的链式存储结构设计与基本操作的实现。 实验内容与要求： ⑴定义线性表的链式存储表示； ⑵基于所设计的存储结构实现线性表的基本操作； ⑶编写一个主程序对所实现的线性表进行测试； ⑷线性表的应用：①设线性表L1和L2分别代表集合A和B，试设计算法求A和B的并集C，并用线性表L3代表集合C（无重复元素）；②设线性表L1和L2中的数据元素为整数，且均已按值非递减有序排列，试设计算法对L1和L2进行合并，用线性表L3保存合并结果（无重复元素），要求L3中的数据元素...
单链表操作（数据结构实验一）
ACway的专栏
09-25 4971
实验内容 1 初始化一个带表头结点的单链表。 2 从表头不断插入结点建立一个带表头结点的单链表。设表中元素的类型为整型，元素值从键盘输入。 3 从表尾不断插入结点建立一个带表头结点的单链表。设表中元素的类型为整型，元素值从键盘输入。 4 打印一个带表头结点的单链表。 5 清空一个带表头结点的单链表。 代码：（只是把各个函数写好，并给出了调用数据，其他根据实验要求改就行了）
数据结构实验二：链表的综合操作
qq_45158661的博客
04-06 1691
一、实验目的 1．掌握线性表链式存储方式的特点； 2．掌握线性表的链式存储基本操作，如建立、查找、插入和删除等。 二、实验内容 定义一个包含学生信息（学号，姓名，性别，年龄）的链表，使其具有如下 功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学生信息； (4) 根据指定的位置可返回相应的学生信息； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记
线性链表(单链表)的基本操作的实现
xdznb_的博客
01-10 290
#include<iostream> #include<cstdlib> using namespace std; //结点结构体 struct Node { int a; struct Node *pNext; }; //链表头尾指针 struct Node *g_pHead = NULL; struct Node *g_pEnd = NULL; //创建链表，在链表...
基于大模型技术的算力产业监测服务平台设计
最新发布
09-17
内容概要：本文提出了一种新型算力产业监测服务平台的设计理念，运用国内自主研发的大模型技术支持，通过对传统技术的改进和完善，提出了三层架构的设计方法，即基础设施层（含向量数据库和模型训练）、大模型应用框架层（强化数据处理与多维关系挖掘）及业务层（如智能分析助手）。这种设计方案旨在提高算力产业发展监测与决策制定的质量。 适合人群：电信行业的从业人员及研究人员；算力产业链各环节管理者；政府相关机构和政策决策者。 使用场景及目标：在多种算力相关的应用场景（如云计算中心管理，数据中心监测，政策分析）中辅助决策者进行快速有效的信息获取和技术选择；助力算力产业发展方向的精确把控和战略调整。 其他说明：随着大模型技术的日臻成熟，该算力产业监测服务平台预计将进一步丰富自身的应用领域和服务深度，以促进算力行业更智慧化发展。
实现链表的基本操作实验设计思路
06-12
实现链表的基本操作实验需要进行以下步骤： 1. 定义链表节点结构体：链表节点包含一个数据域和一个指向下一个节点的指针域。 2. 定义链表结构体：链表结构体包含一个指向链表头节点的指针域和链表长度。 3. 初始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值