#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 ;

}