链表（模板）类

链表类依赖于cmath头文件，使用ListNode，List四个文件实现：

ListNode.h:

/*********************************************
ListNode.h
链表节点（模板）类 ListNode
T 节点数据
pred 前节点指针
succ 后节点指针
ListNode / ListNode(T, T*, T*) 构造
InsertPred(T) 前插入节点
InsertSucc(T) 后插入节点

 * Created by QSY 2020.10.11
 * Shiyuan Qu, qsy19@mails.tsinghua.edu.cn
 * Department Of Automation, Tsinghua University
 * Copyright (c) 2020. All rights reserved.
**********************************************/
#pragma once

typedef int Rank; //秩
#define Posi(T) ListNode<T>* //列表节点指针

template<typename T> 
struct ListNode
{
    T data;//节点数据
    Posi(T) pred;//前驱节点引用
    Posi(T) succ;//后继节点引用
    ListNode() {};//空构造
    ListNode(T e, Posi(T) p = nullptr, Posi(T) s = nullptr)
        :date(e), pred(p), succ(s) {};
    Posi(T) InsertPred(T const& e);//前插入节点
    Posi(T) InsertSucc(T const& e);//后插入节点
};

ListNode.cpp:

/*********************************************
ListNode.cpp

 * Created by QSY 2020.10.11
 * Shiyuan Qu, qsy19@mails.tsinghua.edu.cn
 * Department Of Automation, Tsinghua University
 * Copyright (c) 2020. All rights reserved.
**********************************************/

#include "ListNode.h"

template<typename T>
Posi(T) ListNode<T>::InsertPred(T const& e) {
    Posi(T) x = new ListNode(e, pred, this);
    pred->succ = x;
    this->pred = x;
    return x;
}

template<typename T>
Posi(T) ListNode<T>::InsertSucc(T const& e) {
    Posi(T) x = new ListNode(e, this, succ);
    succ->pred = x;
    this->succ = x;
    return x;
}

List.h:

/*********************************************
链表（模板）类 List
本文件绝大多数函数未考虑非法输入情况，调用前请先依据源代码避免非法输入，否则程序的行为将不可预测

 * Created by QSY 2020.10.14
 * Shiyuan Qu, qsy19@mails.tsinghua.edu.cn
 * Department Of Automation, Tsinghua University
 * Copyright (c) 2020. All rights reserved.
**********************************************/
#pragma once
#include "ListNode.h"

template<typename T>
class List
{
private:
    Rank _size;//链表长度，不计头尾
    Posi(T) header;
    Posi(T) trailer;
    //header first …… last trailer
    //  -1     0        n   n + 1
//内部方法
    //可以将p后的n个节点拷贝至当前对象
    void CopyNodes(Posi(T) p, int n);
    //重载swap函数作为内部方法
    void swap(T, T);
    void swap(Posi(T), Posi(T));
protected:
    //初始化整个列表
    void init();
    //清除整个链表的数据，恢复为混沌初开的状态
    void clear();
    
public:
//构造函数
    List() { init(); };
    List(List<T> const& L);//整体复制列表L
    List(List<T> const& L, Rank r, int n);//复制L中自第r项起的n项
    List(Posi(T) p, int n);//复制列表中自位置p起的n项
//析构函数
    ~List();
//
    const Rank& const size = _size;
    Rank size() const { return _size; }
    bool empty() const { return _size <= 0; }
//节点操作接口
    //r->data
    T& operator[] (Rank r) const;//重载下标操作符，以通过秩直接访问列表节点数据
    //r->p
    Posi(T) posi(Rank r);//返回r节点的指针
    Posi(T) posi(List<T> const& L, Rank r);//返回r节点的指针
    //p->r
    Rank rank(Posi(T) p);//返回当前指针的秩
    //data->p
    Posi(T) find(T const& e) const;
    
    Rank distance(Posi(T) p, Posi(T) q);//p在q前！
    Posi(T) first() const;
    Posi(T) last() const;
    Posi(T) selectMax(Posi(T) p, int n);
    
//写入删除接口
    Posi(T) InsertFirst(T const& e);
    Posi(T) InsertLast(T const& e);
    Posi(T) InsertBefore(Posi(T) p, T const& e);
    Posi(T) InsertAfter(Posi(T) p, T const& e);
    T Remove(Posi(T) p);
//排序接口
    void insert_sort();//invalid
    void merge_sort();//o(nlogn)
    Posi(T) merge_sort(Posi(T) p, int n);
    Posi(T) merge(List<T> L, Posi(T) p, int n, Posi(T) q, int m);
    void select_sort();//o(n^2)
    void radix_sort();//invalid
//转置接口
    void reverse();
    void reverse(Posi(T) p1, Posi(T) p2);//p1在p2之前
    void reverse(Rank r1, Rank r2);
};

List.cpp:

/*********************************************
List.cpp

 * Created by QSY 2020.10.11
 * Shiyuan Qu, qsy19@mails.tsinghua.edu.cn
 * Department Of Automation, Tsinghua University
 * Copyright (c) 2020. All rights reserved.
**********************************************/

#include "List.h"
#include <cmath>

template<typename T>
void List<T>::CopyNodes(Posi(T) p, int n) {
    if (!_size) {
        init();
    }
    else {
        clear();
    }
    while (n--) {
        InsertLast(p->data);
        p = p->succ;
    }
}//有改进空间，栈空间占用过多

template<typename T>
void List<T>::swap(T t1, T t2) {
    T tt = t1;
    t1 = t2;
    t2 = tt;
}

template<typename T>
void List<T>::swap(Posi(T) p1, Posi(T) p2) {
    Posi(T) pt = p1;
    p1 = p2;
    p2 = pt;
}

template<typename T>
void List<T>::init() {
    header = new ListNode<T>;
    trailer = new ListNode<T>;
    header->succ = trailer;
    header->pred = nullptr;
    trailer->succ = nullptr;
    trailer->pred = header;
    _size = 0;
}

template<typename T>
void List<T>::clear() {
    int oldsize = _size;
    while (0 < _size) {
        Remove(header->succ);
    }
}

template<typename T>
List<T>::List(List<T> const& L) {
    CopyNodes(L.first(), L._size); 
}

template<typename T>
List<T>::List(List<T> const& L, Rank r, int n) {
    Posi(T) p = Pos(L, r);
    CopyNodes(p, n);
}

template<typename T>
List<T>::List(Posi(T) p, int n) {
    CopyNodes(p, n);
}

template<typename T>
List<T>::~List() {
    clear();
    delete header;
    delete trailer;
}

template <typename T> 
T& List<T>::operator[] (Rank r) const {
    return Pos(r)->data;
}

template<typename T>
Posi(T) List<T>::posi(Rank r) {
    if (_size <= r) {
        return nullptr;
    }//特判，防止请求越界
    Posi(T) p = this->first();
    while (0 < r--) {
        p = p->succ;
    }
    return p;
}

template<typename T>
Posi(T) List<T>::posi(List<T> const& L, Rank r) {
    if (L.size <= r) {
        return nullptr;
    }//特判，防止请求越界
    Posi(T) p = L.first();
    while (0 < r--) {
        p = p->succ;
    }
    return p;
}

template<typename T>
Rank List<T>::rank(Posi(T) p) {
    Rank r = 0;
    Posi(T) ptr = trailer->succ;
    while (p != ptr) {
        ptr = ptr->succ;
        ++r;
    }
    return 0;
}

template<typename T>
Posi(T) List<T>::find(T const& e)const {
    Posi(T) p = trailer->succ;
    for (int i = 0; i < _size; ++i) {
        if (p->data == T) {
            return p;
        }
        p = p->succ;
    }
    return nullptr;
}

template<typename T>
Rank List<T>::distance(Posi(T) p, Posi(T) q) {
    Rank r = 0;
    while (p != q) {
        p = p->succ;
        ++r;
    }
    return r;
}

template<typename T>
Posi(T) List<T>::first() const {
    if (_size) {
        return header->succ;
    }//特判，防止无长度
    return nullptr;
}

template<typename T>
Posi(T) List<T>::last() const {
    if (_size) {
        return trailer->pred;
    }
    return nullptr;
}

template<typename T>
Posi(T) List<T>::selectMax(Posi(T) p, int n) {
    Posi(T) max = p;
    for (; 1 < n; n--) {
        if (max->data <= p->data) {
            max = p;
        }
        p = p->succ;
    }
    return max;
}

template<typename T>
Posi(T) List<T>::InsertFirst(T const& e) {
    _size++;
    return header->InsertSucc(T);
}

template<typename T>
Posi(T) List<T>::InsertLast(T const& e) {
    _size++;
    return trailer->InsertPred(T);
}

template<typename T>
Posi(T) List<T>::InsertBefore(Posi(T) p, T const& e) {
    _size++;
    return p->InsertPred(T);
}

template<typename T>
Posi(T) List<T>::InsertAfter(Posi(T) p, T const& e) {
    _size++;
    return p->InsertSucc(T);
}

template<typename T>
T List<T>::Remove(Posi(T) p) {
    T e = p->data;//备份数据
    //更新指针指向，拆出链表
    p->pred->succ = p->succ;
    p->succ->pred = p->pred;
    delete p;//释放空间
    _size--;
    return e;
}

template<typename T>
void List<T>::insert_sort() {
    //
}

template<typename T>
void List<T>::merge_sort() {
    merge_sort(first(), _size);
}

template<typename T>
Posi(T) List<T>::merge_sort(Posi(T) p, int n) {
    Posi(T) pp = p->pred;
    Posi(T) q = p;
    int m = n >> 2;
    for (int i = 0; i < m; ++i) {
        q = q->succ;
    }
    merge_sort(p, m);
    merge_sort(q, n - m);
    merge(this, p, m, q, n - m);
    return pp->succ;
}

template<typename T>
Posi(T) merge(List<T> L, Posi(T) p, int n, Posi(T) q, int m) {
    Posi(T) pp = p->pred;
    while (0 < m) {//在q未移出区间之前
        if ((0 < n) && p->data <= q->data) {//p未移出区间且p的数据更小
            p = p->succ;
            --n;
        }
        else {
            q = q->succ;
            InsertBefore(p, L.Remove(q->pred));
            --m;
        }
    }
    return pp->succ;
}

template<typename T>
void List<T>::select_sort() {
    int n = _size;
    Posi(T) first = first();
    Posi(T) tail = trailer;
    while (1 < n) {
        Posi(T) max = selectMax(first, n);
        InsertBefore(tail, Remove(max);
        tail = tail->pred;
        --n;
    }
}

template<typename T>
void List<T>::radix_sort() {
    //
}

template<typename T>
void List<T>::reverse() {
    if (_size < 2) {
        return;
    }
    Posi(T) p = header; 
    Posi(T) q = trailer;
    for (int i = 1; i < _size; i += 2) {
        p = p->succ;
        q = q->pred;
        swap(p->data, q->data);
    }
}

template<typename T>
void List<T>::reverse(Posi(T) p1, Posi(T) p2) {
    int n = distance(p1, p2) + 1;
    for (int i = 1; i < n; i += 2) {
        swap(p1->data, p2->data);
        p1 = p1->succ;
        p2 = p2->pred;
    }
}

template<typename T>
void List<T>::reverse(Rank r1, Rank r2) {
    int n = abs(r2 - r1);
    if (n < 2) {
        return;
    }
    if (r1 < r2) {
        Posi(T) p = posi(r1);
        Posi(T) q = posi(r2);
    }
    else {
        Posi(T) q = posi(r1);
        Posi(T) p = posi(r2);
    }
    for (int i = 1; i < n; i += 2) {
        swap(p->data, q->data);
        p = p->succ;
        q = q->pred;
    }
}

//2020.10.15更新，暂未测试