数据结构C++实现--单链表

数据结构c++实现，长期更新

本人比较懒， 直接看代码吧

#include <iostream>
using namespace std;

template <typename Element>
struct Node // 单链表节点定义
{
    Element data;
    Node<Element> *next;
};

template <typename Element>
class LinkList // 定义模板类LinkList
{
public:
    LinkList();                   // 无参构造函数， 建立一个空单链表
    LinkList(Element a[], int n); // 有参构造函数， 建立一个长为n的单链表
    ~LinkList();
    int getLength();
    Element getItem(int i);
    int locate(Element x);
    void insert(int i, Element x); // 在单链表第i个位置插入值为x的元素
    Element remove(int i);         // 删除单链表第i个元素
    bool empty();
    void printList();

private:
    Node<Element> *head;
};

template <class Element>
LinkList<Element>::LinkList() // 无参构造函数
{
    head = new Node<Element>;
    head->next = nullptr;
}

template <class Element>
bool LinkList<Element>::empty() // 判空函数
{
    if (head->next == nullptr)
        return true;
    else
        return false;
}

template <class Element>
void LinkList<Element>::printList() // 遍历单链表函数
{
    Node p = head->next;
    while (p != nullptr)
    {
        cout << p->data << " ";
        p = p->next; // 工作指针p往后移
    }
    cout << endl;
}

template <class Element>
Element LinkList<Element>::getItem(int i) // 按照位查找元素
{
    Node p = head->next;
    int count = 1;
    while (count < i && p != nullptr)
    {
        p = p->next;
        count++;
    }
    if (p == nullptr)
        throw "查找位置错误";
    else
        return p->next;
}

template <class Element>
int LinkList<Element>::getLength() // 获取单链表长度
{
    Node p = head->next;
    int count = 0;
    while (p != nullptr)
    {
        count++;
        p = p->next;
    }
    return count;
}

template <class Element>
int LinkList<Element>::locate(Element x)
{
    Node p = head->next;
    int j = 1;
    while (p != nullptr && p->data != x)
    {
        p = p->next;
        j++;
    }
    if (p != nullptr)
        return j; // 查找成功，返回其序号
    else
        return 0; // 查找失败，返回0
}

template <class Element>
void LinkList<Element>::insert(int i, Element x)
{
    Node p = head;
    int j = 0;
    while (p != nullptr && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (p == nullptr)
        throw "插入位置异常";
    else
    {
        Node s = new Node<Element>;
        s->data = x;
        s->next = p->next;
        p->next = s;
    }
}
template <class Element>
Element LinkList<Element>::remove(int i) // 按照位置删除元素，并返回元素的值
{
    Node p = head;
    int j = 0;
    while (j < i - 1 && p != nullptr)
    {
        p = p->next;
        j++;
    }
    if (p == nullptr && p->next == nullptr)
    {
        throw "删除位置异常";
    }
    else
    {
        Node q = p->next;
        Element x = q->data;
        p->next = q->next;
        delete q;
        return x;
    }
}

// template <class Element>
// LinkList<Element>::LinkList(Element a[], int n) // 头插法
// {
//     head->next = nullptr;
//     for (int i = 0; i < n; i++)
//     {
//         Node s = new Node<Element>;
//         s->data = a[i];
//         s->next = head->next;
//         head->next = s;
//     }
// }

template <class Element>
LinkList<Element>::LinkList(Element a[], int n) // 尾插法
{
    head->next = nullptr;
    Node rear = head;
    for (int i = 0; i < n; i++)
    {
        Node s = new Node<Element>;
        s->data = a[i];
        s->next = rear->next;
        rear->next = s;
        rear = s;
    }
}

template <class Element>
LinkList<Element>::~LinkList() // 析构函数
{
    Node p = head;
    while (p)
    {
        Node q = p;
        p = p->next;
        delete p;
    }
}

int main()
{

    return 0;
}