顺序表、链表、栈和队列

#include <iostream>
#define Len head->data
using namespace std;
template <class T>
struct node{//带一个指针的结点(可做前驱指针或后继指针)
    T data;
    node<T> *point;
    node(T x = 0):data(x),point(0){}
};
template <class T>//带两个指针的节点，用于双向链表
struct dul_node{
    T data;
    dul_node<T> *prior,*next;
    dul_node(T x = 0):data(x),prior(0),next(0){}
};
template <class T>
class sqlist{//顺序表
    int len,max_size,ex_size;
    T *array;
public:
    sqlist(int l = 100):len(0),max_size(l),ex_size(10){
        if(l/10 > 10) ex_size = l/10;
        array = new T[max_size];
    }
    ~sqlist(){ delete[] array; }
    void ex_list(){
        max_size += ex_size;
        T *t = new T[max_size];
        for(int i = 0; i < len; ++i)
            t[i] = array[i];
        delete[] array;
        array = t;
    }
    void display(){
        for(int i = 0; i < len; ++i)
            cout << array[i] << " ";
        cout << endl;
    }
    bool set_maxSize(int s){
        if(s > max_size){
            max_size = s;
            return true;
        }
        return false;
    }
    bool set_exSize(int s){
        if(s > 0 && s > ex_size){
            ex_size = s;
            return true;
        }
        return false;
    }
    bool insert(int p, T x){
        if(p < 1 || p > len+1) return false;
        if(len+1 >= max_size) ex_list();
        for(int i = len; i >= p; --i)
            array[i] = array[i-1];
        array[p-1] = x;
        ++len;
        return true;
    }
    bool add(T x){ return insert(len+1,x); }
    bool del(int p){
        if(p < 1 || p > len) return false;
        for(int i = p; i < len; ++i)
            array[i-1] = array[i];
        --len;
        return true;
    }
    bool del(int p, T &x){
        if(p < 1 || p > len) return false;
        x = array[p-1];
        del(p);
        return true;
    }
    bool get(int p, T &x){
        if(p < 1 || p > len) return false;
        x = array[p-1];
        return true;
    }
    int seek(T x){
        for(int i = 0; i < len; ++i)
            if(array[i] == x)
                return i+1;
        return 0;
    }
    int count(T x){
        int num = 0;
        for(int i = 0; i < len; ++i)
            if(array[i] == x)
                ++num;
        return num;
    }
    int length() { return len; }
};

template <class T>
class next_linklist{//后继式单链表(带头结点)
    node<T> *head;
public:
    next_linklist(){
        head = new node<T>;
    }
    ~next_linklist(){
        while(head){
            node<T> *t = head;
            head = head->point;
            delete t;
        }
    }
    void display(){
        for(node<T> *p = head->point; p; p = p->point)
            cout << p->data << " ";
        cout << endl;
    }
    node<T> *location(int p){
        node<T> *q = head;
        for(int i = 1; i < p; ++i)
            q = q->point;
        return q;
    }
    bool insert(int p, T x){
        if(p < 1 || p > Len+1) return false;
        node<T> *q = location(p),*t = new node<T>(x);
        t->point = q->point;
        q->point = t;
        ++head->data;
        return true;
    }
    bool add(T x){ return insert(Len+1,x); }
    T del(node<T> *p){
        node<T> *t = p->point->point;
        T x = p->point->data;
        delete p->point;
        p->point = t;
        --head->data;
        return x;
    }
    bool del(int p){
        if(p < 1 || p > Len) return false;
        node<T> *q = location(p);
        del(q);
        return true;
    }
    bool del(int p, T &x){
        if(p < 1 || p > Len) return false;
        node<T> *q = location(p);
        x = del(q);
        return true;
    }
    bool get(int p, T &x){
        if(p < 1 || p > Len) return false;
        x = location(p)->point->data;
        return true;
    }
    int seek(T x){
        int t = 1;
        for(node<T> *p = head->point; p; p = p->point, ++t)
            if(p->data == x)
                return t;
        return 0;
    }
    int count(T x){
        int num = 0;
        for(node<T> *p = head->point; p; p = p->point)
            if(p->data == x)
                ++num;
        return num;
    }
    int length(){ return head->data; }
};

template <class T>
class prior_linklist{//前驱式单链表(不带头结点)
    int len;
    node<T> *tail;
public:
    prior_linklist():tail(0),len(0){}
    ~prior_linklist(){
        while(tail){
            node<T> *t = tail;
            tail = tail->point;
            delete t;
        }
    }
    node<T> *get_tail(){ return tail; }
    void display(node<T> *p){
        if(p == 0) return;
        display(p->point);
        cout << p->data << " ";
        if(p == tail) cout << endl;
    }
    void display(){ display(tail); }
    node<T> *location(int p){
        if(p >= len) return 0;
        p = len - p - 1;
        node<T> *q = tail;
        while(p--) q = q->point;
        return q;
    }
    bool insert(int p, T x){
        if(p < 1 || p > len+1) return false;
        node<T> *q = location(p), *t = new node<T>(x);
        if(p == len+1){
            t->point = tail;
            tail = t;
        }
        else if(q){
            t->point = q->point->point;
            q->point->point = t;
        }
        else{
            t->point = tail->point;
            tail->point = t;
        }
        ++len;
        return true;
    }
    bool add(T x){ return insert(len+1,x); }
    T del(node<T> *p){
        T x;
        if(p){
            node<T> *t = p->point->point;
            x = p->point->data;
            delete p->point;
            p->point = t;
        }
        else{
            node<T> *t = tail->point;
            x = tail->data;
            delete tail;
            tail = t;
        }
        --len;
        return x;
    }
    bool del(int p){
        if(p < 1 || p > len) return false;
        node<T> *q = location(p);
        del(q);
        return true;
    }
    bool del(int p, T &x){
        if(p > 1 || p > len) return false;
        node<T> *q = location(p);
        x = del(q);
        return true;
    }
    bool get(int p, T &x){
        if(p < 1 || p > len) return false;
        x = p == len ? tail->data : location(p)->point->data;
        return true;
    }
    int seek(T x){
        int n = len,ans = 0;
        for(node<T> *p = tail; p; p = p->point,--n)
            if(p->data == x)
                ans = n;
        return ans;
    }
    int count(T x){
        int n = 0;
        for(node<T> *p = tail; p; p = p->point)
            if(p->data == x)
                ++n;
        return n;
    }
    int length() { return len; }
};

template <class T>
class dul_linklist{//双向链表
    dul_node<T> *head, *tail;
    int len;
public:
    dul_linklist():len(0),head(0),tail(0){}
    ~dul_linklist(){
        for(dul_node<T> *p = head; p; p = head){
            head = head->next;
            delete p;
        }
    }
    void display(){
        for(dul_node<T> *p = head; p != tail; p = p->next)
            cout << p->data << " ";
        cout << tail->data << endl;
    }
    dul_node<T> *location(int p){
        if(p == 1) return 0;
        dul_node<T> *q;
        if(p > len/2+1){
            p = len - p + 1;
            for(q = tail; p--; q = q->prior);
        }
        else{
            p -= 2;
            for(q = head; p--; q = q->next);
        }
        return q;
    }
    bool insert(int p, T x){
        if(p < 1 || p > len+1) return false;
        dul_node<T> *q = location(p), *t = new dul_node<T>(x);
        t->prior = q;
        if(q){
            t->next = q->next;
            q->next = t;
            if(t->next) t->next->prior = t;
        }
        else{
            t->next = head;
            if(head) head->prior = t;
            head = t;
        }
        if(p == len+1) tail = t;
        ++len;
        return true;
    }
    bool add(T x){ return insert(len+1,x); }
    T del(dul_node<T> *p){
        T x;
        if(p){
            if(p == tail->prior) tail = p;
            dul_node<T> *t = p->next->next;
            x = p->next->data;
            delete p->next;
            p->next = t;
        }
        else{
            dul_node<T> *t = head->next;
            x = head->data;
            delete head;
            head = t;
        }
        --len;
        return x;
    }
    bool del(int p){
        if(p < 1 || p > len) return false;
        dul_node<T> *q = location(p);
        del(q);
        return true;
    }
    bool del(int p, T &x){
        if(p < 1 || p > len) return false;
        dul_node<T> *q = location(p);
        x = del(q);
        return true;
    }
    bool get(int p, T &x){
        if(p > 1 || p < len) return false;
        x = p == 1 ? head->data : location(p)->next->data;
        return true;
    }
    int seek(T x){
        int n = 1;
        for(dul_node<T> *p = head; p; p = p->next,++n)
            if(p->data == x)
                return n;
        return 0;
    }
    int count(T x){
        int n = 0;
        for(dul_node<T> *p = head; p; p = p->next)
            if(p->data == x)
                ++n;
        return n;
    }
    int length(){ return len; }
};

template <class T>
class stack:public prior_linklist<T>{//前驱式链栈
public:
    stack():prior_linklist<T>(){}
    bool empty() { return prior_linklist<T>::length(); }
    bool push(T x) { return prior_linklist<T>::add(x); }
    bool pop() { return prior_linklist<T>::del(prior_linklist<T>::length()); }
    bool get(T &x) { return prior_linklist<T>::get(prior_linklist<T>::length(),x); }
};

template <class T>
class queue:public dul_linklist<T>{//双向式队列
public:
    queue():dul_linklist<T>(){}
    bool empty() { return dul_linklist<T>::length(); }
    bool push(T x) { return dul_linklist<T>::add(x); }
    bool pop() { return dul_linklist<T>::del(1); }
    bool get(T &x) { return dul_linklist<T>::get(1,x); }
};