C++ 单链表的实现

#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#define MAXLEN 256
template <class T>
struct LinkedList {
    struct Node {
        Node* next = ; // necessary!!!
        T key;
    };
    Node* head = ;

    T* listSearch(const T& k);
    void listInsert(const T& k);
    void listDelete(const T& k);
    void reverse();
};

template <class T>
T* LinkedList<T>::listSearch(const T& k) {
    Node* x = head;
    while (x !=  && x->key != k) {
        x = x->next;
    }

    if (x == ) {
        return ;
    }
    T* temp = &(x->key);
    return temp; // Returns a pointer to the data
}

template <class T>
void LinkedList<T>::listInsert(const T& k) {
    Node* x = new Node();
    x->key = k;
    if (head != ) {
        x->next = head;
    }
    head = x;
}

template <class T>
void LinkedList<T>::listDelete(const T& k) {
    Node* deleteOne = head;
    Node* last = ;
    while (deleteOne !=  && deleteOne->key != k) {
        last = deleteOne;
        deleteOne = deleteOne->next;
    }
    if (deleteOne == ) {
        ;
    } else if (deleteOne == head) {
        head = deleteOne->next;
    } else {
        last->next = deleteOne->next;
    }
}

template <class T>
void LinkedList<T>::reverse() {
    Node* temp[MAXLEN];
    for (int i = ; i != MAXLEN; ++i) {
        temp[i] = ;
    }

    int k = ;
    Node* x = head;
    while (x != ) {
        temp[k] = x;
        x = x->next;
        ++k;
    }

    temp[]->next = ;
    head = temp[k-];
    for (int i = ; i != k; ++i) {
        temp[i]->next = temp[i-];
    }
}
#endif

#ifndef USER_H
#define USER_H
#include <string>
struct User {
    std::string username;
    std::string password;
    User(std::string x, std::string y): username(x), password(y) {}
    User() = default;

    bool operator==(const User &left) {
        if (this->username == left.username) return true;
        return false;
    }

    bool operator!=(const User &left) {
        if (this->username != left.username) return true;
        return false;
    }
};

#endif

#ifndef MYSYSTEM_H
#define MYSYSTEM_H
struct MySystem {
    LinkedList<User> onlineList;
    bool login(User user);
    bool logout(User user);
};

bool MySystem::login(User user) {
    onlineList.listInsert(user);
    if (onlineList.listSearch(user) != ) return true;
    return false;
}

bool MySystem::logout(User user) {
    onlineList.listDelete(user);
    if (onlineList.listSearch(user) == ) return true;
    return false;
}
#endif

#include <iostream>
using namespace std;

int main()
{
    LinkedList<int> listInt;

    listInt.listInsert();
    listInt.listInsert();
    listInt.listInsert();
    listInt.listInsert();
    listInt.listInsert();
    listInt.listDelete();
    listInt.reverse();

    cout << listInt.listSearch() << endl;
    cout << listInt.listSearch() << endl;
    cout << listInt.listSearch() << endl;
    return ;
}

二叉树相关，留着备用：

#include <stdio.h>
#include <iostream>
#include <queue>
using namespace std;

typedef struct bnode {
    int data;
    struct bnode *lc, *rc;
} bnode_type;  

// 前序遍历
int prosearch(bnode_type *root) {
    if (root != NULL) {
        printf("%c\n", root->data);
        prosearch(root->lc);
        prosearch(root->rc);
    }
    return ;
}

// 后序遍历
int postsearch(bnode_type *root) {
    if (root != NULL) {
        prosearch(root->lc);
        prosearch(root->rc);
        printf("%c\n", root->data);
    }
    return ;
}  

// 前序建立二叉树
bnode_type* creat(bnode_type* root) {
    char c;
    cout << "Enter:" << endl;
    cin >> c;
    if (c != '#') {
        root = new bnode_type();
        root->data = c;
        root->lc = creat(root->lc);
        root->rc = creat(root->rc);
    } else {
        root = NULL;
    }
    return root;
}  

// 计算树的高度
int deepth(bnode_type* root) {
    if (root != NULL) {
        int a = deepth(root->lc);
        int b = deepth(root->rc);
        return ((a > b) ? a+ : b+);
    }
    return ;
}

// 计算节点数量
int nodes(bnode_type* root) {
    if (root != NULL) {
        return nodes(root->lc) + nodes(root->rc) + ;
    }
    return ;
}

// 层序遍历
queue<bnode_type*> mark;
void levelOrderTraverse(bnode_type* root) {
    if (root == NULL) return;
    mark.push(root);
    while (mark.size() != ) {
        bnode_type* temp = mark.front();
        printf("%c\n", temp->data);
        if (temp->lc != NULL) mark.push(temp->lc);
        if (temp->rc != NULL) mark.push(temp->rc);
        mark.pop();
    }
}

int main()
{
    /* 前序地建立二叉树，输入#表示节点为空 */
    bnode_type* p = NULL;
    p = creat(p);
    cout << "deepth=" << deepth(p) << endl; //
    cout << "nodes=" << nodes(p) << endl; //
    levelOrderTraverse(p);
    return ;
}