单链表 

class MList {
    struct Node {
        int value;
        Node* next;
        Node() :value(0), next(NULL) {}
        Node(int val) :value(val), next(NULL) {}
    };
public:
    MList() :head(NULL), tail(NULL), size(0) {}
    ~MList() {
        Node* tmp = head;
        while (tmp) {
            Node* delete_ptr = tmp;
            tmp = tmp->next;
            delete delete_ptr;
        }
    }
    // 打印list中的值
    void Print() {
        Node* tmp = head;
        while (tmp) {
            cout << tmp->value << endl;
            tmp = tmp->next;
        }
    }
    // 翻转
    void Reverse() {
        Node* next = NULL;
        Node* pre = NULL;
        while (head) {
            Node* next = head->next;
            head->next = pre;
            pre = head;
            head = next;
        }
        head = pre;
    }
    // 删除单链表中value等于num的节点；
    void RemoveValue(int num) {
        Node* tmp = NULL;
        while (head) {
            if (head->value == num) {
                tmp = head->next;
                delete head;
                head = tmp;
                size--;
            }
            else {
                break;
            }
        }

        while (tmp->next != NULL) {
            if (tmp->next->value == num) {
                Node* next = tmp->next;
                tmp->next = next->next;
                delete next;
                size--;
            }
            else {
                tmp = tmp->next;
            }
        }
    }
    // 删除第index位置的节点
    void RemoveNodeByIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }

        if (index == 0) {
            Pop_Front();
        }
        else if (index == size - 1) {
            Pop_Back();
        }
        else {
            Node* tmp = head;
            int count = 0;
            while (tmp && count != index - 1) {
                tmp = tmp->next;
            }

            Node* delete_ptr = tmp->next;
            tmp->next = delete_ptr->next;
            delete delete_ptr;
            size--;
        }
    }
    // 生成一个随机list，个数为number，每个节点的值都是随机数；
    static void GenerateRandomList(MList& my_list, int number) {
        uniform_int_distribution<unsigned> u(0, 20);
        default_random_engine e;            // 生成无符号随机整数
        e.seed(time(NULL));
        my_list.size = number;
        while (number-- > 0) {
            my_list.Push_Back(u(e));
        }
    }
    // 在list尾部增加一个节点，其值为val；
    void Push_Back(int val) {
        size++;
        if (tail == NULL && head == NULL) {
            head = new Node(val);
            tail = head;
            return;
        }
        tail->next = new Node(val);
        tail = tail->next;
    }
    // 在头部插入一个val值的节点；
    void Push_Front(int val) {
        size++;
        if (tail == NULL && head == NULL) {
            head = new Node(val);
            tail = head;
            return;
        }
        Node* tmp = new Node(val);
        tmp->next = head;
        head = tmp;
    }
    // 弹出头部的节点；
    Node Pop_Front() {
        if (size == 0) {
            throw - 1;
        }
        size--;
        Node ret = *head;
        Node* delete_ptr = head;
        head = head->next;
        delete delete_ptr;
        return ret;
    }
    // 弹出尾部的节点
    Node Pop_Back() {
        if (size == 0) {
            throw - 1;
        }
        size--;
        Node* pre = head;
        while (pre->next != tail) {
            pre = pre->next;
        }
        pre->next = NULL;
        Node ret = *tail;               
        delete tail;
        tail = pre;
        return ret;
    }
    // 返回list内节点的个数
    int Size() { return size; }
    bool Empty() { return Size() == 0; }
private:
    Node* head;
    Node* tail;
    int size;
};

队列

class MQueue {
public:
    void Push_front(int val) {
        node_list.Push_Front(val);
    }
    void Push_back(int val) {
        node_list.Push_Back(val);
    }
    MList::Node Pop_front() {
        return node_list.Pop_Front();
    }
    MList::Node Pop_back() {
        return node_list.Pop_Back();
    }
    bool Empty() {
        return node_list.Empty();
    }
    int Size() {
        return node_list.Size();
    }
private:
    MList node_list;
};

二叉树

class MBTree {
    struct Node {
        int val;
        Node* right;
        Node* left;
        Node() :val(0), left(nullptr), right(nullptr) {}
        Node(int val, Node* left, Node* right) :val(val), left(left), right(right) {}
    };
public:
    // 有序数组转换为二叉平衡树
    static Node* sortedArrayToBST(vector<int>& nums) {
        if (nums.size() == 0) {
            return nullptr;
        }
        if (nums.size() == 1) {
            return new Node(nums.at(0), nullptr, nullptr);
        }

        int mid    = nums.size() / 2;
        Node* head = new Node(nums[mid], nullptr, nullptr);
        vector<int> left_nums(nums.begin(), nums.begin() + mid);
        vector<int> right_nums(nums.begin() + mid + 1, nums.end());
        head->left  = sortedArrayToBST(left_nums);
        head->right = sortedArrayToBST(right_nums);
        return head;
    }
private:
    Node* head;
};