数据结构

链表:

/*************************************************************************
    > File Name: List_BaseArray.cpp
    > Author: yijiull
    > Mail: 1147161372@qq.com 
    > Created Time: 2017年12月09日 星期六 15时57分11秒
 ************************************************************************/

#include <bits/stdc++.h>
using namespace std;
template<typename T>
class List{
private:
    int maxsize;
    int cnt;
    int cur;
    T *listArray;
public:
    void setStart(){
        cur = 0;
    }
    void setEnd(){
        cur = cnt;
    }
    void pre(){
        cur--;
    }
    void nxt(){
        cur++;
    }
    int leftLength(){
        return cur;
    }
    int rightLength(){
        return cnt - cur;
    }
    void setPos(int pos){
        cur = pos;
    }
    T getVal(){
        return listArray[cur];
    }
    void insert(T temp){
        for(int i = cnt; i > cur; i--){
            listArray[i] = listArray[i-1];
        }
        listArray[cur] = temp;
        cnt++;
    }
    void append(T temp){
        listArray[cnt++] = temp;
    }
    T remove(){
        T temp = listArray[cur];
        for(int i = cur; i < cnt; i++){
            listArray[i] = listArray[i+1];
        }
        cnt--;
        return temp;
    }
};
int main(){

}

/*************************************************************************
    > File Name: List_BaseLink.cpp
    > Author: yijiull
    > Mail: 1147161372@qq.com 
    > Created Time: 2017年12月09日 星期六 16时09分37秒
 ************************************************************************/

#include <bits/stdc++.h>
using namespace std;

const int maxn = 10010;
int ary[maxn];
template<typename T>
class Node{
public:
    T x;
    Node *nxt;
    Node(T temp, Node *p = NULL){
        x = temp;
        nxt = p;
    }
    Node(Node *p = NULL){
        nxt = p;
    }
};
template<typename T>
class List{
private:
    Node<T> *head, *tail, *cur;
    int lcnt, rcnt;
public:
    List(int sz = maxn){
        init();
    }
    void init(){
        cur = head = tail = new Node<T>();
        lcnt = rcnt = 0;
    }
    ~List(){
        removeAll();
    }
    void clear(){
        removeAll();
        init();
    }
    void removeAll(){
        while(head != NULL){
            cur = head;
            delete cur;
            head = head->nxt;
        }
    }
    void setStart(){
        cur = head;
        rcnt += lcnt;
        lcnt = 0;
    }
    void setEnd(){
        cur = tail;
        lcnt += rcnt;
        rcnt = 0;
    }
    int leftLength(){
        return lcnt;
    }
    int rightLength(){
        return rcnt;
    }
    T getVal(){
        T temp = cur->nxt->x;
        return temp;
    }
    void insert(T temp){
        cur->nxt = new Node<T>(temp, cur->nxt);
        if(tail == cur) tail = cur->nxt;
        rcnt++;
    }
    void append(T temp){
        tail->nxt = new Node<T>(temp);
        tail = tail->nxt;
        rcnt++;
    }
    T remove(){
        T temp = cur->nxt->x;
        Node<T> *p = cur->nxt;
        cur->nxt = p->nxt;
        if(tail == p){
            tail = cur;
        }
        delete p;
        rcnt--;
        return temp;
    }
    bool pre(){
        if(pre == head){
            return false;
        }
        Node<T> *temp = head;
        while(temp->nxt != cur) temp = temp->nxt;
        cur = temp;
        lcnt--;
        rcnt++;
        return true;
    }
    bool nxt(){
        if(cur->nxt == tail){
            return false;
        }
        cur = cur->nxt;
        lcnt++;
        rcnt--;
        return true;
    }
    void setPos(int pos){
        cur = head;
        for(int i = 0; i < pos; i++){
            cur = cur->nxt;
        }
        rcnt = rcnt + lcnt - pos;
        lcnt = pos;
    }
};

int main(){
    for(int i= 0 ; i < maxn; i++) ary[i] = rand() % 1313131;
    while(1){
        cout<<"请输入链表长度："<<endl;
        int n;
        cin>>n;
        for(int i = 0; i < n; i++) cout<<ary[i]<<" ";
        cout<<endl;
        List<int> list;
        list.init();
        list.insert(ary[0]);
        for(int i = 1; i < n; i++){
            list.append(ary[i]);
        }
        cout<<list.leftLength()<<endl;
        cout<<list.rightLength()<<endl;
        cout<<list.getVal()<<" ";
        while(list.nxt()){
            cout<<list.getVal()<<" ";
        }
        cout<<endl;
    }
    
}

BST

/*************************************************************************
    > File Name: bitree.cpp
    > Author: yijiull
    > Mail: 1147161372@qq.com 
    > Created Time: 2017年11月12日 星期日 15时05分20秒
 ************************************************************************/
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class Node{
public:
    T date;
    Node *L, *R;
    Node(){}
    Node(T date, Node<T> *L = NULL, Node<T> *R = NULL) : date(date), L(L), R(R){}
//    T& getVal(){
//        return date;
//    }
//    void setVal(T x){
//        date = x;
//    }
//    Node<T>* getLeftChild(){
//        return *L;
//    }
//    Node<T>* getRightChild(){
//        return *R;
//    }
//    void setLeftChild(Node *b){
//        L = b;
//    } 
//    void setRightChild(Node *b){
//        R = b;
//    }
//    bool isLeaf(){
//        return L == NULL && R == NULL;
//    }
};
template <typename T>
class bitree{
private:
    Node<T> * rt;
public:
    bitree(){
        rt = NULL;
    }
    Node<T>*& getRoot(){
        return rt;
    }
    Node<T>* getptrRoot(){
        return rt;
    }
    void preOrder(Node<T> *sub){
        if(sub == NULL){
            return ;
        }
        cout<<sub->date<<" ";
        preOrder(sub->L);
        preOrder(sub->R);
    }
    void inOrder(Node<T> *sub){
        if(sub == NULL) {
            return ;
        }
        inOrder(sub->L);
        cout<<sub->date<<" ";
        inOrder(sub->R);
    }
    void postOrder(Node<T> *sub){
        if(sub == NULL){
            return ;
        }
        postOrder(sub->L);
        postOrder(sub->R);
        cout<<sub->date<<" ";
    }
    void traverse(){
        puts("前序遍历: ");
        preOrder(getptrRoot());
        cout<<endl;
        puts("中序遍历: ");
        inOrder(getptrRoot());
        cout<<endl;
        puts("后序遍历: ");
        postOrder(getptrRoot());
        cout<<endl;
    }
    void addNode(Node<T> *&tp, T x){
        if(tp == NULL){
            Node<T> *p = new Node<T>(x);
            tp = p;
        }else if(tp->date > x){
            addNode(tp->L, x);
        }else{
            addNode(tp->R, x);
        }
    }
    void levelTraverse(){
        queue<Node<T> *> q;
        cout<<"层次遍历: 
";
        if(rt != NULL) q.push(rt);
        while(!q.empty()){
            Node<T> *p = q.front();
            q.pop();
            cout<<p->date<<" ";
            if(p->L != NULL) q.push(p->L);
            if(p->R != NULL) q.push(p->R);
        }
        cout<<endl;
    }
};
template <typename T>
void countLeaves(Node<T> *p, int &cnt){
    if(p->L == NULL && p->R == NULL){
        cnt++;
        return ;
    }else {
        if(p->L != NULL) countLeaves(p->L, cnt);
        if(p->R != NULL) countLeaves(p->R, cnt);
    }
}
int height;
template <typename T>
void countLevel(Node<T> *p, int h){
    if(p->L == NULL && p->R == NULL){
        height = max(height, h);
        return ;
    }else{
        if(p->L != NULL) countLevel(p->L, h+1);
        if(p->R != NULL) countLevel(p->R, h+1);
    }

}
void init(){
    freopen("in.txt", "w", stdout);
    for(int i = 0; i < 100; i++){
        int n = rand()%13 + 5;
        cout<<n<<endl;
        for(int j = 0; j < n; j++){
            cout<<rand() % 1313131<<" ";
        }
        cout<<endl;
    }
}
int main(){
    init();
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    int n;
    int kase = 0;
    while(cin>>n){
        cout<<"
Case #"<<++kase<<":
";
        bitree<int> bt;
        for(int i = 0; i < n; i++){
            int x;
            cin>>x;
            bt.addNode(bt.getRoot(), x);
        }
        bt.traverse();
        bt.levelTraverse();
        int cnt = 0;
        countLeaves(bt.getptrRoot(), cnt);
        cout<<"叶子数： "<<cnt<<endl;
        int h = 0;
        height = 0;
        countLevel(bt.getptrRoot(), h);
        cout<<"层数：　"<<height<<endl;
    }
}

Heap

#include <iostream>
using namespace std;

template<typename T>
class Heap{
public:
    T *h;
    int n;
    int size;
public:
    Heap(T *h, int n, int size){
        this.h = h;
        this.n = n;
        this.size = size;
    }
    int lson(int pos){
        return pos*2+1;
    }
    int rson(int pos){
        return pos*2+2;
    }
    int par(int pos){
        return (pos-1)/2;
    }
    bool isLeaf(int pos){
        return pos >= pos/2 && pos < n;
    }
    void siftdown(int pos){
        while(!isLeaf(pos)){
            int lc = lson(pos);
            int rc = rson(pos);
            if(rc < n && h[lc] < h[rc]) lc = rc;
            if(h[pos] >= h[lc]) return;
            swap(h[pos], h[lc]);
            pos = lc;
        }
    }
    void buildHeap(){
        for(int i = n/2-1; i >= 0; i--) siftdown(i);
    }

    bool removemax(T &it){
        if(n == 0) return false;
        swap(h[0], h[--n]);
        if(n != 0) siftdown(0);
        it = h[n];
        return true;
    }
    bool insert(const T &it){
        if(n >= size) return false;
        int cur = n++;
        h[cur] = it;
        while(cur != 0 && h[cur] > h[par(cur)]){
            swap(h[cur], h[par[cur]]);
            cur = par(cur);
        }
        return true;
    }
};

int main(){

}

排序

/*************************************************************************
  > File Name: 8sort.cpp
  > Author: yijiull
  > Mail: 1147161372@qq.com 
  > Created Time: 2017年11月14日 星期二 22时12分19秒
 ************************************************************************/

#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000010;
const int mod = 13131313;

int a[maxn], c[maxn], ary[maxn];
template <typename T>
void print(T *a, int n){
    for(int i = 0; i < n; i++){
        cout<<a[i]<<" ";
    }
    cout<<endl;
}

template <typename T>
void insertSort(T *a, int n){
    for(int i = 1; i < n; i++){
        for(int j = i; j > 0 && a[j] < a[j-1]; j--){
            swap(a[j], a[j-1]);
        }
    }
}

template <typename T>
void bubbleSort(T *a, int n){
    for(int i = 0; i < n - 1; i++){
        int ok = 0;
        //0到ｉ已经排好序
        for(int j = n - 1; j > i; j--){
            if(a[j] < a[j-1]) {
                swap(a[j], a[j-1]);
                ok = 1;
            }
        }
        if(!ok) break;
    }
}
template <typename T>
void doubleSelectSort(T *a, int n){
    for(int i = 0; i < n; i++){
        //从ｊ到ｎ找到最小的元素和ｉ交换
        int min = i, max = n - 1 - i;
        for(int j = i; j <= n - 1 - i; j++){
            if(a[j] < a[min]) min = j;   //稳定
            if(a[j] > a[max]) max = j;
        }
        swap(a[i], a[min]);
        swap(a[n-i-1], a[max]);
    }
}
template <typename T>
void selectSort(T *a, int n){
    for(int i = 0; i < n; i++){
        //从ｊ到ｎ找到最小的元素和ｉ交换
        int id = i;
        for(int j = i + 1; j < n; j++){
            if(a[j] < a[id]) id = j;   //稳定
        }
        swap(a[i], a[id]);
    }
}

template <typename T>
void insertSort(T *a, int n, int from, int incr){
    for(int i = from + incr; i < n; i += incr){
        for(int j = i; j > from && a[j] < a[j-incr]; j -= incr){
            swap(a[j], a[j-incr]);
        }
    }
}
template <typename T>
void shellSort(T *a, int n){
    //分
    for(int i = n / 2; i >= 1; i /= 2){
        for(int j = 0; j < i; j++){
            insertSort(a, n, j, i);
        }
    }
}

template <typename T>
void quickSort(T *a, int s, int e, int n){
    if(s >= e) return ;
    int id = s;
    T temp = a[id];
    int i = s, j = e;
    while(i < j){
        while(j > i && a[j] >= temp) j--;
        if(i < j){
            a[i++] = a[j];
        }
        while(i < j && a[i] < temp) i++;
        if(i < j) {
            a[j--] = a[i];
        }
    }
    a[i] = temp;
    quickSort(a, s, i-1, n);
    quickSort(a, i+1, e, n);
    return ; 
}
template <typename T>
void mergeSort(T *a, int l, int r, T *c){
    if(r - l > 1) {
        int m = l + (r - l) / 2;
        int p = l, q = m, i = l;
        mergeSort(a, l, m, c);
        mergeSort(a, m, r, c);
        while(p < m || q < r){
            if(q >= r || (p < m && a[p] <= a[q])) c[i++] = a[p++];
            else c[i++] = a[q++];
        }
        for(int i = l; i < r; i++) a[i] = c[i];
    }
}

//template <typename T>
//class MaxHeap{
//    public:
//        int cnt;
//        T heap[maxn];
//
//        MaxHeap(){}
//        MaxHeap(T *a, int n){
//            init(a, n);
//        }
//        void init(T *a, int n){
//            cnt = 0;
//            for(int i = 0; i < n; i++) heap[++cnt] = a[i];
//            for(int i = cnt / 2; i >= 1; i--) siftdown(i);
//        }
//        void init(){
//            cnt = 0;
//        }
//
//        void buildHeap(T *a, int n){
//            for(int i = 0; i < n; i++) heap[++cnt] = a[i];
//            for(int i = cnt / 2; i >= 1; i--) siftdown(i);
//        }
//        void siftdown(int pos){
//            while(pos <= cnt/2){
//                int ls = pos * 2;
//                int rs = pos * 2 + 1;
//                if(rs <= cnt && heap[ls] < heap[rs]){
//                    ls = rs;
//                }
//                if(heap[pos] >= heap[ls]) return ;
//                swap(heap[pos], heap[ls]);
//                pos = ls;
//            }
//        }
//        bool insert(T x){
//            int cur = ++cnt;
//            heap[cur] = x;
//            while(cur != 1 && heap[cur] > heap[cur/2]){
//                swap(heap[cur], heap[cur/2]);
//                cur /= 2;
//            }
//            return 1;
//        }
//        T removeMax(){
//            swap(heap[1], heap[cnt--]);
//            if(cnt != 1) siftdown(1);
//            return heap[cnt+1];
//        }
//        //?
//        void remove(int pos, T &it){
//            swap(heap[pos], heap[cnt--]);
//            while(pos != 1 && heap[pos] > heap[pos / 2]){
//                swap(heap[pos], heap[pos / 2]);
//                pos /= 2;
//            }
//            siftdown(pos);
//            it = heap[cnt+1];
//        }
//        void print(){
//            for(int i = 1; i <= cnt; i++) cout<<heap[i]<<" ";
//            cout<<endl;
//        }
//};
//MaxHeap<int> H;
//
//
//template <typename T>
//void heapSort(T *a, int n){
//    //MaxHeap<T> H(a, n);
//    //MaxHeap<T> H;
//    //H.init();
//    //for(int i = 0; i < n;  i++) H.insert(a[i]);
//    //H.print();
//    H.init(a, n);
//    for(int i = 0; i < n; i++){
//        a[n-i-1] = H.removeMax();
//    }
//}
void siftdown(int cur, int n){
    while(cur <= n/2){
        int ls = cur * 2;
        int rs = cur * 2 + 1;
        if(rs <= n && a[ls] < a[rs]) ls = rs;
        if(a[cur] >= a[ls]) break;
        swap(a[cur], a[ls]);
        cur = ls;
    }
}

template <typename T>
void buildHeap(T *a, int n){
    for(int i = n / 2; i >= 1; i--){
        siftdown(i, n);
    }
}

template <typename T>
void heapSort(T *a, int n){
    for(int i = n; i > 0; i--) a[i] = a[i-1];
    buildHeap(a, n);
    for(int i = n; i >= 1; i--){
        swap(a[1], a[i]);
        siftdown(1, i - 1);
    }
    for(int i = 0; i < n; i++){
        a[i] = a[i+1];
    }
}


template <typename T>
void binSort(T *a, int n, T *c){
    for(int i = 0; i < mod; i++){
        c[i] = 0;
    }
    for(int i = 0; i < n; i++){
        c[a[i]]++;
    }
    int cur = 0;
    for(int i = 0; i < mod; i++){
        for(int j = 0; j < c[i]; j++){
            a[cur++] = i;
        } 
    }
}

template <typename T> 
int maxBit(T *a, int n){
    int d = 1;
    int p = 10;
    for(int i = 0; i < n; i++){
        while(a[i] >= p){
            p *= 10;
            d++;
        }
    }
    return d;
}
template <typename T>
void radixSort(T *a, int n, T *c){
    int d = maxBit(a, n);
    int radix = 1;
    int *cnt = new int[10];
    for(int k = 1; k <= d; k++){
        for(int i = 0; i < 10; i++){
            cnt[i] = 0;
        }
        for(int i = 0; i < n; i++){
            int k = (a[i] / radix) % 10;
            cnt[k]++;
        }
        for(int i = 1; i < 10; i++){
            cnt[i] = cnt[i-1] + cnt[i];
        }
        for(int i = n - 1; i >= 0; i--){
            int k = (a[i] / radix) % 10;
            c[--cnt[k]] = a[i];
        }
        for(int i = 0; i < n; i++){
            a[i] = c[i];
        }
        radix *= 10;
    }
    delete[] cnt;
}

template <typename T>
void Sort(T *a, int n, T *c){
    double st, ed;
    for(int i = 0; i < n; i++){
        a[i] = ary[i];
    }
    st = clock();
    insertSort(a, n);
    ed = clock();
    cout<<"插入排序："<<ed-st<<endl;
    for(int i = 0; i < n; i++){
        a[i] = ary[i];
    }
    st = clock();
    bubbleSort(a, n);
    ed = clock();
    cout<<"冒泡排序："<<ed-st<<endl;
    for(int i = 0; i < n; i++){
        a[i] = ary[i];
    }
    st = clock();
    selectSort(a, n);
    ed = clock();
    cout<<"选择排序："<<ed-st<<endl;
    for(int i = 0; i < n; i++){
        a[i] = ary[i];
    }
    st = clock();
    shellSort(a, n);
    ed = clock();
    cout<<"希尔排序："<<ed-st<<endl;
    for(int i = 0; i < n; i++){
        a[i] = ary[i];
    }
    st = clock();
    quickSort(a, 0, n-1, n);
    ed = clock();
    cout<<"快速排序："<<ed-st<<endl;
    //print(a, n);
    for(int i = 0; i < n; i++){
        a[i] = ary[i];
    }
    st = clock();
    mergeSort(a, 0, n, c);
    ed = clock();
    //print(a, n);
    cout<<"归并排序："<<ed-st<<endl;
    for(int i = 0; i < n; i++){
        a[i] = ary[i];
    }
    st = clock();
    heapSort(a, n);
    ed = clock();
    cout<<"堆排序："<<ed-st<<endl;
    //for(int i = 0; i < n; i++){
    //    cin>>a[i];
    //}
    //st = clock();
    //binSort(a, n, c);
    //ed = clock();
    //cout<<"箱排序："<<ed-st<<endl;
    for(int i = 0; i < n; i++){
        a[i] = ary[i];
    }
    st = clock();
    radixSort(a, n, c);
    ed = clock();
    cout<<"基数排序："<<ed-st<<endl;
}
int main(){
    for(int i = 0; i < maxn; i++) ary[i] = rand() % mod;
    while(1){
        cout<<"请输入数据规模：
";
        int n;
        cin>>n;
        if(n == 0) break;
        Sort(a, n, c);
    }
    return 0;
}

哈希

/*************************************************************************
    > File Name: hash.cpp
    > Author: yijiull
    > Mail: 1147161372@qq.com 
    > Created Time: 2017年12月17日 星期日 18时37分05秒
 ************************************************************************/

#include <bits/stdc++.h>
using namespace std;

const int maxn = 10010;
int ary1[maxn], ary2[maxn];
int randarray[maxn];

int testcnt;

template <typename Key, typename Val>
class Node{
private:
    Key key;
    Val val;
public:
    Node(){}
    Node(Key key, Val val) : key(key), val(val){}
    void set(Key tk,Val tv){
        key = tk;
        val = tv;
    }
    void setKey(Key k){
        key = k;
    }
    Key getKey(){
        return key;
    }
    Val getVal(){
        return val;
    }
};

template <typename Key, typename Val>
class HashTable{
private:
    Node<Key, Val>* HT;
    int M;  //size of HashTable
    int cur;
    Key EMPTY;
    int p(Key k, int i, int flag){
        if(flag == 0) return linear_probing(k, i);
        if(flag == 1) return quadratic_probing(k, i);
        return random_probing(k, i);
    }
    int linear_probing(Key k, int i){
        return i;
    }
    //平方探测
    int quadratic_probing(Key k, int i){
        return i * i;
    }
    //随机探测
    int random_probing(Key k, int i){
        return randarray[i];
    }

    int h(int x){
        return x % M;
    }
    int h(char* s){
        int i = 0, sum = 0;
        for(; s[i] != '
'; i++){
            sum += (int)s[i];
        }
        return sum % M;
    }
    Val hashSearch(Key& k){
        int home;
        int pos = home = h(k);
        for(int i = 1; k != HT[pos].getKey() && EMPTY != HT[pos].getKey(); i++){
            pos = (home + p(k, i)) % M;
            testcnt++;
        }
        if(k == HT[pos].getKey()){
            return HT[pos].getVal();
        }
        return EMPTY;
    }
    void hashInsert(Key& k, Val& v, int flag){
        int home;
        int pos = home = h(k);
        for(int i = 1; EMPTY != HT[pos].getKey(); i++){
            pos = (home + p(k, i, flag)) % M;
            testcnt++;
        }
        HT[pos].set(k, v);
    }

public:
    HashTable(){}
    HashTable(int sz, Key k){
        init(sz, k);
    }
    ~HashTable(){
        delete HT;
    }
    void init(int sz, Key k){
        M = sz;
        HT = new Node<Key, Val> [sz];
        for(int i = 0; i < sz; i++){
            HT[i].setKey(EMPTY);
        }
    }
    Val find(Key& k){
        testcnt = 0;
        return hashSearch(k);
    }
    int size(){
        return cur;
    }
    void insert(Key& k, Val& v, int flag){
        testcnt = 0;
        hashInsert(k, v, flag);
        cur++;
    }
};
HashTable<int, int> hs;


int main(){
    for(int i = 0 ; i < maxn; i++) {
        ary1[i] = rand() % 131313;
        ary2[i] = rand() % 1313131313 * 131 % 131313;
    }
    sort(ary1, ary1 + maxn);
    int m = unique(ary1, ary1 + maxn) - ary1;
    int n, slot;
    cout<<"请输入数据个数以及slot数"<<endl;
    cin>>n>>slot;
    int cnt = rand() % 13131313 + 134 ;
    for(int i = 0; i < slot; i++) randarray[i] =  slot - i;
    for(int i = 0; i  < cnt; i++){
        next_permutation(randarray, randarray + slot);
    }
    for(int i = 0; i < slot; i++) cout<<randarray[i]<< " ";
    cout<<endl;
    testcnt = 0;
    hs.init(slot, 0x3f3f3f3f);
    cout<<"依次输入元素键值对为:"<<endl;
    for(int i = 0; i < n; i++){
        hs.insert(ary1[i], ary2[i], 0);
    }
    cout<<"线性探测碰撞次数:"<<testcnt<<endl;
    testcnt = 0;
    hs.init(slot, 0x3f3f3f3f);
    for(int i = 0; i < n; i++){
        hs.insert(ary1[i], ary2[i], 1);
    }
    cout<<"平方探测碰撞次数:"<<testcnt<<endl;
    testcnt = 0;
    hs.init(slot, 0x3f3f3f3f);
    for(int i = 0; i < n; i++){
        hs.insert(ary1[i], ary2[i], 2);
    }
    cout<<"随机探测碰撞次数:"<<testcnt<<endl;
}

乱七八糟

/*************************************************************************
    > File Name: base_array_childandbrother.cpp
    > Author: yijiull
    > Mail: 1147161372@qq.com 
    > Created Time: 2017年11月16日 星期四 21时00分41秒


    基于数组的左儿子右兄弟！！
 ************************************************************************/
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
template <typename T>
class Tree{
public:
    T date[maxn];
    int head[maxn], nxt[maxn];
    int sz;
    Tree(){
        init();
    }
    void init(){
        sz = 0;
        memset(head, -1, sizeof(head));
        memset(nxt, -1, sizeof(nxt));
    }
    void build(int pre, int flag, int u){
       T s;
       if(cin>>s){
           if(s == ')'){
                return ;
           }else{
               if(flag == 1) head[pre] = u;
               else if(flag == 0) nxt[pre] = u;
               date[u] = s;
               if(head[u] == -1)  build(u, 1, ++sz);
               int id;
               for(int i = u; ~i; i = nxt[i]){
                   id = i;
               }
               build(id, 0, ++sz);
           }
       }
    }
    void preOrder(int u){
        if(~u){
            cout<<date[u]<<" ";
            preOrder(head[u]);
            if(head[u]) preOrder(nxt[u]);
        }
    }
    void postOrder(int u){
        if(~u){
            postOrder(head[u]);
            cout<<date[u]<<" ";
            if(head[u]) postOrder(nxt[u]);
        }
    }
    void print(int u){
        cout<<"前序遍历：
";
        preOrder(u);
        cout<<endl;
        cout<<"后序遍历：
";
        postOrder(u);
        cout<<endl;
    }
};
int main(){
//输入：
//abej))f)g))chk)))di))))
    freopen("in.txt", "r", stdin);
    freopen("out1.txt", "w", stdout);
    Tree<char> tree;
    tree.build(0, 2, 0);
    tree.print(0);
//输出：
//前序遍历：
//a b e j f g c h k d i 
//后序遍历：
//j e f g b k h c i d a 
}

/*************************************************************************
    > File Name: base_list_childandbrother.cpp
    > Author: yijiull
    > Mail: 1147161372@qq.com 
    > Created Time: 2017年11月16日 星期四 13时58分57秒


    基于链表的左儿子右兄弟！！！
 ************************************************************************/
#include <bits/stdc++.h>
using namespace std;
int cnt;
const int maxn = 100010;
template <typename T>
class Node{
private:
    T date;
    Node<T> *head, *nxt;
public:
    Node<T>(){
        head = NULL;
        nxt = NULL;
    }
    Node<T>(T date, Node<T> *head = NULL, Node<T> *nxt = NULL) : date(date), head(head), nxt(nxt){}
    void setVal(T x){
        date = x;
    }
    T getVal(){
        return date;
    }
    Node<T>* getptrHead(){
        return head;
    }
    Node<T>*& getHead(){
        return head;
    }
    void setHead(Node<T> *temp){
        head = temp;
    }
    Node<T>* getptrNxt(){
        return nxt;
    }
    Node<T>*& getNxt(){
        return nxt;
    }
    void setNxt(Node<T> * temp){
        nxt = temp;
    }
    bool isLeaf(){
        return head == NULL;
    }
};
template <typename T> 
class Tree{
private:
    Node<T> *rt;
public:
    Tree<T>(){
        rt = NULL;
    }
    Node<T>* getptrRoot(){
        return rt;
    }
    Node<T>*& getRoot(){
        return rt;
    }
    //void build(){
    //    T u, v;
    //    cin>>u>>v;
    //    Node<T> * q[maxn];
    //    int front = 0, rear = 0;
    //    while(v != '#'){
    //        Node<T> *temp = new Node<T>(v);
    //        if(u == '#'){
    //            rt = temp;
    //            q[(rear++) % maxn] = temp;
    //        }else{
    //            Node<T> *tp = q[front];
    //            while(tp->getVal() != u){
    //                front = (front + 1) % maxn;
    //                tp = q[front];
    //            }
    //            if(tp->getVal() == u){
    //                if(tp->getHead() == NULL){
    //                    tp->setHead(temp);
    //                }else{
    //                    tp = tp->getHead();
    //                    while(tp->getNxt()){
    //                        tp = tp->getNxt();
    //                    }
    //                    tp->setNxt(temp);
    //                }
    //            }
    //            if(rear + 1 % maxn != front) {
    //                q[(rear++) % maxn] = temp;
    //            }
    //        }
    //        cin>>u>>v;
    //    }
    //}
    void buildPreOrder(Node<T> *&cur){
        T s;
        if(cin>>s){
            Node<T> *temp = new Node<T>();
            if(s == ')'){
                cur = NULL;
            }else{
                temp->setVal(s);
                cur = temp;
                buildPreOrder(cur->getHead());
                buildPreOrder(cur->getNxt());
            }
        }
    }
    void preOrder(Node<T> *temp){
        if(temp != NULL){
            cout<<temp->getVal()<<" ";
            preOrder(temp->getptrHead());
            preOrder(temp->getptrNxt());
        }
    }
    void postOrder(Node<T> *temp){
        if(temp != NULL){
            postOrder(temp->getptrHead());
            cout<<temp->getVal()<<" ";
            postOrder(temp->getptrNxt());
        }
    }
    void levelOrder(){
        queue<Node<T> *> q;
        q.push(rt);
        while(!q.empty()){
            Node<T> *temp = q.front();
            cout<<temp->getVal()<<" ";
            q.pop();
            for(Node<T> *it = temp->getptrHead(); it != NULL; it = it->getptrNxt()){
                q.push(it);
            }
        }
        cout<<endl;
    }
    void print(Node<T> *temp){
        cout<<"前序遍历：
";
        preOrder(temp);
        cout<<endl;
        cout<<"后序遍历：
";
        postOrder(temp);
        cout<<endl;
        cout<<"层次遍历：
";
        levelOrder();
    }
};
int main(){
    freopen("in.txt", "r", stdin);
    //freopen("out.txt","w", stdout);
//输入：
//abej))f)g))chk)))di))))
    Tree<char> tree;
    //输入以右括号标记子树的结束，输入前序
    tree.buildPreOrder(tree.getRoot());
    tree.print(tree.getptrRoot());
//输出：
//前序遍历：
//a b e j f g c h k d i 
//后序遍历：
//j e f g b k h c i d a 
//层次遍历：
//a b c d e f g h i j k 
}

/*************************************************************************
    > File Name: base_list_childlist1.cpp
    > Author: yijiull
    > Mail: 1147161372@qq.com 
    > Created Time: 2017年11月16日 星期四 23时12分14秒
    
    链表方式实现的第一种孩子列表！！！！！
 ************************************************************************/


#include <bits/stdc++.h>
using namespace std;
template <typename T>
class Node{
public:
    T date;
    Node<T> *par;
    vector<Node<T> *> child;
public:
    Node(){
        par = NULL;
        child.clear();
    }
    Node(T date){
        this->date = date;
        par = NULL;
        child.clear();
    }
    void init(){
        par = NULL;
        child.clear();
    }
    T getVal(){
        return date;
    }
    void setVal(T x){
        date = x;
    }
    Node<T>* getPar(){
        return par;
    }
    void setPar(Node<T> *temp){
        par = temp;
    }
    bool isLeaf(){
        return child.size() == 0;
    }
    Node<T>*& getHead(){
        if(child.size() == 0) {
            Node<T> *temp = NULL;
            child.push_back(temp);
        }
        return child[0];
    }
    Node<T>*& getNxt(int &pos){
        int sz = par->child.size();
        for(int i = 0; i < sz; i++){
            if(par->child[i]->date == date) {
                pos = i + 1;
                if(pos == sz) {
                    Node<T> *temp = NULL;
                    par->child.push_back(temp);
                }
                return par->child[i+1];
            }
        }
    }
    void setHead(Node<T> *temp){
        child.push_back(temp);
    }
    void setNxt(Node<T> *temp){
        child.push_back(temp);
    }
    void removeHead(){
        child.erase(child.begin());   
    }
    void removeNxt(){
        int pos;
        getNxt(pos);
        //删除整棵子树
        par->child.erase(par->child.begin() + pos);
    }
};

template <typename T>
class Tree{
public:
    Node<T> *rt;
    void init(){
        //rt->init();
        rt = NULL;
    }
    Tree(){
        init();
    }
    Node<T> *& getRoot(){
        return rt;
    }
    Node<T>* find(T name, Node<T> *temp){
        Node<T> *res = NULL;
        if(temp != NULL){
            if(temp->getVal() == name){
                res = temp;
            }else{
                for(int i = 0; i < temp->child.size() && !res; i++){
                    res = find(name, temp->child[i]);
                }
            }
        }
        return res;
    }
    void build(){
        T x;
        int cnt;
        while(cin>>x){
            cin>>cnt;
            Node<T> *temp = find(x, rt);
            if(temp == NULL){
                temp = new Node<T>(x);
                rt = temp;
            }
            for(int i = 0; i < cnt; i++){
                cin>>x;
                Node<T> *tp = new Node<T>(x);
                tp->setPar(temp);
                temp->child.push_back(tp);
            }
        }
    }
    //有问题！！
    //void buildPreOrder(Node<T> *&cur){    
    //    T s;
    //    if(cin>>s){
    //        cout<<s<<endl;
    //        Node<T> *temp = new Node<T>();
    //        if(s == ')'){
    //            cur = NULL;
    //        }else{
    //            temp->setVal(s);
    //            cur = temp;
    //            buildPreOrder(cur->getHead());
    //            int pos;
    //            buildPreOrder(cur->getHead()->getNxt(pos));
    //        }
    //    }
    //    
    //}
    void print(){
        cout<<"层次遍历："<<endl;
        queue<Node<T> *> q;
        q.push(rt);
        while(!q.empty()){
            Node<T> * temp = q.front();
            q.pop();
            cout<<temp->date<<" ";
            for(int i = 0; i < temp->child.size(); i++){
                q.push(temp->child[i]);
            }
        }
        cout<<endl;
    }
};
int main(){
//    freopen("in.txt", "r", stdin);
//    freopen("out2.txt", "w", stdout);
//输入：
//aA 4 g cC z BBbb
//z 2 f i
//g 1 d
//d 3 x e j
    Tree<string> tree;
    tree.init();
    tree.build();
    tree.print();
    Node<string> * temp = tree.rt;
    cout<<"删除根的第一个儿子及子树
";
    temp->removeHead();
    tree.print();
    cout<<"删除根的第三个儿子及子树
";
    temp = temp->getHead();
    temp->removeNxt();
    tree.print();

//输出：
//层次遍历：
//aA g cC z BBbb d f i x e j 
//删除根的第一个儿子及子树
//层次遍历：
//aA cC z BBbb f i 
//删除根的第三个儿子及子树
//层次遍历：
//aA cC BBbb 
}

/*************************************************************************
    > File Name: base_list_childlist2.cpp
    > Author: yijiull
    > Mail: 1147161372@qq.com 
    > Created Time: 2017年11月17日 星期五 19时24分04秒

    链表方式实现的第二种孩子列表！！！！！
 ************************************************************************/

#include <bits/stdc++.h>
using namespace std;
template <typename T> class Node_P;
template <typename T> 
class Node_E{
public:
    T date;
    Node_E<T> *par;
    Node_P<T> *head;
    Node_E(){}
    Node_E(T date) : date(date){
        par = NULL;
        head = NULL;
    }
    T getVal(){
        return date;
    }
    void setPar(Node_E<T> *temp){
        par = temp;
    }
    void setHead(Node_P<T> *temp){
        head = temp;
    }
    Node_P<T>* getRightSon(){
        Node_P<T> *cur = par->head;
        cout<<"getson  "<<cur->node->date<<endl;
        while(cur->nxt) cur = cur->nxt;
        return cur;
    }
};
template <typename T>
class Node_P{
public:
    Node_E<T> *node;
    Node_P<T> *nxt;
    Node_P(Node_E<T> *node = NULL, Node_P<T> *nxt = NULL) : node(node), nxt(nxt){}
    void setNxt(Node_P<T> *temp){
        nxt = temp;
    }
};

template <typename T> 
class Tree{
public:
    Node_E<T> *rt;
    Tree(){
        rt = NULL;
    }
    Node_E<T>* find(T name, Node_E<T> *temp){
        Node_E<T> *res = NULL;
        if(temp != NULL){
            if(temp->date == name){
                res = temp;
            }else{
                Node_P<T> *it = temp->head;
                while(!res && it){
                    res = find(name, it->node);
                    it = it->nxt;
                }
            }
        }
        return res;
    }
    void build(){
        T x;
        while(cin>>x){
            int cnt;
            cin>>cnt;
            Node_E<T> *temp = find(x, rt);
            if(temp == NULL){
                temp = new Node_E<T>(x);
                rt = temp;
            }
            for(int i = 0; i < cnt; i++){
                cin>>x;
                Node_E<T> *tp = new Node_E<T>(x);
                tp->setPar(temp);
                if(temp->head == NULL){
                    Node_P<T> *t1 = new Node_P<T>(tp);
                    temp->setHead(t1);
                }else{
                    Node_P<T> *t1 = temp->head;
                    while(t1->nxt) t1 = t1->nxt;
                    Node_P<T> *t2 = new Node_P<T>(tp);
                    t1->setNxt(t2);
                }
            }
        }
    }
    void print(){
        cout<<"层次遍历：
";
        queue<Node_E<T>*> q;
        q.push(rt);
        while(!q.empty()){
            Node_E<T> *temp = q.front();
            q.pop();
            cout<<temp->date<<" ";
            int z = 0;
            for(Node_P<T> *it = temp->head; it != NULL; it = it->nxt){
                q.push(it->node);   
            }
        }
    }
}; 
int main(){
    freopen("in.txt", "r", stdin);
    freopen("out2.txt", "w", stdout);
//输入：
//aA 4 g cC z BBbb
//z 2 f i
//g 1 d
//d 3 x e j
    Tree<string> tree;
    tree.build();
    tree.print();
//输出：
//层次遍历：
//aA g cC z BBbb d f i x e j 
}