C++单向链表之一

最新推荐文章于 2023-08-27 05:44:40 发布
最新推荐文章于 2023-08-27 05:44:40 发布
阅读量223 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c++ 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xrinosvip/article/details/119704121
版权

链表

单向链表

链表是链式存储的，非顺序存储的，与顺序存储的数组不同；数组存储必须先申请足够的内存的空间，然后再存储数据，这可能导致内存空间浪费，链表则不同，链表是需要多少存储空间，则向内存空间申请多少内存，不会导致内存浪费。
链表：
优点：存储数据灵活，节省内存空间，增删查改数据方便等；
缺点：访问速度不如数组快
链表的存储机制，如图：

单向链表

代码：

以 类模板 的形式写的代码，所以只有一个头文件：linkedList.h
Node 模板类 以嵌套类的方式定义在类内部，以实现数据隐藏和封装

#ifndef SIMPLY_LINKEDLIST_LINKEDLIST_H
#define SIMPLY_LINKEDLIST_LINKEDLIST_H
#include <iostream>

template <class T>
class LinkedList{
private:
    // 嵌套类模板：private
    template <class >
    class Node{
        public:
            T element;
            Node<T>* next;

            Node(){
                element = T();
                next = nullptr;
            }

            Node(T element, Node<T>* next):element(element){
//                this->element = element;
                this->next = next;
            }

            ~Node()=default;

    };

private:
    const int ELEMENT_NOT_FOUND = -1;
    int Size;
    Node<T>* first;

    Node<T>* node(int index) const{
        Node<T>* node = first;
        for(int i=0; i < index; ++i){
            node = node->next;
        }
        return node;
    }


public:
    LinkedList();
    LinkedList(T element, Node<T>* next);

    ~LinkedList();

    int size() const;
    void clear();
    bool contains(T element);
    void add(T element);
    void add(T element, int index);
    T get(int index) const;
    T set(T element, int index);
    T remove(int index) ;
    int getPos(T element);
    void display() const;

};

    template <class T>
    LinkedList<T>::LinkedList():Size(0){
        Node<T>();
        first = nullptr;
    }

    template <class T>
    LinkedList<T>::LinkedList(T element, Node<T>* next):Size(0){
        Node<T>(element, next);
        first = nullptr;
    }

    template <class T>
    LinkedList<T>::~LinkedList() {
        Node<T>* ptr = first;
        int cnt = 0;
        while(ptr != nullptr){
            auto q = ptr->next;
            delete ptr;
            ptr = q;
            ++cnt;
        }
        first = nullptr;
        std::cout << "...Finally, calling destructor..." << cnt << std::endl;

    }

    template <class T>
    int LinkedList<T>::size() const {
        return Size;
    }

    template <class T>
    void LinkedList<T>::clear() {
        Node<T>* node = first;
        int cnt = 0;
        for (int i=0; i < Size; ++i){
            auto q = node->next;
            delete node;
            node = q;
            ++cnt;
        }
        Size = 0;
        first = nullptr;
        std::cout << "clear--->cnt: " << cnt << std::endl;
    }

    template <class T>
    bool LinkedList<T>::contains(T element) {
        return getPos(element) != ELEMENT_NOT_FOUND;
    }

    template <class T>
    void LinkedList<T>::add(T element) {
        add(element, Size);
    }

    template <class T>
    void LinkedList<T>::add(T element, int index) {
        if (index == 0){
            first = new Node<T>(element, first);
        }else{
            Node<T>* prev = node(index-1);
            prev->next = new Node<T>(element, prev->next);
        }
        ++Size;
    }

    template <class T>
    T LinkedList<T>::get(int index) const{
        return node(index)->element;
    }

    template <class T>
    T LinkedList<T>::set(T element, int index) {
        Node<T>* ptr = node(index);
        T old = ptr->element;
        ptr->element = element;
        return old;
    }

    template <class T>
    T LinkedList<T>::remove(int index) {
        Node<T>* oldPtr = first;
        if (index == 0){
            first = first->next;    // 删除 第一个节点；
        }else{
            /* 这里容易错：假如要删除 node(1), 则要获取指向 node(0) 处的指针，并将 node(0)->next = node(0)->next->next */
            Node<T>* prev = node(index-1);
            oldPtr = prev->next;
            prev->next = prev->next->next;
        }
        T old = oldPtr->element;
        --Size;
        delete oldPtr;          // 删除节点后，释放 add 时 new 出来的节点内存；
        return old;
    }

    template <class T>
    int LinkedList<T>::getPos(T element) {
        int position = ELEMENT_NOT_FOUND;
        Node<T>* ptr = first;
        for (int i=0; i < Size; ++i){
            if(element == ptr->element){
                position = i;
                break;
            }
            ptr = ptr->next;
        }
        return position;
    }

    template <class T>
    void LinkedList<T>::display() const {
        for(int i=0; i < Size; ++i){
            std::cout << get(i) << "   ";
        }
        std::cout << std::endl;
    }

#endif //SIMPLY_LINKEDLIST_LINKEDLIST_H

注意：

  1. C++ 内存的使用和释放需注意：向堆申请内存，程序退出后应释放多少内存。
  2. 删除节点时（即：remove() ）：记得释放被删除节点的内存。
  3. 清空节点时（即：clear() ):要释放所有 节点 的内存，这和析构函数的作用有点像。
  4. 析构函数： 释放所有 节点 占用的堆内存空间，并将 first（即：头结点）指向 nullptr。

测试函数
main.cpp

#include <iostream>
#include <utility>
#include "linkedList.h"

int main(){
//    auto listPtr = new LinkedList_struct<T>();
    auto listPtr = new LinkedList<T>(0, nullptr);

    // function---->add()
    listPtr->add(100, 0);
    listPtr->add(10000, listPtr->size());
    listPtr->add(20);
    listPtr->add(500);
    for (int i = 0; i < 10; ++i){
        listPtr->add(i*100, i+2);
    }
    listPtr->display();
    cout << "---------------------------------------------------------------------" << endl;

    // function---->remove()
    listPtr->remove(0);

    T a = listPtr->remove(3);
    cout << "a<--remove: " << a << endl;

    listPtr->remove(listPtr->size()-1);
    listPtr->display();
    cout << "---------------------------------------------------------------------" << endl;

    // function---->set()
    a = listPtr->set(10, 0);
    cout << "a<--set: " << a << endl;

    a = listPtr->set(20000, listPtr->size()-1);
    cout << "a<--set: " << a << endl;

    a = listPtr->set(30000, 3);
    cout << "a<--set: " << a << endl;
    listPtr->display();
    cout << "---------------------------------------------------------------------" << endl;

    // function---->get()
    a = listPtr->get(0);
    cout << "a<--get: " << a << endl;

    a = listPtr->get(listPtr->size()-1);
    cout << "a<--get: " << a << endl;

    a = listPtr->get(3);
    cout << "a<--get: " << a << endl;
    cout << "---------------------------------------------------------------------" << endl;

    // function---->getPos()
    int pos = listPtr->getPos(10);
    cout << "pos(element->10): " << pos << endl;

    pos = listPtr->getPos(20000);
    cout << "pos(element->20000): " << pos << endl;

    pos = listPtr->getPos(30000);
    cout << "pos(element->30000): " << pos << endl;
    cout << "---------------------------------------------------------------------" << endl;

    // function---->contains()
    bool tr = listPtr->contains(10);
    cout << "true(1) or false(0): " << tr << endl;
    tr = listPtr->contains(20000);
    cout << "true(1) or false(0): " << tr << endl;
    tr = listPtr->contains(-10);
    cout << "true(1) or false(0): " << tr << endl;
    cout << "---------------------------------------------------------------------" << endl;

    // function---->clear()
    listPtr->clear();
    listPtr->display();
    cout << "listPtr---->size: " << listPtr->size() << endl;
    cout << "---------------------------------------------------------------------" << endl;

    delete listPtr;
    return 0;
}

运行结果：

E:\programme\C_C++\CLion\C++\algorithm\LinkedList\simply_LinkedList\cmake-build-debug\simply_LinkedList.exe
100   10000   0   100   200   300   400   500   600   700   800   900   20   500
---------------------------------------------------------------------
a<--remove: 200
10000   0   100   300   400   500   600   700   800   900   20
---------------------------------------------------------------------
a<--set: 10000
a<--set: 20
a<--set: 300
10   0   100   30000   400   500   600   700   800   900   20000
---------------------------------------------------------------------
a<--get: 10
a<--get: 20000
a<--get: 30000
---------------------------------------------------------------------
pos(element->10): 0
pos(element->20000): 10
pos(element->30000): 3
---------------------------------------------------------------------
true(1) or false(0): 1
true(1) or false(0): 1
true(1) or false(0): 0
---------------------------------------------------------------------
clear--->cnt: 11

listPtr---->size: 0
---------------------------------------------------------------------
...Finally, calling destructor...0

Process finished with exit code 0
漠北尘-Gavin
关注
专栏目录
c++单向链表
qq_42972267的博客
01-06 751
#include &lt;iostream&gt; #include &lt;time.h&gt; using std::cout; using std::endl; struct Node { int data; struct Node* next; }; 一、创建链表 Node * createList() { Node *head = new Node; if (NULL == h...
【C++】单向链表
taoxing
07-09 1636
一.基本介绍 单向链表是链表中的一种，它链接的方向是单向的，而且对链表的访问要从头部开始，依次往下读取。 一个单向链表的节点被分为两部分，第一部分保存该节点的相关信息，第二个节点存储下一个节点的地址。 链表中节点的地址是不连续的。 实现思路： （1）我们需要实现两个类，一个类为节点类，存储相关信息与下一个节点的地址；一个为链表类，头节点作为其变量。 （2）在这里我们以学生信息作为节点进行实现，基本信息包括学号、姓名（写的简洁一下）。 （3）单链表包括节点的增删查改以及链表的打印。 单链
C++ 实现单向链表
u012782049的专栏
12-20 653
#include #include #include using namespace std; struct Node { int value; Node* Next; }; class List { private: Node* head; int count; public: List() { count=0; head=NULL; } Node* He
单向链表c++实现
weixin_42355349的博客
03-07 839
单向链表的结构 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 设置节点类如下： class Node{ int item; Node* next; }; 其中节点指针next指向节点类型变量，从而实现链表的连接 设置链表类如下,包含一节点指针head class...
C++：单向链表
qq_50426849的博客
11-27 549
题目概述： 单向链表。 编程： #include< iostream> using namespace std; typedef struct node { char name[20]; int age; struct node* next; }Student; Student* createList(int n) { Student* head = new Student;//头节点 Student* pre = head; for (int i = 0; i < n; i++) { S
C++单向链表.rar
10-19
这是近期自己参考书上和网上资源使用C++编的单向链表，主要包含了链表的增删改查功能，除此之外还有简单的排序功能，代码实现的效果图已经在项目文件夹中了，可以按照效果图进行数据的增删改查等操作，最后也希望对...
c++数据结构—单向链表
qq_67972375的博客
03-14 1919
由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为NULL,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。
C++单向链表的实现
11-06
C++进阶学习——单向链表的实现,相关教程链接如下： http://blog.csdn.net/tennysonsky/article/details/49685199
C/C++实现单向链表
01-16
单向链表是一种基本的数据结构，它在计算机科学中被广泛使用，特别是在处理动态数据集合时。本项目中，我们分别使用C语言和C++语言实现了单向链表的几个核心功能，包括创建链表、插入数据、获取指定位置的数据以及...
C++ 单向链表
qq_27158571的博客
12-21 399
链表： 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。 1.节点结构体Point data数据 next指针，指向下一个 2.链表类List *head //链表头指针 length //链表长度 3.单向链表的实现
C++单向链表
weixin_34062469的博客
01-28 96
#include <cstdio> #include <cstdlib> #include <iostream> using namespace std; struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; clas...
单向链表（C++实现）
雪
01-09 487
一 、单向链表： 单向链表是一种特殊的数组，它的每个元素称为节点，每个节点包括两个部分：数据域（存放数据）、指针域（存放下一个节点的地址） 单向链表的结构： 特点： 链表比数组多了指针域，链表通过上一节点的指针域找下一个数据，如上图所示，它的存储空间不一定连续。 实现： //----------...
C++链表——单向链表
sinat_40837337的博客
05-21 301
单向链表，简单的说就是一个个结点由一个有方向的绳子连接起来的，如图所示：其中head指向头结点，tail指向尾结点，而在每个结点上简单就包含两个一个是数据变量，另一个是指向下一个结点的Next指针（Next定义与结构体或者类一样）。 如定义一个简单的结点类（所写的带有模板） data为存储数据的变量以及Next指向下一个结点的指针，以及添加函数一个默认构造函数，一个接收一个T类型变量...
用C++实现单向链表
最新发布
qq_37934722的博客
08-27 149
通过addNode方法可以添加新节点，通过findNode方法可以查找特定的节点，而通过deleteNode方法可以删除节点。接下来，我们定义一个LinkedList类，用于表示整个单向链表。head指向链表的第一个节点，而tail指向链表的最后一个节点。值得注意的是，在实现链表时需要小心内存泄漏的问题，即需要确保每个节点都正确地被删除。总结起来，C++中的单向链表实现起来并不复杂，但需要仔细处理各种边界情况，以确保程序的正确性和稳定性。首先，我们定义一个Node类，用于表示链表中的节点。
C++-单向链表
4396的博客
04-13 143
实现链表的增删改查 ownlinklist.cpp #include<iostream> #include "include/ownlinklist.h" #include <cstdlib> using namespace std; node* init() { return new node; } node* get_elment(node *_list,in...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值