C++泛化单链表

泛型单链表

单链表将每个数据分为节点，每个节点存储数据和指向下一个节点的指针。这样数据就不用在内存中使用连续的存储空间，有更大的灵活性。

这里将单链表分为节点类（Node）和链表类（singleLinkedList），由于链表类需要访问到Node类的数据，因此将Node类的数据声明为public，也可以将链表类声明为节点类的友元类。

抽向数据类型（ADT) :(linearList.h)

/*************************************************************************
> File Name       : linearList.h
> Author          : Harold
> Mail            : 2106562095@qq.com
> Github          : www.github.com/Haroldcc
> Created Time    : 2020年02月26日  11时02分58秒
************************************************************************/

/***** 线性表的抽象定义 *****/

#ifndef LINEARLIST_H
#define LINEARLIST_H

#include <iostream>

template <typename T>
class linearList
{
public:
    virtual ~linearList() {}
    virtual bool isEmpty() const = 0;                         //是否为空
    virtual int size() const = 0;                             // 元素个数
    virtual T &getElement(int index) const = 0;               // 根据索引获取元素
    virtual void setElement(int index, const T &element) = 0; // 根据索引更改元素值
    virtual int indexOf(const T &element) const = 0;          //指定元素第一次出现的索引
    virtual void removeByIndex(int index) = 0;                //根据索引删除元素并返回
    virtual void removeByElement(const T &element) = 0;       // 删除指定元素
    virtual void add(const T &element) = 0;                   // 在尾部插入元素
    virtual void add(int index, const T &element) = 0;        // 在指定索引处插入元素
    virtual void output(std::ostream &out) const = 0;         // 插入输出流out
};

#endif

异常类（myException.h）

/*************************************************************************
> File Name       : myExceptions.h
> Author          : Harold
> Mail            : 2106562095@qq.com
> Github          : www.github.com/Haroldcc
> Created Time    : 2020年02月26日  14时32分01秒
************************************************************************/

/***** 自定义的异常 *****/
#ifndef MYEXCEPTIONS_H
#define MYEXCEPTUONS_H

#include <iostream>
#include <string>

// 非法参数
class illegalParameterValue
{
private:
    std::string message;

public:
    illegalParameterValue(std::string theMessage = "参数值非法！") : message(theMessage) {}
    void outputMessage() { std::cout << message << std::endl; }
};

// 非法输入
class illegalInputData
{
private:
    std::string message;

public:
    illegalInputData(std::string theMessage = "非法数据输入！")
    {
        message = theMessage;
    }

    void outputMessage() { std::cout << message << std::endl; }
};

// 非法索引
class illegalIndex
{
private:
    std::string message;

public:
    illegalIndex(std::string theMessage = "非法索引！") : message(theMessage) {}
    void outputMessage() { std::cout << message << std::endl; }
};
#endif

单链表头文件（singleLinkedList.h）

/*************************************************************************
> File Name       : singleLinkedList.h
> Author          : Harold
> Mail            : 2106562095@qq.com
> Github          : www.github.com/Haroldcc
> Created Time    : 2020年02月27日  10时12分02秒
************************************************************************/

/***** 单链表 *****/

#ifndef SINGLELINKEDLIST_H
#define SINGLELINKEDLIST_H

#include "linearList.h"   // ADT
#include "myExceptions.h" // 异常类
#include <sstream>        // for ostringstream

/*** 链表节点类 ***/
template <typename T>
class Node
{
public:
    T element;
    Node<T> *next;

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

/*** 单链表类 ***/
template <typename T>
class singleLinkedList : public linearList<T>
{
private:
    void checkIndex(int index) const; // 索引异常检测

    Node<T> *firstNode; // 链表头节点指针
    int listSize;       // 链表的元素个数

public:
    /* 构造函数 */
    singleLinkedList(int initialCapacity = 10);
    singleLinkedList(const singleLinkedList<T> &);
    ~singleLinkedList();

    /* ADT */
    bool isEmpty() const { return this->listSize == 0; }
    int size() const { return this->listSize; }
    T &getElement(int index) const;
    void setElement(int index, const T &element);
    int indexOf(const T &element) const;
    void removeByIndex(int index);
    void removeByElement(const T &element);
    void add(const T &element);
    void add(int index, const T &element);
    void output(std::ostream &out) const;
};

// 默认构造
template <typename T>
singleLinkedList<T>::singleLinkedList(int initialCapacity)
{
    if (initialCapacity < 1)
    {
        std::ostringstream s;
        s << "初始化容量 = " << initialCapacity << "必须 > 0";
        throw illegalParameterValue(s.str());
    }
    this->firstNode = nullptr;
    this->listSize = 0;
}

// 拷贝构造
template <typename T>
singleLinkedList<T>::singleLinkedList(const singleLinkedList<T> &list)
{
    this->listSize = list.listSize;

    // list 为空
    if (this->listSize == 0)
    {
        this->firstNode = nullptr;
        return;
    }

    // list 不为空
    Node<T> *sourceNode = list.firstNode;               // 要复制链表list的节点
    this->firstNode = new Node<T>(sourceNode->element); // 要复制链表list的首元素
    sourceNode = sourceNode->next;
    Node<T> *targetNode = this->firstNode; // 当前链表 *this 的最后一个节点
    while (sourceNode != nullptr)
    { // 复制剩下的节点
        targetNode->next = new Node<T>(sourceNode->element);
        targetNode = targetNode->next;
        sourceNode = sourceNode->next;
    }
    targetNode->next = nullptr; // 尾部置为空
}

// 析构函数
template <typename T>
singleLinkedList<T>::~singleLinkedList()
{
    while (this->firstNode != nullptr)
    {
        Node<T> *nextNode = this->firstNode->next;
        delete this->firstNode;
        firstNode = nextNode;
    }
}

template <typename T>
void singleLinkedList<T>::checkIndex(int index) const
{
    if (index < 0 || index >= this->listSize)
    {
        std::ostringstream s;
        s << "index = " << index << "size = " << this->listSize;
        throw illegalIndex(s.str());
    }
}

// 根据索引获取对应的节点，如未找到，抛异常
template <typename T>
T &singleLinkedList<T>::getElement(int index) const
{
    checkIndex(index);

    Node<T> *currentNode = this->firstNode;
    for (int i = 0; i < index; i++)
        currentNode = currentNode->next;

    return currentNode->element;
}

// 根据索引设置元素值
template <typename T>
void singleLinkedList<T>::setElement(int index, const T &element)
{
    checkIndex(index);

    Node<T> *currentNode = this->firstNode;
    for (int i = 0; i < index; i++)
        currentNode = currentNode->next;

    currentNode->element = element;
}

// 返回给定元素的索引值，若未找到返回 -1
template <typename T>
int singleLinkedList<T>::indexOf(const T &element) const
{
    Node<T> *currentNode = this->firstNode;
    int index = 0;
    while (currentNode != nullptr && currentNode->element != element)
    {
        currentNode = currentNode->next;
        index++;
    }

    if (currentNode == nullptr)
    {
        return -1;
    }
    else
    {
        return index;
    }
}

// 删除指定索引处的元素值，未找到元素抛异常
template <typename T>
void singleLinkedList<T>::removeByIndex(int index)
{
    checkIndex(index);

    Node<T> *deleteNode;
    if (index == 0)
    { // 删除链表中的第一个元素
        deleteNode = this->firstNode;
        this->firstNode = this->firstNode->next;
    }
    else
    {
        Node<T> *p = this->firstNode;
        for (int i = 0; i < index - 1; i++)
            p = p->next;

        deleteNode = p->next;
        p->next = p->next->next;
    }
    this->listSize--;
    delete deleteNode;
}

template <typename T>
void singleLinkedList<T>::removeByElement(const T &element)
{
    removeByIndex(indexOf(element));
}

template <typename T>
void singleLinkedList<T>::add(const T &element)
{
    add(this->listSize, element);
}

// 在指定索引处添加元素
template <typename T>
void singleLinkedList<T>::add(int index, const T &element)
{
    if (index < 0 || index > this->listSize)
    {
        std::ostringstream s;
        s << "index = " << index << "size = " << this->listSize;
        throw illegalIndex(s.str());
    }

    if (index == 0)
    { // 头部插入元素
        this->firstNode = new Node<T>(element, this->firstNode);
    }
    else
    {
        Node<T> *p = this->firstNode;
        for (int i = 0; i < index - 1; i++)
        {
            p = p->next;
        }
        p->next = new Node<T>(element, p->next);
    }
    this->listSize++;
}

template <typename T>
void singleLinkedList<T>::output(std::ostream &out) const
{
    for (Node<T> *currentNode = this->firstNode;
         currentNode != nullptr;
         currentNode = currentNode = currentNode->next)
        out << currentNode->element << " ";
}

// 重载 << 运算符
template <typename T>
std::ostream &operator<<(std::ostream &out, const singleLinkedList<T> &list)
{
    list.output(out);
    return out;
}

#endif

测试

#include "linearList.h"
#include "singleLinkedList.h"
#include <iostream>

using namespace std;

int main()
{
    // test constructor
   linearList<double> *x = new singleLinkedList<double>;
   singleLinkedList<int> y, z;

   // test size
   cout << "Initial size of x, y, and z = "
        << x->size() << ", "
        << y.size() << ", "
        << z.size() << endl;

   // test isEmpty
   if (x->isEmpty()) cout << "x is isEmpty" << endl;
   else cout << "x is not isEmpty" << endl;
   if (y.isEmpty()) cout << "y is isEmpty" << endl;
   else cout << "y is not isEmpty" << endl;

   // test add
   y.add(0, 2);
   y.add(1, 6);
   y.add(0, 1);
   y.add(2, 4);
   y.add(3, 5);
   y.add(2, 3);
   cout << "Inserted 6 integers, list y should be 1 2 3 4 5 6" << endl;
   cout << "Size of y = " << y.size() << endl;
   if (y.isEmpty()) cout << "y is isEmpty" << endl;
   else cout << "y is not isEmpty" << endl;
   y.output(cout);
   cout << endl << "Testing overloaded <<" << endl;
   cout << y << endl;

   // test indexOf
   int index = y.indexOf(4);
   if (index < 0) cout << "4 not found" << endl;
   else cout << "The index of 4 is " << index << endl;

   index = y.indexOf(7);
   if (index < 0) cout << "7 not found" << endl;
   else cout << "The index of 7 is " << index << endl;

   // test getElement
   cout << "Element with index 0 is " << y.getElement(0) << endl;
   cout << "Element with index 3 is " << y.getElement(3) << endl;

   // test removeByIndex
   y.removeByIndex(1);
   cout << "Element 1 erased" << endl;
   cout << "The list is "  << y << endl;
   y.removeByIndex(2);
   cout << "Element 2 erased" << endl;
   cout << "The list is "  << y << endl;
   y.removeByIndex(0);
   cout << "Element 0 erased" << endl;
   cout << "The list is "  << y << endl;

   cout << "Size of y = " << y.size() << endl;
   if (y.isEmpty()) cout << "y is isEmpty" << endl;
   else cout << "y is not isEmpty" << endl;

   try {y.add(-3, 0);}
   catch (illegalIndex e)
   {
      cout << "Illegal index exception" << endl;
      cout << "Insert index must be between 0 and list size" << endl;
      e.outputMessage();
   }

   // test copy constructor
   singleLinkedList<int> w(y);
   y.removeByIndex(0);
   y.removeByIndex(0);
   cout << "w should be old y, new y has first 2 elements removed" << endl;
   cout << "w is " << w << endl;
   cout << "y is " << y << endl;

   // a few more inserts, just for fun
   y.add(0,4);
   y.add(0,5);
   y.add(0,6);
   y.add(0,7);
   cout << "y is " << y << endl;

    return 0;
}

输出

Initial size of x, y, and z = 0, 0, 0
x is isEmpty
y is isEmpty
Inserted 6 integers, list y should be 1 2 3 4 5 6
Size of y = 6
y is not isEmpty
1 2 3 4 5 6
Testing overloaded <<
1 2 3 4 5 6
The index of 4 is 3
7 not found
Element with index 0 is 1
Element with index 3 is 4
Element 1 erased
The list is 1 3 4 5 6
Element 2 erased
The list is 1 3 5 6
Element 0 erased
The list is 3 5 6
Size of y = 3
y is not isEmpty
Illegal index exception
Insert index must be between 0 and list size
index = -3size = 3
w should be old y, new y has first 2 elements removed
w is 3 5 6
y is 6
y is 7 6 5 4 6