手把手教你实现LinkedList

概述

关于链表（LinkedList）的定义，这里我就不作解释了，如果你还不知道什么是链表，那么本文并不适合你阅读。同时本文使用C++实现，如果你还不懂C++的基础语法，那么本文也不适合你阅读。今天我以单链表为例教你实现一个链表。小编是一名大二学生，学习C++也不过几个月的时间，如果有写错的地方，还望斧正！

---

接口设计

接口	功能
add	添加
insert	插入
remove	删除
clear	清空
set	修改
get	按索引获取
indexOf	搜索
forEach	遍历

在C++中接口是通过抽象类是实现的,因此我们定义一个类,名为AbstractList,同时将方法添加进去

template<typename T>
class AbstractList {
public:
    virtual ~AbstractList() {}
public:
    // 增
    virtual AbstractList<T>& add(T elem) = 0;
    virtual AbstractList<T>& insert(T newElem, size_t pos) = 0;

    // 删
    virtual AbstractList<T>& remove(size_t pos) = 0;
    virtual AbstractList<T>& clear() = 0;

    // 改
    virtual AbstractList<T>& set(size_t index, T newElem) = 0;

    // 查
    virtual const T& get(size_t index) const = 0;
    virtual size_t indexOf(T target) const = 0;

    // 遍历
    virtual AbstractList<T>& forEach(const std::function<void(T)>& fn) = 0;
};

---

实现LinkedListNode和LinkedList

1.定义LinkedListNode

首先定义节点类,名为LinkedListNode,该类可以通过struct定义在LinkedList的内部,也可以像我一样使用class单独定义为一个类,为了方便我将LinkedList声明为LinkedListNode的友元类，这样LinkedList就能访问到该类的所有属性了，不过在声明友元之前，LinkedList尚未编译，所以要先声明LinkedList。同时为了检测内存泄漏，我在LinkedListNode中定义了一个静态属性 CNT，这个属性在构造函数中+1，在析构函数中-1。如果确认内存不泄漏，可以将该属性删除。

// 前向声明
template<typename T>
class LinkedList;

template<typename T>
class LinkedListNode {
    friend class LinkedList<T>;
public:
    // CNT 用来检查内存泄漏
    static int CNT;
private:
    T _value;// 数据域
    LinkedListNode<T>* next;  //后继
public:
    LinkedListNode(T value, LinkedListNode<T>* next) : _value(value), next(next) {
        CNT++;
    }

    virtual ~LinkedListNode() {
        CNT--;
    }
};
template<typename T>
int LinkedListNode<T>::CNT = 0;

2.定义LinkedList

首先 公有继承AbstractList类 ，将接口导入进来，该类的属性有_head,_tail,_length,均为私有属性,_head是头结点指针,_tail是尾结点指针,_length是链表的长度。该类需要实现拷贝构造函数、需要重载operator=，将默认的拷贝构造函数和默认的赋值运算符都改为深拷贝，并且需要实现析构函数来释放new出来的内存。

template<typename  T>
class LinkedList: public AbstractList<T>{
private:
    LinkedListNode<T>* _head = nullptr;
    LinkedListNode<T>* _tail = nullptr;
    size_t _length = 0;
public:
    LinkedList<T>& add(T elem) override {}

    LinkedList<T>& insert(T newElem, size_t pos) override {}

    LinkedList<T>& remove(size_t pos) override {}

    LinkedList<T>& clear() override {}

    LinkedList<T>& set(size_t index, T newElem) override {}

    const T& get(size_t index) const override {}

    size_t indexOf(T target) const override {}

    LinkedList<T>& forEach(std::function<void(T)> fn) override{}
};

---

实现接口

1.实现add

    /**
     * 尾插
     * @param data 新的数据
     * @return 自身
     */
    LinkedList<T>& add(T data) override {
        // 生成结点
        LinkedListNode<T>* pNode = new LinkedListNode<T>(data, nullptr);
        // 如果是空链表
        if (!_length) {
        	// 如果头指针不为空,则先把头指针内存释放
            if (_head != nullptr)delete _head;
            // 头指针指向新的节点
            _head = new LinkedListNode<T>(data, pNode);
            // 尾指针指向新的节点
            _tail = pNode;
        } 
        // 如果不是空链表
        else {
	        // 尾指针后移
            _tail->next = pNode;
            // 尾指针指向新生成的结点
            _tail = pNode;
        }
        // 长度+1
        _length++;
        // 返回自身,便于函数式编程
        return *this;
    }

2.实现remove

	/**
	 * 删除
	 * @param index要删除元素的索引 
	 * @return 自身
	 */
    LinkedList<T>& remove(size_t index) override {
    	// 如果要删除元素的索引错误,则抛出异常
        if (index > _length - 1) {
            throw exception("remove:溢出!");
        }
        // 开始遍历链表,注意:这里要从从头指针开始遍历,因为要删除的元素的索引可能为0
        int i = -1;
        for (LinkedListNode<T>* ptr = _head; ptr; ptr = ptr->next,i++) {
	        // 找到目标元素的前驱结点
            if (i == index - 1) {
            	// 先存一下目标结点
                auto temp = ptr->next;
                // 将前驱结点的后继改为目标结点的后继
                ptr->next = ptr->next->next;
                // 删除目标结点
                delete temp;
                // 如果删除的是尾结点
                if (index == _length - 1) {
	                // 尾结点前移
                    _tail = ptr;
                }
                // 退出循环
                break;
            }
        }
        // 长度-1
        _length--;
        // 如果删除之后变为空链表
        if (_length == 0) {
        	// 释放内存
        	delete _head;
	        //将头指针和尾指针置空
            _head = _tail = nullptr;
        }
        return *this;
    }

3.实现clear

    LinkedList<T>& clear() override {
	    // 如果是空链表,直接返回自身
        if (!_length)return *this;
        // 工作指针从头结点开始遍历链表
        LinkedListNode<T>* ptr = _head;
        while (ptr) {
	        // 临时存一下当前指向的节点
            auto temp = ptr;
            // 工作指针后移
            ptr = ptr->next;
            // 释放内存
            delete temp;
        }
        // 头指针,尾指针置空
        _head = _tail = nullptr;
		// 长度置0
        _length = 0;
        // 返回自身
        return *this;
    }

4.实现insert

   /**
     * 插入
     * @param newElem 新的元素
     * @param pos  要插入的位置
     * @return 自身
     */
    LinkedList<T>& insert(T newElem, size_t pos) override {
	    // 如果要插入的位置大于等于链表的长度,则直接尾插
        if (pos >= _length) return add(newElem);
        // 生成一个结点,后继待定
        LinkedListNode<T>* pNode = new LinkedListNode<T>(newElem, nullptr);
        // 从头指针开始遍历链表
        int i = -1;
        for (LinkedListNode<T>* ptr = _head; ptr; ptr = ptr->next,i++) {
	        // 找到目标结点的前一个结点
            if (i == pos - 1) {
	            // 新结点的后继指向目标结点
                pNode->next = ptr->next;
                // 前一个结点的后继指向新节点
                ptr->next = pNode;
                // 退出循环
                break;
            }
        }
        // 长度+1
        _length++;
        // 返回自身
        return *this;
    }

5.实现indexOf

    /**
     * 按值查找
     * @param target 要查找的元素
     * @return 该元素对应的索引
     */
    size_t indexOf(T target) const override {
        int i = 0;
        // 遍历链表
        for (LinkedListNode<T>* ptr = _head->next; ptr; ptr = ptr->next,i++) {
        	// 找到该元素,返回该元素
            if (ptr->_value == target) {
                return i;
            }
        }
        // 未找到抛出异常
        throw exception("find:未找到该元素!");
    }

6.实现set

    /**
     * 修改
     * @param index 要修改元素的索引 
     * @param newElem 新的值
     * @return 自身
     */
    LinkedList<T>& set(size_t index, T newElem) override {
	    // 如果索引不正确,抛出异常
        if (index > _length - 1) {
            throw exception("set:溢出!");
        }
        // 遍历链表
        int i = 0;
        for (LinkedListNode<T>* ptr = _head->next; ptr; ptr = ptr->next) {
	        // 找到要修改的元素
            if (i++ == index) {
            	// 修改值
                ptr->_value = newElem;
                // 返回自身
                return *this;
            }
        }
    }

7.实现get

   /**
     * 搜索
     * 通过该方法返回的值只读
     * @param index 索引 
     * @return 该索引对应的数据 
     */
    const T& get(size_t index) const override {
        if (_length == 0)throw exception("get:空链表!");
        else if (index >= _length) throw exception("get:溢出!");
        // 遍历链表,i用于计数
        int i = 0;
        for (LinkedListNode<T>* ptr = _head->next; ptr; ptr = ptr->next) {
        	// 找到对应的结点,就返回
            if (i++ == index) {
                return ptr->_value;
            }
        }
    }

8.实现forEach

我们会发现get方法获取一个值就需要遍历一次链表,时间复杂度为O(n)。
此时我们想一下这种情况：
在外界如何打印该链表?
你可能会说利用int i 游标使用get方法遍历链表,源代码如下:

    LinkedList<int> list;
    list.add(1);
    list.add(2);
    list.add(3);
    for (int i = 0; i < list.length(); ++i) {
        cout << list.get(i) << "\t";
    }
    cout << endl;

是的,这确实没错,但是利用get效率实在太低了,这样的算法时间复杂度为O(n²),这怎么能忍?
于是我实现了forEach方法,这个方法可以从外接收一个lambda表达式或函数,这样就可以一边遍历一边调用传进来的函数,代码如下:

    /**
     * 遍历
     * 1.该方法从外界接收一个 返回值为void 参数类型为T的lambda表达式或函数的常引用
     * 传入的lambda表达式或函数的参数的传递方式采用值传递,这是为了避免在forEach遍历
     * 过程中修改到表中的数据,同时也避免了两个(指针)引用指向同一对象
     * 2.传常引用是为了提升效率
     * @param fn lambda表达式或者函数的常引用
     * @return 自身
     */
    LinkedList<T>& forEach(const std::function<void(T)>& fn) override {
        if (_length == 0)throw exception("forEach:空链表!");
        for (LinkedListNode<T>* ptr = _head->next; ptr; ptr = ptr->next) {
            fn(ptr->_value);
        }
        return *this;
    }

lambda表达式是C++11的新特性 基本语法为:

[捕获列表](参数列表)->返回类型{函数体}
返回类型可以省略

std::function类是C++11新增的特性,在C++11之前你可以通过函数指针实现相同功能,但捕获列表不为空的lambda是不能通过函数指针实现的!
OK,实现forEach之后,遍历效率就高了许多了,你可以使用以下语句进行遍历

    LinkedList<int> list;
    list.add(1);
    list.add(2);
    list.add(3);
    list.forEach([](int item) { cout << item << '\t'; });
    cout << endl;

这样看起来就舒服多了!
同时你还可以使用lambda捕获一下变量：

    LinkedList<int> list, list1;
    list.add(1);
    list.add(2);
    list.add(3);
    // 将list中的全部数据加入list1
    list.forEach([&](int item) { list1.add(item); });
    // 打印list1
    list1.forEach([](int item) { cout << item << "\t"; });// 输出 1,2,3
    cout << endl;

在上面的代码中我将list中的代码加入到了list1中,由于lambda的参数采用值传递,你可以不用担心两个引用指向同一个对象这种问题。

9.添加length方法

   size_t length() const {
        return _length;
    }

10.拷贝构造函数

    LinkedList(const LinkedList<T>& src) {
	    // 将src中的数据添加到新的链表
        for (LinkedListNode<T>* ptr = src._head->next; ptr; ptr = ptr->next) {
            add(ptr->_value);
        }
    }

11.operator=

    LinkedList& operator=(const LinkedList<T>& src) {
	    // 判断自身复制
        if (&src == this) {
            return *this;
        }
        // 先清空
        clear();
        // 从src添加新的数据
        for (LinkedListNode<T>* ptr = src._head->next; ptr; ptr = ptr->next) {
            add(ptr->_value);
        }
        //返回自身的引用
        return *this;
    }

12.析构函数

直接清空即可

 ~LinkedList() override { clear(); }

源代码

我已经将代码提交到github上,大家可以下载：
https://github.com/Ozral/LinkedList