精华内容
下载资源
问答
  • 单链表 C++

    2018-10-28 03:01:42
    单链表 C++ 题目 1、创建单链表2、初始化单链表3、释放单链表4、获取单链表中元素的数量5、输出单链表中的所有数据6、获取单链表中指定位置的元素7、根据键值查找指定元素8、采用头插法向单链表中插入一个元素9、...
        

    单链表 C++

    题目

    1、创建单链表
    2、初始化单链表
    3、释放单链表
    4、获取单链表中元素的数量
    5、输出单链表中的所有数据
    6、获取单链表中指定位置的元素
    7、根据键值查找指定元素
    8、采用头插法向单链表中插入一个元素
    9、采用尾插法向单链表中插入一个元素
    10、向单链表中的指定位置插入一个元素
    11、删除指定位置的元素

    设计类图

    文件结构

    效果

    store.h

    #pragma once
    // store.h 储存的结构体
    #include "typeRedefinition.h"
    #define Node_Length 20
    
    /*储存基本的储存结构*/
    class Elemtype {
    private:
        string num;    // 学号
        string name;    // 姓名
        int age;    // 年龄
        string major;    // 专业
        int regissterYear;    // 入学年份
    public:
        int setNum(string num);
        string getNum();
        int setName(string name);
        string getName();
        int setAge(int age);
        int getAge();
        int setMajor(string major);
        string getMajor();
        int setRegissterYear(int regissterYear);
        int getRegissterYear();
    };
    
    /*节点*/
    class Node: public Elemtype{
    public:
        Node* next = NULL;
        Node();
    };
    

    store.cpp

    // store.cpp
    #include "pch.h"
    #include "store.h"
    
    /*构造函数*/
    Node::Node(){
        this->next = NULL;
        Elemtype::setAge(0);
        Elemtype::setMajor("NULL");
        Elemtype::setName("NULL");
        Elemtype::setNum("NULL");
        Elemtype::setRegissterYear(0);
    }
    
    /*学号*/
    int Elemtype::setNum(string num)
    {
        this->num = num;
        return 0;
    }
    
    string Elemtype::getNum(){
        return this->num;
    }
    
    /*姓名*/
    int Elemtype::setName(string name)
    {
        this->name = name;
        return 0;
    }
    
    string Elemtype::getName()
    {
        return this->name;
    }
    
    /*年龄*/
    int Elemtype::setAge(int age)
    {
        this->age = age;
        return 0;
    }
    
    int Elemtype::getAge()
    {
        return this->age;
    }
    
    /*专业*/
    int Elemtype::setMajor(string major)
    {
        this->major = major;
        return 0;
    }
    
    string Elemtype::getMajor()
    {
        return this->major;
    }
    
    /*入学年份*/
    int Elemtype::setRegissterYear(int regissterYear)
    {
        this->regissterYear = regissterYear;
        return 0;
    }
    
    int Elemtype::getRegissterYear()
    {
        return this->regissterYear;
    }

    typeRedefinition.h

    #pragma once
    // typeRedefinition.h   
    #include <string>
    using namespace std;
    
    //typedef struct Elemtype elemtype;    
    //typedef struct Elemtype*  p_Elemtype;    // 基本的储存
    //typedef Node* p_Node;    // 储存的方式
    typedef string* p_string;    // string 指针

    method.cpp

    // method.cpp 单链表
    #include "pch.h"
    #include "method.h"
    
    /*构造函数*/
    list::list() {
        this->createList();
    }
    
    /*析构函数*/
    list::~list() {
        this->destroyList();
    }
    
    /*创建链表*/
    int list::createList() {
        Node* head = new Node();    // 创建头节点
        this->head = head;
        try {
            if (head == NULL) {
                exit(-2);
            }
        }catch (const string msg) {
            this->error = msg;
            return -1;
        }
    
        // 维护线性表长度
        this->length = 0;
    
        return 0;
    }
    
    /*获得链表长度*/
    int list::getLength()
    {
        Node* p;
        int i = 0;    // 头节点为0 依次不断递增,第一个存储有内容的节点为1
        
        // 处理0节点的问题
        if (this->length == 0)
            return 0;
        
        p = this->head->next;
    
        while (p != NULL) {
            i++;
            p = p->next;
        }
    
        try {
            if (i != this->length) {
                exit(-3);
            }
        }catch (const string msg) {
            this->error = msg;
            this->length = 0;
            return 0;
        }
    
        return this->length;
    }
    
    /*获得链表*/
    // 将获取的线性表的结果保存在result字符串中
    list* list::getList() {
        Node* p;
        if (this->length == 0)
            return 0;
    
        p = this->head->next;    // 指向第一个拥有数据的节点
    
        for (int index = 1; index <= this->getLength(); index++) {
            // 由于第一个节点为空节点,所以index的初值为1
            /*输出节点序号*/
            this->result += "\n节点序号\t" + to_string(index) + "\n";
            this->result += "输出学号\t" + p->getNum() + "\n";
            /*输出姓名*/
            this->result += "输出姓名\t" + p->getName() + "\n";
            /*输出年龄*/
            this->result += "输出年龄\t" + to_string(p->getAge()) + "\n";
            /*输出专业*/
            this->result += "输出专业\t" + p->getMajor() + "\n";
            /*输出入学年份*/
            this->result += "入学年份\t" + to_string(p->getRegissterYear()) + "\n";
            /*指向下一个节点*/
            p = p->next;
            this->result += "------------------------------------------------";
        }
        return this;
    }
    
    /*输出result*/
    string list::toString()
    {
        return this->result;
    }
    /*设置result字符串*/
    list* list::setString(string& msg)
    {
        this->result = msg;
        return this;
    }
    
    
    /*输出error*/
    string list::toError()
    {
        return this->error;
    }
    
    /*头插法插入元素*/
    list* list::insertElem_Head(Node& node){
        Node* p = NULL;
        p = this->head->next;
        node.next = p;
        this->head->next = &node;
        this->head->next;
        (this->length)++;    // 长度维护
    
        return this;
    }
    
    /*尾插法,插入元素*/
    list* list::insertElem_Foot(Node& node){
        Node* p = this->head;    // 指向头结点
        for (int i = 1; i <= this->length; i++) {
            p = p->next;
        }
        // 进行插入
        p->next = &node;    // 设置指向
        p = p->next;    // 指针移动
        p->next = NULL;    // 设置空值
        (this->length)++;
    
        return this;
    }
    
    /*根据键值查找指定节点*/
    Node* list::getNumNode(const string& num){
        Node* p = this->head->next;    // 指向第一个节点
        int index = 1;    // 计数为1
    
        // 遍历链表
        try {
            while (p != NULL) {
                if (p->getNum() == num) {
                    return p;    // 找到节点以后返回一个指针
                }
                // 检查越界情况
                if (index > this->length)
                    exit(-4);
                // 移动指针
                p = p->next;
                index++;
            };
        }
        catch (string msg) {
            this->error = msg;
            return this->head;
        }
        return this->head;    // 未找到返回空指针
    }
    
    /*获取指定loc位置的节点*/
    Node* list::getNode(const int& loc){
        // 对loc进行判断
        try {
            if (loc < 0 || loc > this->length) {
                exit(-1);
            }
        }
        catch (const char msg) {
            this->error = msg;    // 错误储存
            return this->head;    // 返回一个指针
        }
    
        // 获取指定位置的节点
        Node* p = this->head;    // 头节点
        for (int index = 0; index < loc; index++) {
            p = p->next;    // 移动指针
        }
    
        return p;
    }
    
    /*插入指定位置的元素*/
    Node * list::insertLoc(Node & node, int & loc){
        node.next = this->getNode(loc + 1);
        this->getNode(loc - 1)->next = &node;
        return &node;
    }
    
    /*删除节点*/
    list* list::deleteNode(const int& loc){
        // 对loc进行处理
        try {
            if (loc < 0 || loc > this->length)
                exit(-1);
        }
        catch (string msg) {
            this->error = msg;
            return this;    
        }
    
        // 删除节点
        Node* p_loc_previous = this->getNode(loc-1);    // 获取要删除的节点的上一个节点
        Node* p_loc = this->getNode(loc);    // 获取要删除的节点
        p_loc_previous->next = this->getNode(loc)->next;    // 删除链
        delete p_loc;    // 删除new出的堆内存
        p_loc = NULL;    // 设置指针为空
    
        // 维护长度
        (this->length)--;
        return this;
    }
    
    /*链表反转*/
    list* list::reverse()
    {
        // 使用三个指针,遍历单链表,逐个对链表进行反转
        // 思路,将链表的指针进行反向,为了防止链表断裂,使用一个指针进行保存,然后再和头节点进行连接
        Node* last;
        Node* tmp;
        Node* first;
        // 进行初始化
        first = this->head->next;
        last = this->head->next->next;    // 此时上方的指向为  first->next = last
    
        // 开始链表反转
        try {
            while (last->next != NULL) {    // 当最后一个链表的next的值为NULL的时,表明链表反转完成
                // 查看链表是否单链表循环,防止死循环发生
                if (this->judgingRingList())
                    exit(-1);
                
                // 为了防止链表丢失,将第三个链表进行用tmp暂存
                tmp = last->next;
                // 调整first和last之间的顺序
                last->next = first;    // 注;此时first->next仍旧指向last此时为一个闭环
                // 指针往后移动
                first = last;
                last = tmp;
            }
        }
        catch (string msg) {
            this->error = msg;
            return this;
        }
    
        // 处理最后一个节点
        last->next = first;
        // 此时this->head 指向该链表的最后一个节点,以及倒数的第二个节点形成环
        // 即 first->next = last  last -> next = first  this->head->next = first
        // 处理环,以及头节点
        this->head->next->next = NULL;    // 处理尾部节点
        this->head->next = last;    //处理头节点
    
        return this;
    }
    
    /*链表一分为二*/
    Node* list::TwoPoints()    {
        Node* q1 = this->head;
        Node* q2 = this->head;
        
        // 判断是否为环单链表
        try {
            if (this->judgingRingList())
                exit(-1);
        }
        catch (string msg) {
            this->error = msg;
            return NULL;
        }
    
        // 进行一分为二
        while (q2->next != NULL) {
            q1 = q1->next;    // q1走一步
            if (q2->next == NULL)
                break;    // 循环到终止
            q2 = q2->next->next;    // q2走两步
        }
    
        // q1重新设置头,形成一条单独的链,并返回
        return (new Node())->next = q1;
    }
    
    /*释放单链表*/ 
    int list::destroyList(){
        for (int index = 1; index <= this->length; index++) {
            this->deleteNode(index);
                
        }
    
        // 删除头节点
        delete this->head;
        this->head = NULL;
        return 0;
    }
    
    
    /*判断环单链表*/
    bool list::judgingRingList(){
        Node* q1 = this->head;
        Node* q2 = this->head;
        
        while (q2->next != NULL) {
            q1 = q1->next;    // q1走一步
            if (q2->next == NULL)
                break;    // 循环到终止,证明单链表
            q2 = q2->next->next;    // q2走两步
            
            if (q1 == q2)
                return true;    // 证明为环单链表
        }
        return false;
    }

    method.h

    #pragma once
    #include "store.h"
    // method.h 单链表
    // 0 号节点为头节点 1号节点开始存储内容
    class list {
    public: 
        list();    // 构造函数
        ~list();    // 析构函数
        int getLength();    // 获得链表长度
        list* getList(); // 获得链表
        string toString();    // 获得result字符串
        list* setString(string& msg);    // 设置result字符串
        string toError();    // 获得error
        list* insertElem_Head(Node& node);    // 头插法,插入元素
        list* insertElem_Foot(Node& node);    // 尾插法,插入元素
        Node* getNumNode(const string& num);    // 根据键值查找指定节点,返回指向该节点的指针
        Node* getNode(const int& loc);    // 获取指定loc的节点,返回指向该节点的指针
        Node* insertLoc(Node& node, int& loc);    // 插入指定位置的元素
        list* deleteNode(const int& loc);    // 删除节点
        list* reverse();    // 反转链表
        Node* TwoPoints();    // 链表一分为二,返回第二个链表的头
    private:
        Node* head;    // 链表头结点
        int length=NULL;    // 链表的长度
        string result = "";    // 临时保存结果
        string error;    // 保存错误
        bool judgingRingList();    // 判断环单链表
        int createList();    // 创建链表
        int destroyList();    // 释放线性表
    };

    单元测试

    // ConsoleApplication3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    //
    
    #include "pch.h"
    #include "method.h"
    #include "store.h"
    #include "typeRedefinition.h"
    #include <iostream>
    
    int main()
    {
        // 创建
        list* list1 = new list();
        cout << list1->TwoPoints() << endl;
        cout << list1->getList() << endl;
        cout << list1->toString() << endl;
        cout << list1->getLength() << endl;
        cout << list1->getList() << endl;
        cout << list1->toString() << endl;
        cout << list1->toError() << endl;
        Node* node1 = new Node();
        node1->setAge(12);
        node1->setMajor("match");
        node1->setName("ming");
        node1->setNum("1211111");
        node1->setRegissterYear(201800012);
        cout << node1->getAge() << endl;
        cout << node1->getMajor() << endl;
        cout << node1->getName() << endl;
        cout << node1->getNum() << endl;
        cout << node1->getRegissterYear() << endl;
        list1->insertElem_Head(*node1);
        Node* node2 = new Node();
        node2->setAge(123);
        node2->setMajor("3333");
        node2->setName("66777");
        node2->setNum("666");
        node2->setRegissterYear(8888);
        list1->insertElem_Foot(*node2);
        cout << list1->getNode(1)->getAge()<< endl;
        cout << list1->getLength() << endl;
        cout << 3333 << endl;
        cout << list1->getList()->toString()<< endl;
        cout << list1->toError() << endl;
        cout << 3333 << endl;
        string tmp = "";
        cout << list1->setString(tmp)->toString() << endl;
        list1->reverse();
        cout << list1->getList()->toString() << endl;
        cout << list1->TwoPoints() << endl;
        delete list1;
        list1 = NULL;
    
    
        return 0;
    }
    

    ps

    仅仅为最基本的,下面用qt框架做ui

    展开全文
  • 单链表C++

    2018-10-28 23:04:44
    单链表 C++ 题目 1、创建单链表2、初始化单链表3、释放单链表4、获取单链表中元素的数量5、输出单链表中的所有数据6、获取单链表中指定位置的元素7、根据键值查找指定元素8、采用头插法向单链表中插入一个元素9、...

    单链表 C++

    题目

    1、创建单链表
    2、初始化单链表
    3、释放单链表
    4、获取单链表中元素的数量
    5、输出单链表中的所有数据
    6、获取单链表中指定位置的元素
    7、根据键值查找指定元素
    8、采用头插法向单链表中插入一个元素
    9、采用尾插法向单链表中插入一个元素
    10、向单链表中的指定位置插入一个元素
    11、删除指定位置的元素

    设计类图

    文件结构

    效果

    store.h

    #pragma once
    // store.h 储存的结构体
    #include "typeRedefinition.h"
    #define Node_Length 20
    
    /*储存基本的储存结构*/
    class Elemtype {
    private:
        string num;    // 学号
        string name;    // 姓名
        int age;    // 年龄
        string major;    // 专业
        int regissterYear;    // 入学年份
    public:
        int setNum(string num);
        string getNum();
        int setName(string name);
        string getName();
        int setAge(int age);
        int getAge();
        int setMajor(string major);
        string getMajor();
        int setRegissterYear(int regissterYear);
        int getRegissterYear();
    };
    
    /*节点*/
    class Node: public Elemtype{
    public:
        Node* next = NULL;
        Node();
    };
    

    store.cpp

    // store.cpp
    #include "pch.h"
    #include "store.h"
    
    /*构造函数*/
    Node::Node(){
        this->next = NULL;
        Elemtype::setAge(0);
        Elemtype::setMajor("NULL");
        Elemtype::setName("NULL");
        Elemtype::setNum("NULL");
        Elemtype::setRegissterYear(0);
    }
    
    /*学号*/
    int Elemtype::setNum(string num)
    {
        this->num = num;
        return 0;
    }
    
    string Elemtype::getNum(){
        return this->num;
    }
    
    /*姓名*/
    int Elemtype::setName(string name)
    {
        this->name = name;
        return 0;
    }
    
    string Elemtype::getName()
    {
        return this->name;
    }
    
    /*年龄*/
    int Elemtype::setAge(int age)
    {
        this->age = age;
        return 0;
    }
    
    int Elemtype::getAge()
    {
        return this->age;
    }
    
    /*专业*/
    int Elemtype::setMajor(string major)
    {
        this->major = major;
        return 0;
    }
    
    string Elemtype::getMajor()
    {
        return this->major;
    }
    
    /*入学年份*/
    int Elemtype::setRegissterYear(int regissterYear)
    {
        this->regissterYear = regissterYear;
        return 0;
    }
    
    int Elemtype::getRegissterYear()
    {
        return this->regissterYear;
    }

    typeRedefinition.h

    #pragma once
    // typeRedefinition.h   
    #include <string>
    using namespace std;
    
    //typedef struct Elemtype elemtype;    
    //typedef struct Elemtype*  p_Elemtype;    // 基本的储存
    //typedef Node* p_Node;    // 储存的方式
    typedef string* p_string;    // string 指针

    method.cpp

    // method.cpp 单链表
    #include "pch.h"
    #include "method.h"
    
    /*构造函数*/
    list::list() {
        this->createList();
    }
    
    /*析构函数*/
    list::~list() {
        this->destroyList();
    }
    
    /*创建链表*/
    int list::createList() {
        Node* head = new Node();    // 创建头节点
        this->head = head;
        try {
            if (head == NULL) {
                exit(-2);
            }
        }catch (const string msg) {
            this->error = msg;
            return -1;
        }
    
        // 维护线性表长度
        this->length = 0;
    
        return 0;
    }
    
    /*获得链表长度*/
    int list::getLength()
    {
        Node* p;
        int i = 0;    // 头节点为0 依次不断递增,第一个存储有内容的节点为1
        
        // 处理0节点的问题
        if (this->length == 0)
            return 0;
        
        p = this->head->next;
    
        while (p != NULL) {
            i++;
            p = p->next;
        }
    
        try {
            if (i != this->length) {
                exit(-3);
            }
        }catch (const string msg) {
            this->error = msg;
            this->length = 0;
            return 0;
        }
    
        return this->length;
    }
    
    /*获得链表*/
    // 将获取的线性表的结果保存在result字符串中
    list* list::getList() {
        Node* p;
        if (this->length == 0)
            return 0;
    
        p = this->head->next;    // 指向第一个拥有数据的节点
    
        for (int index = 1; index <= this->getLength(); index++) {
            // 由于第一个节点为空节点,所以index的初值为1
            /*输出节点序号*/
            this->result += "\n节点序号\t" + to_string(index) + "\n";
            this->result += "输出学号\t" + p->getNum() + "\n";
            /*输出姓名*/
            this->result += "输出姓名\t" + p->getName() + "\n";
            /*输出年龄*/
            this->result += "输出年龄\t" + to_string(p->getAge()) + "\n";
            /*输出专业*/
            this->result += "输出专业\t" + p->getMajor() + "\n";
            /*输出入学年份*/
            this->result += "入学年份\t" + to_string(p->getRegissterYear()) + "\n";
            /*指向下一个节点*/
            p = p->next;
            this->result += "------------------------------------------------";
        }
        return this;
    }
    
    /*输出result*/
    string list::toString()
    {
        return this->result;
    }
    /*设置result字符串*/
    list* list::setString(string& msg)
    {
        this->result = msg;
        return this;
    }
    
    
    /*输出error*/
    string list::toError()
    {
        return this->error;
    }
    
    /*头插法插入元素*/
    list* list::insertElem_Head(Node& node){
        Node* p = NULL;
        p = this->head->next;
        node.next = p;
        this->head->next = &node;
        this->head->next;
        (this->length)++;    // 长度维护
    
        return this;
    }
    
    /*尾插法,插入元素*/
    list* list::insertElem_Foot(Node& node){
        Node* p = this->head;    // 指向头结点
        for (int i = 1; i <= this->length; i++) {
            p = p->next;
        }
        // 进行插入
        p->next = &node;    // 设置指向
        p = p->next;    // 指针移动
        p->next = NULL;    // 设置空值
        (this->length)++;
    
        return this;
    }
    
    /*根据键值查找指定节点*/
    Node* list::getNumNode(const string& num){
        Node* p = this->head->next;    // 指向第一个节点
        int index = 1;    // 计数为1
    
        // 遍历链表
        try {
            while (p != NULL) {
                if (p->getNum() == num) {
                    return p;    // 找到节点以后返回一个指针
                }
                // 检查越界情况
                if (index > this->length)
                    exit(-4);
                // 移动指针
                p = p->next;
                index++;
            };
        }
        catch (string msg) {
            this->error = msg;
            return this->head;
        }
        return this->head;    // 未找到返回空指针
    }
    
    /*获取指定loc位置的节点*/
    Node* list::getNode(const int& loc){
        // 对loc进行判断
        try {
            if (loc < 0 || loc > this->length) {
                exit(-1);
            }
        }
        catch (const char msg) {
            this->error = msg;    // 错误储存
            return this->head;    // 返回一个指针
        }
    
        // 获取指定位置的节点
        Node* p = this->head;    // 头节点
        for (int index = 0; index < loc; index++) {
            p = p->next;    // 移动指针
        }
    
        return p;
    }
    
    /*插入指定位置的元素*/
    Node * list::insertLoc(Node & node, int & loc){
        node.next = this->getNode(loc + 1);
        this->getNode(loc - 1)->next = &node;
        return &node;
    }
    
    /*删除节点*/
    list* list::deleteNode(const int& loc){
        // 对loc进行处理
        try {
            if (loc < 0 || loc > this->length)
                exit(-1);
        }
        catch (string msg) {
            this->error = msg;
            return this;    
        }
    
        // 删除节点
        Node* p_loc_previous = this->getNode(loc-1);    // 获取要删除的节点的上一个节点
        Node* p_loc = this->getNode(loc);    // 获取要删除的节点
        p_loc_previous->next = this->getNode(loc)->next;    // 删除链
        delete p_loc;    // 删除new出的堆内存
        p_loc = NULL;    // 设置指针为空
    
        // 维护长度
        (this->length)--;
        return this;
    }
    
    /*链表反转*/
    list* list::reverse()
    {
        // 使用三个指针,遍历单链表,逐个对链表进行反转
        // 思路,将链表的指针进行反向,为了防止链表断裂,使用一个指针进行保存,然后再和头节点进行连接
        Node* last;
        Node* tmp;
        Node* first;
        // 进行初始化
        first = this->head->next;
        last = this->head->next->next;    // 此时上方的指向为  first->next = last
    
        // 开始链表反转
        try {
            while (last->next != NULL) {    // 当最后一个链表的next的值为NULL的时,表明链表反转完成
                // 查看链表是否单链表循环,防止死循环发生
                if (this->judgingRingList())
                    exit(-1);
                
                // 为了防止链表丢失,将第三个链表进行用tmp暂存
                tmp = last->next;
                // 调整first和last之间的顺序
                last->next = first;    // 注;此时first->next仍旧指向last此时为一个闭环
                // 指针往后移动
                first = last;
                last = tmp;
            }
        }
        catch (string msg) {
            this->error = msg;
            return this;
        }
    
        // 处理最后一个节点
        last->next = first;
        // 此时this->head 指向该链表的最后一个节点,以及倒数的第二个节点形成环
        // 即 first->next = last  last -> next = first  this->head->next = first
        // 处理环,以及头节点
        this->head->next->next = NULL;    // 处理尾部节点
        this->head->next = last;    //处理头节点
    
        return this;
    }
    
    /*链表一分为二*/
    Node* list::TwoPoints()    {
        Node* q1 = this->head;
        Node* q2 = this->head;
        
        // 判断是否为环单链表
        try {
            if (this->judgingRingList())
                exit(-1);
        }
        catch (string msg) {
            this->error = msg;
            return NULL;
        }
    
        // 进行一分为二
        while (q2->next != NULL) {
            q1 = q1->next;    // q1走一步
            if (q2->next == NULL)
                break;    // 循环到终止
            q2 = q2->next->next;    // q2走两步
        }
    
        // q1重新设置头,形成一条单独的链,并返回
        return (new Node())->next = q1;
    }
    
    /*释放单链表*/ 
    int list::destroyList(){
        for (int index = 1; index <= this->length; index++) {
            this->deleteNode(index);
                
        }
    
        // 删除头节点
        delete this->head;
        this->head = NULL;
        return 0;
    }
    
    
    /*判断环单链表*/
    bool list::judgingRingList(){
        Node* q1 = this->head;
        Node* q2 = this->head;
        
        while (q2->next != NULL) {
            q1 = q1->next;    // q1走一步
            if (q2->next == NULL)
                break;    // 循环到终止,证明单链表
            q2 = q2->next->next;    // q2走两步
            
            if (q1 == q2)
                return true;    // 证明为环单链表
        }
        return false;
    }

    method.h

    #pragma once
    #include "store.h"
    // method.h 单链表
    // 0 号节点为头节点 1号节点开始存储内容
    class list {
    public: 
        list();    // 构造函数
        ~list();    // 析构函数
        int getLength();    // 获得链表长度
        list* getList(); // 获得链表
        string toString();    // 获得result字符串
        list* setString(string& msg);    // 设置result字符串
        string toError();    // 获得error
        list* insertElem_Head(Node& node);    // 头插法,插入元素
        list* insertElem_Foot(Node& node);    // 尾插法,插入元素
        Node* getNumNode(const string& num);    // 根据键值查找指定节点,返回指向该节点的指针
        Node* getNode(const int& loc);    // 获取指定loc的节点,返回指向该节点的指针
        Node* insertLoc(Node& node, int& loc);    // 插入指定位置的元素
        list* deleteNode(const int& loc);    // 删除节点
        list* reverse();    // 反转链表
        Node* TwoPoints();    // 链表一分为二,返回第二个链表的头
    private:
        Node* head;    // 链表头结点
        int length=NULL;    // 链表的长度
        string result = "";    // 临时保存结果
        string error;    // 保存错误
        bool judgingRingList();    // 判断环单链表
        int createList();    // 创建链表
        int destroyList();    // 释放线性表
    };

    单元测试

    // ConsoleApplication3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    //
    
    #include "pch.h"
    #include "method.h"
    #include "store.h"
    #include "typeRedefinition.h"
    #include <iostream>
    
    int main()
    {
        // 创建
        list* list1 = new list();
        cout << list1->TwoPoints() << endl;
        cout << list1->getList() << endl;
        cout << list1->toString() << endl;
        cout << list1->getLength() << endl;
        cout << list1->getList() << endl;
        cout << list1->toString() << endl;
        cout << list1->toError() << endl;
        Node* node1 = new Node();
        node1->setAge(12);
        node1->setMajor("match");
        node1->setName("ming");
        node1->setNum("1211111");
        node1->setRegissterYear(201800012);
        cout << node1->getAge() << endl;
        cout << node1->getMajor() << endl;
        cout << node1->getName() << endl;
        cout << node1->getNum() << endl;
        cout << node1->getRegissterYear() << endl;
        list1->insertElem_Head(*node1);
        Node* node2 = new Node();
        node2->setAge(123);
        node2->setMajor("3333");
        node2->setName("66777");
        node2->setNum("666");
        node2->setRegissterYear(8888);
        list1->insertElem_Foot(*node2);
        cout << list1->getNode(1)->getAge()<< endl;
        cout << list1->getLength() << endl;
        cout << 3333 << endl;
        cout << list1->getList()->toString()<< endl;
        cout << list1->toError() << endl;
        cout << 3333 << endl;
        string tmp = "";
        cout << list1->setString(tmp)->toString() << endl;
        list1->reverse();
        cout << list1->getList()->toString() << endl;
        cout << list1->TwoPoints() << endl;
        delete list1;
        list1 = NULL;
    
    
        return 0;
    }
    

    ps

    仅仅为最基本的,下面用qt框架做ui

    展开全文
  • 单链表c++

    2020-10-04 17:08:09
    #include<iostream> using namespace std; struct node{ int data; node* next; } class List{ private: node* head; public: List(); void CreatList(int n); ... int DeletePts
    #include<iostream>
    using namespace std;
    struct node{
    	int data;
    	node* next;
    };
    class List{
    	private:
    		node* head;
    	public:
    		List();
    		void CreatList(int n);
    		bool isEmpty(List& l);
    		int Insert(const List &l,int e,int pos);
    		int DeletePts(int e);
    		void Print();
    };
    List::List(){
    	head=new node;
    	head->next=NULL;
    }
    void List::CreatList(int n){
    	int i;
    	node* tmp;
    	node* p=head;
    	for(i=0;i<n;i++){
    		tmp=new node;
    		cin>>tmp->data;
    		tmp->next=NULL;
    		p->next=tmp;
    		p=tmp;
    	}
    }
    bool List::isEmpty(List & l){
    	if(l.head->next==NULL) return true;
    	else return false;
    }
    int List::Insert(const List & l,int e,int pos){
    	node* tmp;
    	node* p=head;
    	if(pos<0||pos>sizeof(l)) return -1;
    	else{
    		tmp->data=e;
    		int i=1;
    		while(pos!=i){
    			p=p->next;
    			i++;
    		}
    		if(pos==i){
    			tmp->next=p->next;
    			p->next=tmp;
    		}
    	}
    }
    int List::DeletePts(int e){
    	node* p=head;
    	node* prev;
    	while(p->data!=e){
    		prev=p;
    		p=p->next;
    	}
    	if(p->data==e){
    		prev->next=p->next;
    		delete p;
    	}
    	else return -1;
    }
    void List::Print(){
    	node* p=head->next;
    	if(head==NULL&&head->next==NULL)
    		cout<<"空链表"<<endl;
    	else{
    		while(p!=NULL){
    			cout<<p->data<<" ";
    			p=p->next;
    		}
    	}
    }
    int main(){
    	List l;
    	l.CreatList(5);
    }
    展开全文
  • 单链表 c++

    2015-07-08 16:45:00
    #include<string> #include<iostream> usingnamespacestd; /*构建一个升序链表*/ typedefstructnode{ stringaddress; inttemp; structnode...
    #include<string>
    #include<iostream>
    using namespace std;
    /*构建一个升序链表*/
     typedef struct node{
        string address;
    	int temp;
    	struct node *next;
    }Link;
    
    Link* Head;   //声明一个虚拟节点——头结点
    int NodeCount;
    
    //初始化链表
    void CreateList(void)
    {
    	//初始化链表
    	Head =new Link;   //定义,初始化
    	Head->next=NULL;   //Head->next=NULL用于表示链表结束
    	NodeCount=0;
    }
    /*有序插入*/
    void insert_Node(string viraddress,int mtemp)
    {
    	Link *pn=new Link; 
    	pn->address=viraddress;
    	pn->temp=mtemp;
    	Link *pre;
    	Link *curr;
    	pre=Head;
    	curr=Head->next;
    
    	//定位插入点,由于加入了头结点,只要找到插入点,在链表的任何位置的插入操作都一致~
    	while(curr!=NULL&&curr->temp<pn->temp)
    	{
    		pre=curr;
    		curr=curr->next;
    	}
    	//插入操作
    	pn->next=pre->next;
    	pre->next=pn;
    	
    	NodeCount++;
    	cout<<"插入成功"<<endl;
    }
    /*删除操作*/
    int delete_Node(int mtemp)
    {
    	//考虑删除成功和删除失败两种情况
    	Link *pre=Head;
    	Link *curr=Head->next;
    	while(curr!=NULL&&curr->temp!=mtemp)
    	{
    		pre=curr;
    		curr=curr->next;
    	}
    	if(curr==NULL)  //链表为空或无mtemp两种情况
    	{
    		cout<<"删除元素失败"<<endl;
    		return 0;
    	}
    	else
    	{
    		pre->next=curr->next;
    		NodeCount--;
    		cout<<"删除成功"<<endl;
    		return 1;
    	}
    }
    /*搜索某元素,返回结点*/
    Link* find_Node(int mtemp)
    {
    	Link *curr=Head;
    	while(curr!=NULL&&curr->temp!=mtemp)
    		curr=curr->next;
    	return curr;
    
    }
    int main()
    {
    	
    	CreateList();
    	string add="shandong";
    	insert_Node(add,30);
    	add="harbin";
    	insert_Node(add,35);
    	delete_Node(30);
    	delete_Node(31);
    	Link *t=find_Node(35);
    	cout<<t->address<<endl;
    	return 0;
    }


    转载于:https://my.oschina.net/ingu5102/blog/476243

    展开全文
  • 单链表C++实现

    2016-05-15 13:44:29
    单链表C++实现//单链表C++实现 #include //节点定义 template class ListNode { friend class List; private: T data; ListNode * next; public: ListNode(); ListNode(const Type & item); }; //链表定义 ...
  • 单链表C++实现代码

    万次阅读 多人点赞 2019-06-20 16:01:28
    因为没什么事做就写一下单链表的操作,反正是基础数据结构,长时间不写的话再写会出现一下小的细节毛病,多练习练习,理解也更加深点。 单链表写顺,队列的入队出队就是单链表的头插和尾删而已,栈的入栈出栈就是...
  • 数据结构单链表C++操作 #include<iostream> #include<cstdio> #include<algorithm> #include<cassert> #include<vector> using namespace std; typedef int DataType; #define Node ...
  • 线性表之单链表C++实现 源码:https://github.com/cjy513203427/C_Program_Base/tree/master/54.%E9%93%BE%E8%A1%A8 需要实现的方法 #pragma once #include"Node.h" #ifndef LIST_H...
  • 最基本的单链表C++

    千次阅读 2011-09-17 13:42:20
    // 单链表.cpp -- 最基本的单链表C++ // Singly-linked list node template class Link { public: Elem element; // value for this node Link *next; // pointer to next node in list Link(const Elem& ...
  • 单链表c++实现

    2019-09-05 18:31:40
    单链表 LinkList.cpp,实现链表插入遍历 Linklist.cpp // // Created by lingxian on 2019/9/5. // #include "LinkList.h" template <typename T> struct node{ node *next= nullptr; T data; }; template &...
  • 循环单链表C++实现

    2021-01-19 13:30:35
    #pragma once #ifndef Node_hpp #define Node_hpp typedef double value_data; class Node { public: value_data Data; Node *Next; }; #endif /* Node_hpp */ #pragma once ...class Circular_L
  • 单链表C++ 模板

    2016-06-18 11:04:39
    /********************** 单链表类 *************************/ // 链表结点 template struct LinkNode{ T data; LinkNode<T> *next; LinkNode(LinkNode<T> *ptr = NULL){ next = ptr; } LinkNode(const T& ...
  • 单链表 C++实现

    2015-12-03 23:31:07
    重新修改了下,单链表C++实现,Ubuntu14下测试可运行。 List.h #include #include using namespace std; template struct LinkNode{ T data; LinkNode<T> * link; LinkNode(LinkNode<T> *ptr = NULL) { link =...
  • 简单的单链表模板实现: #include<iostream> using namespace std; template <typename T> class List{ public: //构造函数 List():head(NULL), len(0){} //析构函数 ~List(){ clear...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,134
精华内容 1,653
关键字:

单链表c++

c++ 订阅