数据结构一：线性表

线性表是最常用也是最简单的数据结构，几种常用的线性表的类模板C++描述描述如下：

1.顺序表

顺序表是将所有元素按逻辑顺序存储在一组地址连续的存储空间中的简单数据结构：

const int MAXSIZE = 1000;
template<class T>
class SeqList
{
public:
    SeqList(){ lenght = 0; }           // 无参构造函数
    SeqList(const T a[], int n);       // 带参构造函数，并用数组初始化

    int GetLenght() const{ return lenght; }// 返回顺序表长度
    void PrintList()const;                 // 依次遍历顺序表各个数据元素
    void Insert(int i, T x);               // 指定位置插入数据元素
    T Delete(int i);                       // 删除指定位置的数据元素，并返回这个元素
    T Get(int i) const;                    // 获取指定位置的数据元素
    int Locate(T x) const;                 // 查找指定元素并返回其位置
private:
    T data[MAXSIZE];                       // 存储顺序表中各个数据元素
    int lenght;                            // 顺序表长度
};


// 构造函数
template<class T>
SeqList<T>::SeqList(const T a[], int n)
{
    if (n > MAXSIZE)
        throw"数组长度超出顺序表最大长度";
    for (int i = 0; i < n; i++)
        data[i] = a[i];
    lenght = n;
}

// 遍历顺序表
template<class T>
void SeqList<T>::PrintList()const
{
    std::cout << "顺序表中元素依次如下所示：" << endl;
    for (int i = 0; i < lenght; i++)
        std::cout << data[i] << " ";
    std::cout << std::endl;
}

// 插入元素
template<class T>
void SeqList<T>::Insert(int i, T x)
{
    if (lenght >= MAXSIZE)
        throw"上溢异常";
    if (i<1 || i>lenght)
        throw"插入位置不合法";
    for (int j = lenght; j >= i; j--)
        data[j] = data[j - 1];
    data[i - 1] = x;
    lenght++;
}

// 删除元素
template<class T>
T SeqList<T>::Delete(int i)
{
    if (0 == lenght)
        throw"下溢异常";
    if (i<1 || i>lenght)
        throw"删除位置不合法";
    T X = data[i - 1];
    for (int j = i; j < lenght; j++)
        data[j - 1] = data[j];
    lenght--;
    return X;
}

// 查找元素
template<class T>
T SeqList<T>::Get(int i)const
{
    if (i<1 || i>lenght)
        throw"查找位置不合法";

    return data[i - 1];
}

// 定位元素
template<class T>
int SeqList<T>::Locate(T x)const
{
    for (int i = 0; i < lenght; i++)
    {
        if (x == data[i])
            return i + 1;
    }
    
    throw"查找的元素不存在顺序表中";
    return 0;
}

2.单链表

单链表与顺序表不同的地方是存放的元素地址是零散的，可能连续也可能不连续，保证彼此之间的联系，因此，在存储元素的时候需要存储下一个元素的地址：

template<class T>
struct Node
{
    T data;
    Node*next;
};


template<class T>
class LinkList
{
public:
    LinkList(){ front = new Node<T>; front->next = NULL; }// 无参构造函数
    LinkList(T a[], int n);                               // 带参构造函数，用数组初始化链表 
    ~LinkList();                                          // 析构函数
    void PrintList()const;                                // 依次遍历链表元素
    int GetLenght()const;                                 // 返回链表长度
    Node<T>*Get(int i)const;                              // 返回指定位置的数据元素
    int Locate(T x)const;                                 // 查找指定元素，并返回其位置
    void Insert(int i, T x);                              // 指定位置插入指定元素
    T Delete(int i);                                      // 删除指定位置的元素
private:
    Node<T>*front;                                        // 头指针
};


 // 头插法
template<class T>
LinkList<T>::LinkList(T a[], int n)
{
    front = new Node<T>;             
    front->next = NULL;                                   // 构造空链表
    for (int i = n - 1; i => 0;i--)
    {
        Node<T>*s = new Node<T>;                          // 建立新结点
        s->data = a[i];                                   // 将值写入结点数据域
        s->next = front->next;                            // 修改新节点指针域
        front->next = s;                                  // 修改头结点指针域
    }
}

// 尾插法
template<class T>
LinkList<T>::LinkList(T a[], int n)
{
    front = new Node<T>;
    Node<T>*r = front;
    for (int i = 0; i < n;i++)
    {
        Node<T>*s = new Node<T>;           // 建立新结点
        s->data = a[i];                    // 将值写入新结点数据域
        r->next = s;                       // 将新结点加入链表
        r = s;                             // 修改尾指针
    }
    r->next = NULL;
}

template<class T>
LinkList<T>::~LinkList()
{
    Node<T>*p = front;                    // 初始化工作指针
    while (p)
    {
        front = p;                        // 暂存工作指针  
        p = p->next;                      // 移动工作指针到下一个结点
        delete front;                     // 释放结点
    }
}

template<class T>
Node<T>*LinkList<T>::Get(int i)const
{
    Node<T>*p = front->next;              // 初始化工作指针
    int j = 1;                            // 初始化计数器
    while (p&&j!=i)                       
    {
        p = p->next;                      // 移动工作指针
        j++;                              // 计数器递增
    }
    return p;                             // 返回查找结果
}

template<class T>
int LinkList<T>::Locate(T x)const
{
    Node<T>*p = front->next;              // 初始化工作指针
    int j = 1;                            // 初始化计数器
    while (p)
    {
        if (x == p->data)                 // 找到指定元素就返回位置
            return j;                     
        p = p->next;                      // 移动工作指针
        j++;                              // 递增计时器
    }
    return -1;                            // 若找不到，返回-1
}

template<class T>
void LinkList<T>::Insert(int i, T x)
{
    Node<T>*p = front;                    // 初始化工作指针

    if (i != 1)
        p = Get(i - 1);                   // 返回插入位置前一个元素的位置
    if (p)
    {
        Node<T>*s = new Node<T>;
        s->data = x;                      // 插入元素数据区域赋值
        s->next = p->next;                // 插入元素指针区域赋值
        p->next = s;                      // 插入元素接入链表
    }
    else
        throw"插入位置错误！";
}

template<class T>
T LinkList<T>::Delete(int i)
{
    Node<T>*p = front;                 // 初始化工作指针
    if (i != 1)
        p = Get(i - 1);                // 获取第i-1个元素的地址
    Node<T>*q = p->next;               // 获取第i个元素的地址
    p->next = q->next;                 // 将第i+1个元素与第i个元素链接
    T x = q->data;                     // 保存被删除元素
    delete q;                          // 删除指定位置元素
    return x;                          // 返回被删除的元素
}

template<class T>
void LinkList<T>::PrintList()const
{
    Node<T>*p = front->next;
    std::cout << "链表元素依次为：";
    while (p)
    {
        std::cout << (p->data) << " ";
        p = p->next;
    }
    std::cout << std::endl;
}

template<class T>
int LinkList<T>::GetLenght()const
{
    Node<T>*p = front->next;
    int j = 1;
    while (p)
    {
        p = p->next;
        j++;
    }

    return j;
}

3.单循环链表

单循环链表与单链表没有太大区别，为了访问链表的首尾段，将之前的头指针换成了尾指针，尾指针指向链表尾部，尾指针指针域指向链表第一个元素：

template<class T>
struct Node
{
    T data;     // 数据域
    Node*next;  // 指针域
}

template<class T>
class CLinkList
{
public:
    CLinkList(){ rear = new Node<T>; rear->next = rear; } // 无参构造函数
    CLinkList(T a[], int n);                              // 用数组初始化单循环链表

    ~CLinkList();                                         // 析构函数
    int GetLenght()const;                                 // 返回链表长度
    Node<T>*Get(int i)const;                              // 返回指定位置元素数据
    int Locate(T x)const;                                 // 查找指定元素，并返回其位置
    void Insert(int i, T x);                              // 指定位置插入元素
    T Delete(int i);                                      // 删除指定位置的元素，并返回其值
    void PrintList()const;                                // 依次遍历链表元素
    void Connect(CLinkList<T>&B);                         // 将链表B链接到表尾

private:
    Node<T>*rear;                                         // 尾指针（指向最后一个元素）
};


template<class T>
CLinkList<T>::CLinkList(T a[], int n)   // 尾插法
{
    rear = new Node<T>;
    rear->next = rear;       // 初始化尾指针
    for (int i = 0; i < n; i++)
    {
        Node <T>*s = new Node <T>;
        s->data = a[i];      // 数据域赋值
        s->next = rear->next;// 新增结点指针指向头结点
        rear->next = s;      // 新增结点添加到链表中
        rear = s;            // 尾指针指向尾结点
    }
}


template<class T>
void CLinkList<T>::PrintList()const
{
    std::cout << "单循环链表各元素如下：";
    Node<T>*p = rear->next;              // 初始化工作指针指向头结点
    do
    {
        p = p->next;                     // 修改工作指针
        std::cout << p->data << " ";     // 打印
    } while (p != rear);

    std::cout << std::endl;
}

template<class T>
CLinkList<T>::~CLinkList()
{
    Node<T>*p = rear->next;         // 初始化工作指针
    Node<T>*q = rear->next;         // 初始化工作指针
    while (p!=rear)
    {
        q = p;
        p = p->next;
        delete q;
    }
    delete p;                      // 释放尾结点
}


template<class T>
int CLinkList<T>::GetLenght()const
{
    Node<T>*p = rear->next;         // 初始化工作指针
    int j = 0;                      // 元素计数器
    while (p != rear)
    {
        p = p->next;                // 移动工作指针
        j++;
    }
    return j;
}

template<class T>
Node<T>*CLinkList<T>::Get(int i)const
{
    Node<T>*p = rear->next;                   // 初始化工作指针
    int j = 0;                                // 计数器
    while ((p != rear) && (j != i))
    {
        p = p->next;                          // 移动工作指针
        j++;
    }
    return p;
}

template<class T>
int CLinkList<T>::Locate(T x)const
{
    Node<T>*p = rear->next;             // 初始化工作指针
    int j = 0;                          // 计数器
    while (p != rear)
    {
        if (p->data == x)
            return j;
        p = p->next;                   // 移动工作指针
        j++;
    }
    return -1;
}

template<class T>
T CLinkList<T>::Delete(int i)
{
    Node<T>*P = rear;                  // 初始化工作指针
    if (i != 1)
        P = Get(i - 1);                // 获取第i-1个元素的地址
    Node<T>*q = P->next;               // 获取第i个元素的地址
    P->next = q->next;                 // 将第i+1个元素与第i个元素链接
    T x = q->data;                     // 保存被删除元素
    delete q;                          // 删除指定位置元素
    return x;                          // 返回被删除的元素
}

template<class T>
void CLinkList<T>::Insert(int i, T x)
{
    Node<T>*p = rear;

    if (i != 1)
        p = Get(i - 1);                // 获取第i-1个元素的地址
    if (p)
    {
        Node<T>*s = new Node<T>;       // 新建结点数据
        s->data = x;                   // 新增结点数据域赋值
        s->next = p->next;             // 新增结点指针域赋值
        p->next = s;                   // 连接链表
    }
    else
        throw"插入位置错误！";
}

template<class T>
void CLinkList<T>::Connect(CLinkList<T>&B)
{
    if (B.rear == B.rear->next)
        return;                       // 如果B为空表，无需链接
    Node<T>*p = B.rear->next;         // 暂存头结点
    B.rear->next = rear->next;
    rear->next = p->next;
    rear = B.rear;

    B.rear->next = B.rear = p;
}

4.双向链表

相比单向链表，就是多了一个前驱结点指针，方便访问相连的前后结点：

template<class T>
struct DNode
{
    T data;      // 数据域
    DNode*prior; // 指针域，指向前一个结点
    DNode*next;  // 指针域，指向后一个结点
};

template<class T>
class DLinkList
{
public:    
    DLinkList(){ front = new DNode<T>; front->next = front; front->prior = front; } // 无参构造函数
    DLinkList(T a[], int n);                         // 带参构造函数，数组初始化链表
    ~DLinkList();                                    // 析构函数

    void Insert(int i, T X);                         // 指定位置插入指定元素
    T Delete(int i);                                 // 删除指定位置的元素，并返回这个元素
    int GetLenght()const;                            // 返回链表长度
    DNode<T>*Get(int i)const;                        // 查找指定位置元素
    int Locate(T X)const;                            // 查找指定元素，并返回其位置
    void PrintList()const;                           // 遍历链表
private:
    DNode<T>*front;
};

template<class T>
DLinkList<T>::DLinkList(T a[], int n)
{
    front = new DNode<T>;                 // 构造头结点
    DNode<T>*p = front;                   // 存储头指针
    front->next = front;                  // 初始化头结点
    front->prior = front;                 // 初始化头结点

    for (int i = 0; i < n;i++)
    {
        DNode<T>*s = new DNode<T>;        // 构造新结点数据结构
        s->data = a[i];                   // 给新结点数据域赋值
        s->next = front->next;            // 新结点后驱指针指向头结点
        front->next = s;                  // 新结点加入后驱链中
        s->prior = front;                 // 新结点前驱指针指向头结点
        p->prior = s;                     // 修改头结点前驱指针指向新结点

        front = s;                        // 传递尾结点地址到下一个结点
    }
    front = p;                            // 修改头指针指向头结点
}

template<class T>
DLinkList<T>::~DLinkList()
{
    DNode<T>*p = front;                   // 初始化工作结点
    DNode<T>*q = front;                   // 初始化工作结点
    do 
    {
        p = p->next;                      // 移动工作结点
        q = p;                            // 暂存待释放结点
        delete q;
    } while (p!=front->prior);

    delete front;                          // 释放头结点
}

template<class T>
void DLinkList<T>::PrintList()const
{
    DNode<T>*p = front;                    // 初始化工作链表
    std::cout << "按后驱指针遍历链表：";
    while(p!=front->prior)
    {
        p = p->next;                       // 移动工作指针
        std::cout << p->data << " ";
    }
    std::cout << std::endl;

    DNode<T>*q = front->prior;             // 初始化工作链表
    std::cout << "按前驱指针遍历链表：";
    while (p != front)
    {
        std::cout << p->data << " ";
        p = p->prior;                       // 移动工作指针
    }
    std::cout << std::endl;
}

template<class T>
T DLinkList<T>::Delete(int i)
{
    DNode<T>*p = Get(i);           // 获取待删除结点地址
    DNode<T>*p1 = p->prior;        // 获取待删除结点的前驱结点位置
    DNode<T>*p2 = p->next;         // 获取待删除结点的后驱结点位置
    T x = p->data;                 // 暂存待删除结点数据域
    p1->next = p2;                 // 修改后驱链
    p2->prior = p1;                // 修改前驱链

    delete p;                      // 删除结点

    return x;
}

template<class T>
void DLinkList<T>::Insert(int i, T X)
{
    DNode<T>*p = Get(i);                // 获取待插入位置地址
    if (p)
    {
        DNode<T>*s = new DNode<T>;      // 构造新结点数据存储结构
        DNode<T>*q = p->prior;          // 获取待插入位置的前驱结点位置

        s->data = X;                    // 插入的新结点数据域赋值
        s->next = p;                    // 插入结点的后驱指针赋值
        q->next = s;                    // 插入结点的前一结点的后驱指针赋值
        s->prior = q;                   // 插入结点的前驱指针赋值
        p->prior = s;                   // 插入结点的后一节点的前驱指针赋值
    }
    else throw"插入位置错误";
}

template<class T>
int DLinkList<T>::GetLenght()const
{
    DNode<T>*p = front;                  // 初始化工作指针
    int j = 0;                           // 定义一个计数器
    while (p!=front->prior) 
    {
        p = p->next;                     // 移动工作指针
        j++;
    }
    return j;
}

template<class T>
DNode<T>*DLinkList<T>::Get(int i)const
{
    DNode<T>*p = front;              // 初始化工作指针
    int j = 0;                       // 定义一个计数器
    while ((p!=front->prior)&&j!=i)
    {
        p = p->next;                 // 移动工作指针
        j++;
    }
    return p;                        // 找到返回地址
}

template<class T>
int DLinkList<T>::Locate(T X)const
{
    DNode<T>*p = front;              // 初始化工作结点
    int j = 0;
    while (p!=front->prior)
    {
        p = p->next;                 // 移动工作指针
        j++;
        if (p->data == X)
            return j;                // 找到元素，返回位置
    }
    return -1;                       // 找不到返回-1
}

5.静态链表

静态链表主要是为了满足那些没有“指针”这一类数据类型的语言（JAVA,BASIC等），采用数组来模拟链表，数组的下标来模拟指针：

template<class T>
struct StaticNode
{
    T data;            // 数据域
    int next;          // 游标（模拟指针）
};

const int SLISTMAXSIZE = 100;

template<class T>
class StaticLinkList
{
public:
    StaticLinkList();                     // 无参构造函数
    StaticLinkList(T a[], int n);         // 带参构造函数，数组初始化链表
    void Insert(int i, T X);              // 指定位置插入指定元素
    T Delete(int i);                      // 删除指定位置元素，并返回该元素
    int Get(int i)const;                  // 按位查找，返回下标
    int Locate(T X)const;                 // 按值查找，返回下标
    int GetLenght()const;                 // 返回链表长度
    int NewNode();                        // 申请结点空间
    void DeleteNode(int i);               // 释放指定结点
    void PrintList()const;                // 遍历链表
private:
    int front;                            // 数据域起始下标
    int tail;                             // 空闲域起始下标
    StaticNode<T> Sarray[SLISTMAXSIZE];        // 数据表
};


template<class T>
StaticLinkList<T>::StaticLinkList()
{
    for (int i = 0; i < SLISTMAXSIZE - 1; i++)
        Sarray[i].next = i + 1;            // 链表每个游标都是指向下一个数组元素
    Sarray[SLISTMAXSIZE - 1].next = -1;         // 将最后一个元素的游标指向-1
    tail = 0;                             // 显然空链表的头结点下标就是0
    front = -1;                           // 空链表的头结点游标定义为-1
}

template<class T>
StaticLinkList<T>::StaticLinkList(T a[], int n)
{
    // 初始化数组
    if (n > SLISTMAXSIZE)
        throw"数据溢出";
    for (int i = 0; i < SLISTMAXSIZE - 1; i++)
        Sarray[i].next = i + 1;             // 链表中每个游标指向下一个数组元素
    Sarray[SLISTMAXSIZE - 1].next = -1;          // 将最后一个元素的游标指向-1
    for (int i = 0; i < n; i++)
        Sarray[i].data = a[i];              // 给链表数据域赋值
    front = 0;                             // front指向可用数据域的第一个元素的下标
    tail = Sarray[n - 1].next;              // tail指向未分配空间的第一个元素
    Sarray[n - 1].next = -1;                // 将可用数据域最有一个元素的游标指向-1
}

template<class T>
int StaticLinkList<T>::NewNode()
{
    if (-1 == tail)                         // 判断是否还有未分配空间
        throw"内存不足";
    int pos=tail;                           // 未分配空间第一个结点分配给新结点
    tail = Sarray[tail].next;               // 未分配空间起点游标后移
    Sarray[tail].next = -1;                 // 修改数据域最后一个元素指向-1
    return pos;                             // 返回新结点的下标
}

template<class T>
void StaticLinkList<T>::DeleteNode(int i)
{
    if (i<0 || i>SLISTMAXSIZE - 1 || -1 == front)
        throw"释放空间错误";
    int p = Get(i);                             // 记录第i个元素下标
    int q = Get(i - 1);;                        // 记录第i-1个元素的下标
    if (p==front)                               // 单独处理删除点为头结点的情况
    {
        Sarray[front].next = tail;
        tail = front;                           // 删除的结点插入到未使用空间的头结点位置
        front = Sarray[front].next;             // 更改数据域的起始下标为原来的下一个位置
    }
    else if (-1 == Sarray[p].next)              // 单独处理待删除点为尾结点的情况
    {
        Sarray[p].next = tail;
        tail = p;
        Sarray[q].next = -1;
    }
    else                                        // 一般情况处理
    {
        Sarray[q].next = Sarray[p].next;
        Sarray[p].next = tail;
        tail = p;
    }
}

template<class T>
T StaticLinkList<T>::Delete(int i)
{
    T x = Sarray[Get(i)].data;   // 将待删除元素暂存
    DeleteNode(i);               // 删除元素

    return x;
}

template<class T>
void StaticLinkList<T>::Insert(int i, T X)
{
    int p = Get(i);                       // 记录第i个元素的下标
    if (p < 0)
        throw"插入位置错误";

    if (p==front)                         // 单独处理在头结点插入的情况
    {
        Sarray[tail].data = X;            // 从未分配空间第一个元素开始使用
        Sarray[tail].next = front;        // 新结点与后一结点链接
        front = tail;                     // 更新头结点
        tail = Sarray[tail].next;         // 未分配空间的头结点顺移
    }
    else
    {
        int q = Get(i - 1);               // 记录第i-1个元素下标

        Sarray[tail].data = X;            // 从未分配空间第一个元素开始使用
        Sarray[q].next = tail;            // 新结点与前一结点链接
        Sarray[tail].next = p;            // 新结点与后一结点链接
        tail = Sarray[tail].next;         // 未分配空间的头结点顺移
    }
}

template<class T>
int StaticLinkList<T>::Get(int i)const
{
    if (i<0 || i>GetLenght())
        return -1;               // 找不到就返回错误-1
    int p = front;               // 初始化工作指针
    int j = 1;                   // 计数器
    while (p!= -1)
    {
        if (j == i)
            return p;
        p = Sarray[p].next;      // 移动工作指针
        j++;
    }
    return p;
}

template<class T>
int StaticLinkList<T>::GetLenght()const
{
    if (-1 == front)
        throw"长度为0";     
    
    int j = 0;                  // 计数器
    int k = front;              // 工作指针
    while (k!=-1)
    {
        k = Sarray[k].next;     // 移动工作指针
        j++;
    }
    return j;
}

template<class T>
int StaticLinkList<T>::Locate(T X)const
{
    int p = front;                      // 工作指针
    while (p!=-1)
    {
        if (X == Sarray[p].data)        // 找到就返回下标
            return p;
        p = Sarray[p].next;
    }
    return -1;
}

template<class T>
void StaticLinkList<T>::PrintList()const
{
    int p = front;                   // 工作游标
    std::cout << "链表元素依次如下：";
    while (p!=-1)
    {
        std::cout << Sarray[p].data << " ";
        p = Sarray[p].next;          // 移动工作游标
    }
    std::cout << std::endl;
}