好久没来这里了，放几个数据结构代码吧

单链表的实现：

#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include<iostream>
using namespace std;
//the definition of Node
template <class T>
class Node{
    public:
        Node(T x = 0, Node* p = nullptr):data(x), next(p){}
        T data;     
        Node* next;
};
//the definition of LinkedList
template <class T>
class LinkedList{
    public:
        LinkedList();
        ~LinkedList();
        void insert(int pos, T x);  //insert the Node whose data is x between pos and pos+1(pos starts with 0 which is the position of head)
        void deleteAtPos(int pos);  //delete the Node at pos
        void deleteAtData(T x);     //delete all the Nodes whose data is x
        int getLength();
        void travelList();
        void reverseList();         //reverse the list but head is fixed
        void bubbleSort();          //from min to max(change '<' into '>' if you want it from max to min)
    private:
        Node<T>* head;
        int length;
};
template <class T>
LinkedList<T>::LinkedList(){
    head = new Node<T>();
    length = 0;
}
template <class T>
LinkedList<T>::~LinkedList(){
    Node<T>* p = head;
    while(p->next){
        head = head->next;
        delete p;
        p = head;
    }
    delete p;
    length = 0;
}
template <class T>
void LinkedList<T>::insert(int pos, T x){
    if(pos <= length && pos >= 0){
        Node<T>* p = head;
        for(int i=0;i<pos;i++){
            p = p->next;
        }
        Node<T>* newNode = new Node<T>(x, p->next);
        p->next = newNode;
        length++;
    }
    else cout<<"Out of range"<<endl;
}
template <class T>
void LinkedList<T>::deleteAtPos(int pos){
    if(pos <= length && pos > 0 && length > 0){
        Node<T>* p = head;
        for(int i=0;i<pos-1;i++){
            p = p->next;
        }
        Node<T>* q = p->next;
        p->next = q->next;
        delete q;
        length--;
    }
    else cout<<"Out of range"<<endl;
}
template <class T>
void LinkedList<T>::deleteAtData(T x){
    Node<T>* p = head;
    for(int i=0;i<length;i++){
        p = p->next;
        if(p->data == x) deleteAtPos(i+1);
    }
}
template <class T>
int LinkedList<T>::getLength(){
    return length;
}
template <class T>
void LinkedList<T>::travelList(){
    Node<T>* p = head;
    cout<<"head";
    while(p->next){
        p = p->next;
        cout<<"->"<<p->data;
    }
    cout<<endl;
}
template <class T>
void LinkedList<T>::reverseList(){
    if(length > 1){
        Node<T>* p = head->next;
        Node<T>* q = head->next->next;
        Node<T>* r = nullptr;
        while(q){
            p->next = r;
            r = p;
            p = q;
            q = q->next;
        }
        p->next = r;
        head->next = p;
    }
}
template <class T>
void LinkedList<T>::bubbleSort(){
    Node<T>* p = head->next;
    Node<T>* q = head->next;
    for(; p->next != nullptr; p = p->next){
        for(q = head->next; q->next != nullptr; q = q->next){
            if(q->data>q->next->data){
                T temp = q->data;
                q->data = q->next->data;
                q->next->data = temp;
            }
        }
    }
}
#endif

数组实现栈：

//implemented with an array
#ifndef STACK_H
#define STACK_H
#define MAX_SIZE 10005

#include <iostream>
using namespace std;

template <class T>
class Stack{
    public:
        Stack();
        ~Stack();
        bool isEmpty();
        void push(T x);
        void pop();
        T& getTop();
        int getLength();
        void display();
    private:
        int top;
        T* s;
};
template <class T>
Stack<T>::Stack(){
    s = new T[MAX_SIZE];
    top = -1;
}
template <class T>
Stack<T>::~Stack(){
    delete []s;
}
template <class T>
bool Stack<T>::isEmpty(){
    return (top == -1);
}
template <class T>
void Stack<T>::push(T x){
    if(top + 1 >= MAX_SIZE)
    cout<<"Full"<<endl;
    else{
        s[top + 1] = x;
        top++;
    }
}
template <class T>
void Stack<T>::pop(){
    if(isEmpty()) cout<<"Empty"<<endl;
    else{
        top--;
    }
}
template <class T>
T& Stack<T>::getTop(){
    return s[top];
}
template <class T>
int Stack<T>::getLength(){
    return (top + 1);
}
template <class T>
void Stack<T>::display(){
    if(top == -1) cout<<"Empty"<<endl;
    for(int i = top; i >= 0; i--){
        cout<<s[i]<<endl;
    }
}
#endif

链表实现栈：

#ifndef STACK_H
#define STACK_H
#include<iostream>
using namespace std;

template <class T>
class Node{
    public:
        Node(T x = 0, Node* p = nullptr):data(x), next(p){}
        T data;     
        Node* next;
};
template <class T>
class Stack{
    public:
        Stack();
        ~Stack();
        bool isEmpty();
        void push(T x);
        void pop();
        T& getTop();
        int getLength();
        void display();
    private:
        Node<T>* top;
        int length;
};
template <class T>
Stack<T>::Stack(){
    top = nullptr;
    length = 0;
}
template <class T>
Stack<T>::~Stack(){
    Node<T>* p = top;
    while(p){
        top = top->next;
        delete p;
        p = top;
    }
    length = 0;
}
template <class T>
bool Stack<T>::isEmpty(){
    return (length==0);
}
template <class T>
void Stack<T>::push(T x){
    Node<T>* newNode = new Node<T>(x,top);
    top = newNode;
    length++;
}
template <class T>
void Stack<T>::pop(){
    if(isEmpty()) cout<<"Empty"<<endl;
    else{
        Node<T>* p = top->next;
        delete top;
        top = p;
        length--;
    }
}
template <class T>
T& Stack<T>::getTop(){
    return top->data;
}
template <class T>
int Stack<T>::getLength(){
    return length;
}
template <class T>
void Stack<T>::display(){
    if(isEmpty()) cout<<"Empty"<<endl;
    Node<T>* p = top;
    while(p){
        cout<<p->data<<endl;
        p = p->next;
    }
}
#endif

数组实现队列：

#ifndef QUEUE_H
#define QUEUE_H

#include<iostream>
using namespace std;
#define MAX_SIZE 10005
//Circle Queue
template <class T>
class Queue{
    public:
        Queue();
        ~Queue();
        void enQueue(T x);
        void deQueue();
        bool isEmpty();
        bool isFull();
        T& getHead();
        int getLength();
    private:
        int front;
        int rear;
        T* q;
};

template <class T>
Queue<T>::Queue(){
    q = new T[MAX_SIZE];
    front = rear = 0;
}
template <class T>
Queue<T>::~Queue(){
    delete []q;
}
template <class T>
void Queue<T>::enQueue(T x){
    if(isFull()) cout<<"Full"<<endl;
    else{
        q[rear] = x;
        rear = (rear + 1) % MAX_SIZE;
    }
}
template <class T>
void Queue<T>::deQueue(){
    if(isEmpty()) cout<<"Empty"<<endl;
    else{
        front = (front + 1) % MAX_SIZE;
    }
}
template <class T>
bool Queue<T>::isEmpty(){
    return (front == rear);
}
template <class T>
bool Queue<T>::isFull(){
    return (front == (rear + 1) % MAX_SIZE);
}
template <class T>
T& Queue<T>::getHead(){
    return q[front];
}
template <class T>
int Queue<T>::getLength(){
    return (rear - front + MAX_SIZE) % MAX_SIZE;
}
#endif

链表实现队列：

#ifndef QUEUE_H
#define QUEUE_H

#include<iostream>
using namespace std;

template <class T>
class Node{
    public:
        Node(T x = 0, Node* p = nullptr):data(x), next(p){}
        T data;
        Node* next;
};
template <class T>
class Queue{
    public:
        Queue();
        ~Queue();
        void enQueue(T x);
        void deQueue();
        bool isEmpty();
        T& getHead();
        int getLength();
    private:
        Node<T>* front;
        Node<T>* rear;
};
template <class T>
Queue<T>::Queue(){
    front = rear = new Node<T>();
}
template <class T>
Queue<T>::~Queue(){
    Node<T>* p = front;
    while(front != rear){
        front = front->next;
        delete p;
        p = front;
    }
    delete p;
}
template <class T>
void Queue<T>::enQueue(T x){
    Node<T>* newNode = new Node<T>(x,nullptr);
    rear->next = newNode;
    rear = newNode;
}
template <class T>
void Queue<T>::deQueue(){
    if(isEmpty()) cout<<"Empty"<<endl;
    else{
        Node<T>* p = front->next;
        front->next = p->next;

        if(p == rear) rear = front;     //where I didn't pay attention
        
        delete p;
    }
}
template <class T>
bool Queue<T>::isEmpty(){
    return (front == rear);
}
template <class T>
T& Queue<T>::getHead(){
    return front->next->data;
}
template <class T>
int Queue<T>::getLength(){
    Node<T>* p = front;
    int i=0;
    while(p != rear){
        i++;
        p = p->next;
    }
    return i;
}
#endif

溜了溜了，以后有时间再来吧