二叉树-------二叉链表实现

2019-04-30 17:11:12

重新拿c++实现了一下

#include <iostream>
#include <stack>
#include <queue>

using namespace std;

class tree_node
{
public:
    int data;
    tree_node *lchild;
    tree_node *rchild;
    ~tree_node(){
        lchild = nullptr;
        rchild = nullptr;
    }
};

class binary_tree
{
public:
    tree_node *build_tree(int level, string pos);
    void pre_order(tree_node *root);
    void in_order(tree_node *root);
    void post_order(tree_node *root);
    int sum_node(tree_node *root);
    int sum_leaf(tree_node *root);
    bool tree_equals(tree_node *root1, tree_node *root2);
    void destory_tree(tree_node *root);
    tree_node *copy_tree(tree_node *root);
    void non_rec_pre_order(tree_node *root);
    void non_rec_in_order(tree_node *root);
    void non_rec_post_order(tree_node *root);
    void level_order(tree_node *root);
    void invert_level_order(tree_node *root);
    int tree_depth(tree_node *root);
    int tree_depth2(tree_node *root);
    void find_x_level(tree_node *root, int x);
    tree_node *pre_in_create_tree2(int A[], int B[], int s1, int e1, int s2, int e2);
    tree_node *pre_in_create_tree(int A[],int B[], int s1, int e1, int s2, int e2);
    bool is_complete(tree_node *root);
    int double_son_node(tree_node *root);
    void swap_lrchild(tree_node *root);
    void swap_lrchild2(tree_node *root);
    int search_k_node(tree_node *root, int k);
    void destory_x_node(tree_node *root, int k);
    void print_ancestor_node(tree_node *root, int x);
    tree_node *nearest_comm_ancestor(tree_node *root, int p, int q);
    int tree_width(tree_node *root);
    void pre_to_post(int pre[], int s1, int e1,
                     int post[], int s2, int e2);
    tree_node *inorder_list(tree_node *root);
    void link(tree_node *root, tree_node *head, tree_node *tail);
    bool is_similar(tree_node *root1, tree_node *root2);
    int WPL(tree_node *node);

    ~binary_tree(){
        root = nullptr;
    }

    tree_node *root;
};

tree_node *binary_tree::build_tree(int level, string pos) {
    int tmp;
    cin >> tmp;
    if(tmp == 0)
        return nullptr;

    tree_node *p_new = new tree_node();
    p_new->data = tmp;
    p_new->lchild = build_tree(level+1, "left");
    p_new->rchild = build_tree(level+1, "right");
    return p_new;
}

void binary_tree::pre_order(tree_node *root) {
    if(root)
    {
        cout << root->data << endl;
        pre_order(root->lchild);
        pre_order(root->rchild);
    }
}

void binary_tree::in_order(tree_node *root) {
    if(root)
    {
        in_order(root->lchild);
        cout << root->data << endl;
        in_order(root->rchild);
    }
}

void binary_tree::post_order(tree_node *root) {
    if(root)
    {
        post_order(root->lchild);
        post_order(root->rchild);
        cout << root->data << endl;
    }
}

int binary_tree::sum_node(tree_node *root) {
    if(root == nullptr)
        return 0;
    else{
        return sum_node(root->lchild) + sum_node(root->rchild) + 1;
    }

    return 0;
}

// 统计叶子节点的个数
int binary_tree::sum_leaf(tree_node *root) {
    int sum=0;

    if(root)
    {
        if(root->lchild==nullptr && root->rchild==nullptr)
            sum++;
        if(root->lchild)
            sum += sum_leaf(root->lchild);
        if(root->rchild)
            sum += sum_leaf(root->rchild);
    }

    return sum;
}

bool binary_tree::tree_equals(tree_node *root1, tree_node *root2) {

    if(root1 == nullptr && root2 == nullptr)
        return true;

    if(root1 && root2 && root1->data == root2->data)
        if(tree_equals(root1->lchild,root2->lchild))
            if(tree_equals(root1->rchild, root2->rchild))
                return true;

    return false;
}

/// delete 会调用析够函数,对对象进行释放
/// 这个代码不能有效删除树根节点 root
void binary_tree::destory_tree(tree_node *root) {
    if(root == nullptr)
        return;
    destory_tree(root->lchild);
    destory_tree(root->rchild);

    delete root;
    root = nullptr;
    return;
}


tree_node *get_tree_node(int data, tree_node *lchild, tree_node *rchild)
{
    tree_node *p_tmp = new tree_node();
    p_tmp->data = data;
    p_tmp->lchild = lchild;
    p_tmp->rchild = rchild;
    return p_tmp;
}

tree_node *binary_tree::copy_tree(tree_node *root) {
    tree_node *new_l, *new_r, *new_root;
    if(root == nullptr)
        return nullptr;

    if(root->lchild)
        new_l = copy_tree(root->lchild);
    else
        new_l = nullptr;

    if(root->rchild)
        new_r = copy_tree(root->rchild);
    else
        new_r = nullptr;

    new_root = get_tree_node(root->data, new_l, new_r);


    return new_root;
}

void binary_tree::non_rec_pre_order(tree_node *root) {

    /**
类名后面加*，表示该类型为对应类的指针类型。
指针类型为C/C++语言的特色概念，其值为对象的地址。
类名加*，有两种作用情况：
1 用于定义时，或用于函数参数，返回值时，表示对应变量值为类指针类型；
2 用于变量前，以(CLASS_NAME *)var_name，形式出现时，表示将变量或常量var_name强制转换为类指针类型。
     * */

    stack<tree_node *> tree_stack;
    if(root == nullptr)
        return;
    else{
        while(root || !tree_stack.empty())
        {
            if(root)
            {
                cout << root->data << endl;
                tree_stack.push(root);
                root = root->lchild;
            }else{
                root = tree_stack.top();
                tree_stack.pop();
                root = root->rchild;
            }
        }
    }

}

void binary_tree::non_rec_in_order(tree_node *root) {
    stack<tree_node *> tree_stack;
    if(root==nullptr)
        return;
    else{
        while(root || !tree_stack.empty())
        {
            if(root){
                tree_stack.push(root);
                root=root->lchild;
            }else{
                root=tree_stack.top();
                tree_stack.pop();
                cout << root->data << endl;
                root=root->rchild;
            }
        }
    }
}

void binary_tree::non_rec_post_order(tree_node *root) {
    stack<tree_node *> tree_stack;
    tree_node *vis = nullptr;

    if(root == nullptr)
        return;

    while(root || !tree_stack.empty())
    {
        if(root)
        {
            tree_stack.push(root);
            root = root->lchild;
        }else{
            root = tree_stack.top();
            if(root->rchild && root->rchild != vis)
            {
                root=root->rchild;
                tree_stack.push(root);
                root=root->lchild;
            }else{
                root=tree_stack.top();
                tree_stack.pop();
                cout << root->data << endl;
                vis=root;
                root=nullptr;
            }
        }
    }
}

/**
 * 学会使用stl后,代码超级简单,还不用记忆各个容器的具体操作
 * */
void binary_tree::level_order(tree_node *root) {
    queue<tree_node *> tree_que;

    if(root == nullptr)
        return;

    tree_que.push(root);
    while(!tree_que.empty())
    {
        root = tree_que.front();
        tree_que.pop();

        cout << root->data<< endl;

        if(root->lchild)
            tree_que.push(root->lchild);

        if (root->rchild)
            tree_que.push(root->rchild);
    }
}

/**
 * 逆层次遍历
 *
 * */
void binary_tree::invert_level_order(tree_node *root) {
    queue<tree_node *> tree_que;
    stack<tree_node *> tree_stack;

    if(root == nullptr)
        return;

    tree_que.push(root);
    while(!tree_que.empty())
    {
        root = tree_que.front();
        tree_que.pop();
        tree_stack.push(root);

        if(root->lchild)
            tree_que.push(root->lchild);
        if(root->rchild)
            tree_que.push(root->rchild);
    }

    while(!tree_stack.empty())
    {
        root = tree_stack.top();
        tree_stack.pop();
        cout << root->data << endl;
    }
}

/**
 *
 1.每遍历一层，depth++;

 2.每一层，需使用一个变量len记录该层的结点个数，也就是队列的当前长度，
 然后依次在队列中访问该层的len个结点（将队列中len个元素出队列），
 并将下一层如队列
 * */

int binary_tree::tree_depth(tree_node *root) {

    queue<tree_node *> tree_que;
    if(root == nullptr)
        return 0;

    int level=0;
    tree_que.push(root);

    while(!tree_que.empty())
    {
        unsigned long tree_size=tree_que.size();
        level++;
        while(tree_size--)
        {
            tree_node *tmp = tree_que.front();
            tree_que.pop();
            if(tmp->lchild)
                tree_que.push(tmp->lchild);
            if(tmp->rchild)
                tree_que.push(tmp->rchild);
        }
    }

    return level;
}

int binary_tree::tree_depth2(tree_node *root) {

    int level=0;
    if(!root)
        return 0;
    else
    {
        level = 1 + max(tree_depth2(root->lchild), tree_depth2(root->rchild));
    }

    return level;
}

void binary_tree::find_x_level(tree_node *root, int x) {
    static int level=1;
    if(root)
    {
        if(root->data == x)
        {
            cout << level << endl;
            return;
        }

        level++;
        find_x_level(root->lchild, x);
        find_x_level(root->rchild, x);
    }
}

tree_node *binary_tree::pre_in_create_tree2(int *A, int *B, int s1, int e1, int s2, int e2) {
    if(s1>e1 || s2>e2)
        return nullptr;
    tree_node *root = new tree_node();
    root->data=A[s1];
    for(int i=s2; i<=e2; ++i)
    {
        if(A[s1] == B[i])
        {
            root->lchild=pre_in_create_tree2(A,B,s1+1,s1+i-s2, s2, i-1);
            root->rchild=pre_in_create_tree2(A,B,i-s2+s1+1,e1,i+1,e2);
        }
    }

    return root;
}

tree_node *binary_tree::pre_in_create_tree(int *A, int *B, int s1, int e1, int s2, int e2) {

    return nullptr;
}


/**
 * 对应于博客上的代码是有问题的,617行
 *
 * */
bool binary_tree::is_complete(tree_node *root) {
    queue<tree_node *> tree_que;

    if(!root)
        return true;

    tree_que.push(root);

    tree_node *tmp = tree_que.front();
    while(tmp)
    {
        tree_que.pop();
        tree_que.push(tmp->lchild);
        tree_que.push(tmp->rchild);
        tmp = tree_que.front();
    }

    tree_que.pop();// 把空pop出来
    // 因为以经有一个空了，所以只要头不为空就不是完全二叉树
    while(!tree_que.empty())
    {
        if(tree_que.front())
            return false;
        tree_que.pop();
    }
    return true;
}

int binary_tree::double_son_node(tree_node *root) {

    if(root == nullptr)
        return 0;

    if(root->lchild && root->rchild)
        return double_son_node(root->lchild)+double_son_node(root->rchild)+1;
    else
        return double_son_node(root->lchild)+double_son_node(root->rchild);
}


/*
 * 交互二叉树的左右子树(后序遍历的应用)
 * 1.首先交换root的左孩子的左右子树，
 * 2.然后交换root的右孩子的左右子树
 * 3.最后交换root的左右孩子，当结点为空时递归结束
*/
void binary_tree::swap_lrchild(tree_node *root) {
    tree_node *tmp;
    if(root)
    {
        swap_lrchild(root->lchild);
        swap_lrchild(root->rchild);
        tmp=root->lchild;
        root->lchild=root->rchild;
        root->rchild=tmp;
    }
}

void binary_tree::swap_lrchild2(tree_node *root) {
    tree_node *p, *tmp;
    queue<tree_node *> tree_que;

    if(root)
    {
        tree_que.push(root);
    }
    while(!tree_que.empty())
    {
        p = tree_que.front();
        tree_que.pop();

        if(p->lchild)
            tree_que.push(p->lchild);
        if(p->rchild)
            tree_que.push(p->rchild);

        tmp = p->lchild;
        p->lchild = p->rchild;
        p->rchild = tmp;
    }
}

// 对应的博客中的代码有问题
// 715 行
int binary_tree::search_k_node(tree_node *root, int k) {
    static int flg = 0;
    static int ans = -1;

    if(root)
    {
        flg++;
        if(flg == k)
        {
            ans = root->data;
            return ans;
        }
        search_k_node(root->lchild, k);
        search_k_node(root->rchild, k);
    }
    return ans;
}

/**
 * 思想很简单,但是destory_tree
 * 写的删除不了根节点,这个代码就不测了
 *
 * */
void binary_tree::destory_x_node(tree_node *root, int k) {
    if(root)
    {
        if(root->data == k)
        {
            destory_tree(root);
            return;
        }

        queue<tree_node *> tree_que;

        tree_que.push(root);

        while(!tree_que.empty())
        {
            tree_node *tmp=tree_que.front();
            tree_que.pop();

            if(tmp->lchild)
            {
                if(tmp->lchild->data == k)
                {
                    destory_tree(root->lchild);
                    root->lchild= nullptr;
                }else
                {
                    tree_que.push(tmp->lchild);
                }
            }
            if(tmp->rchild)
            {
                if(tmp->rchild->data == k)
                {
                    destory_tree(root->rchild);
                    root->rchild= nullptr;
                }else
                {
                    tree_que.push(tmp->rchild);
                }
            }
        }
    }
    return;
}

 /*
 780  * 打印X结点的所有祖先，用到了非递归后序遍历的栈中信息
 781  * 1.非递归后序遍历找到X
 782  * 2.此时栈中的所有元素均为该结点的祖先结点
 783  * Note:树上的代码是后序遍历的不同写法，感觉没必要记那种（应该看一下深入理解后序遍历），
 784  * 会一种就够了了，所以我的代码，就是把上边的后序遍历中的输出语句该为了判断是否是当前结点。
 785  * 王道 P.133 第十二题

 博客中写的太恶心了,不要用那种
 786  * */

void binary_tree::print_ancestor_node(tree_node *root, int x) {
    stack<tree_node *> tree_stack;
    tree_node *vis = nullptr;
     if(!root)
     {
         cout << "tree is empyt" << endl;
         return;
     }

     while(root || !tree_stack.empty())
     {
         if(root)
         {
             tree_stack.push(root);
             root = root->lchild;
         }else{
             root = tree_stack.top();
             if(root->rchild && root->rchild != vis)
             {
                 root=root->rchild;
                 tree_stack.push(root);
                 root=root->lchild;
             }else{
                 root=tree_stack.top();
                 tree_stack.pop();
                 /// 将后序遍历的输出改为判断是否为x节点
                 // 是x节点,跳出循环,栈中元素极为祖先
                 if(root->data == x)
                     break;

                 vis=root;
                 root=nullptr;
             }
         }
     }

     while(!tree_stack.empty())
     {
         cout << tree_stack.top()->data << endl;
         tree_stack.pop();
     }
    return;
}

/*
 829  * 求 p q两个结点的最近公共祖先，非递归后序遍历的应用，就是利用栈信息
 830  * 假设p 在 q的左边
 831  * 1.后序遍历必然先遍历到 p,这时把栈中的信息借用辅助栈保存起来
 832  * 2.继续遍历，遍历到 q 结点的时候，将栈中的结点逐个和辅助栈的结点匹配，
 833  *      第一个相等的元素就是p & q的最近公共祖先
 834  * 王道 P.134 第13题
 835  * */
tree_node *binary_tree::nearest_comm_ancestor(tree_node *root, int p, int q) {
    stack<tree_node *> tree_stack;
    stack<tree_node *> ass_tree_stack;
    tree_node *vis = nullptr;
    if(!root)
    {
        cout << "tree is empyt" << endl;
        return nullptr;
    }

    while(root || !tree_stack.empty())
    {
        if(root)
        {
            tree_stack.push(root);
            root = root->lchild;
        }else{
            root = tree_stack.top();
            if(root->rchild && root->rchild != vis)
            {
                root=root->rchild;
                tree_stack.push(root);
                root=root->lchild;
            }else{
                root=tree_stack.top();
                tree_stack.pop();
                /// 将后序遍历的输出改为判断是否为x节点
                // 是x节点,跳出循环,栈中元素极为祖先
                if(root->data == p)
                {
                    ass_tree_stack = tree_stack;
                }
                if(root->data == q)
                {
                    vector<tree_node *> s1_info;
                    vector<tree_node *> s2_info;

                    while(!tree_stack.empty())
                    {
                        s1_info.push_back(tree_stack.top());
                        tree_stack.pop();
                    }

                    while(!ass_tree_stack.empty())
                    {
                        s2_info.push_back(ass_tree_stack.top());
                        ass_tree_stack.pop();
                    }

                    for (auto i=s1_info.begin(); i!=s1_info.end(); ++i) {
                        for (auto j = s2_info.begin(); j != s2_info.end() ; j++) {
                            if((*i) == (*j))
                            {
                                cout << *i << endl;
                                return *i;
                            }

                        }

                    }
                }

                vis=root;
                root=nullptr;
            }
        }
    }


    return nullptr;
}

int binary_tree::tree_width(tree_node *root) {

    queue<tree_node *> tree_queue;

    if(!root)
        return 0;

    int tree_width=1;
    tree_queue.push(root);
    while(true)
    {
        int len = (int)tree_queue.size(); // 当前层具有的节点个数
        if(len == 0)
            break;
        while(len > 0) // 如果当前层还有节点
        {
            tree_node *tmp = tree_queue.front();
            tree_queue.pop(); // 出队,
            len --;//长度减1
            if(tmp->lchild)
                tree_queue.push(tmp->lchild); // 下一层入队
            if(tmp->rchild)
                tree_queue.push(tmp->rchild); // 下一层入队
        }
        tree_width = max(tree_width,(int)tree_queue.size()); // 得到最大宽度
    }
    return tree_width;
}

/**
 * 直接抄下来,没有细看
 *
 * */
void binary_tree::pre_to_post(int *pre, int s1, int e1, int *post, int s2, int e2) {
    int mid;
    if(e1>=s1)
    {
        post[e2]=pre[e1];
        mid = (e1-s1)/2;
        pre_to_post(pre, s1+1,s1+mid,post,s2,s2+mid-1);
        pre_to_post(pre, s1+mid+1, e1, post, s1+mid, e2-1);
    }
}

/**
 *
 * 没有细看
 * */
tree_node *head, *pre= nullptr;
tree_node *binary_tree::inorder_list(tree_node *root) {

    if(root)
    {
        inorder_list(root->lchild);

        if(!root->lchild && !root->rchild)
        {
            if(!pre)
            {
                head = root;
                pre = root;
            }else{
                pre->rchild = root;
                pre = root;
            }
            inorder_list(root->rchild);
            pre->rchild= nullptr;
        }
    }

    return head;
}

/**
 *
 * 没有细看
 * */
void binary_tree::link(tree_node *root, tree_node *head, tree_node *tail) {
    if(root)
    {
        if(!root->lchild && !root->rchild)
        {
            if(!head)
            {
                head = root;
                tail = root;
            }else
            {
                tail->rchild = root;
                tail = root;
            }
        }

        link(root->lchild, head, tail);
        link(root->rchild, head, tail);
    }
}



bool binary_tree::is_similar(tree_node *root1, tree_node *root2) {

    int l_data, r_data;
    if(!root1 && !root2)
        return true;
    else if(!root1 && !root2)
        return false;
    else
    {
        l_data = is_similar(root1->lchild, root2->lchild);
        r_data = is_similar(root1->lchild, root2->rchild);
        return (l_data&&r_data);
    }
}


int binary_tree::WPL(tree_node *node) {
    return 0;
}


int main() {
    // 1 2 0 0 3 0 4 5 0 0 0
    // 1 0 2 0 0
    std::cout << "Hello, World!" << std::endl;

    binary_tree bt;
    binary_tree bt1;
    bt.root = bt.build_tree(1, "root");
    bt1.root = bt1.build_tree(1, "root");
    bt.pre_order(bt.root);
    bt.in_order(bt.root);
    bt.post_order(bt.root);
    cout<< "node sum is : " << bt.sum_node(bt.root) << endl;
    cout<< "leaf node sum is : " << bt.sum_leaf(bt.root) << endl;
    cout<< "tree equals is : " << bt.tree_equals(bt.root, bt1.root) << endl;
//    bt.destory_tree(bt.root);
//    cout<< "node sum is : " << bt.sum_node(bt.root) << endl;
//    cout << bt.root->data << endl;

    binary_tree bt2;
    bt2.root = bt.copy_tree(bt.root);
    cout<< "node sum is : " << bt2.sum_node(bt2.root) << endl;
    cout << bt2.tree_depth2(bt2.root)<< endl;

    bt2.find_x_level(bt2.root, 2);

    int A[] = {1,2,4,7,3,5,6,8};
    int B[] = {4,7,2,1,5,3,8,6};
    binary_tree bt3;
    bt3.root = bt3.pre_in_create_tree2(A,B,0,7,0,7);
    bt3.non_rec_pre_order(bt3.root);

    cout << bt1.search_k_node(bt1.root, 15) << endl;
    cout << bt1.nearest_comm_ancestor(bt1.root, 2,5)->data << endl;
    bt1.pre_order(bt1.root);
    cout << bt1.tree_width(bt1.root) << endl;

    return 0;
}

　　

一下两个版本部分代码存在问题,请忽略

///练练练
#include <stdio.h>
#include <stdlib.h>
typedef char Telemtype;
typedef struct BinTree{
    Telemtype data;
    struct BinTree *LChild;
    struct BinTree *RChild;
}BinaryTree;

/*
 * 建树是通过先序遍历的方法进行，先输如一个字符，如果不是‘0’，则进行
 * 树的创建，否则不建树
 * 树的创建需要有一下几个步骤
 * 1.给树根结点申请空间
 * 2.给根节点的数据域赋值
 * 3.递归的分别创建左右子树
 * */
BinaryTree* create_tree(BinaryTree *Tree)
{
    Telemtype tmp;
    scanf("%c", &tmp);
    if(tmp == '0')
        return 0;
    Tree = (BinaryTree*)malloc(sizeof(BinaryTree));
    Tree->data = tmp;
    Tree->LChild = create_tree(Tree->LChild);
    Tree->RChild = create_tree(Tree->RChild);
    return Tree;
}

/*
 * 递归写法的几种树的遍历（先序，中序，后序），都一样
 * 但是这样的写法其实在其他操作中也类似，
 * 1.比如说统计节点个数
 * 2.树的销毁等等
 * 对于时间复杂度，因为每个节点均遍历一次，所以复杂度为O(n)
 * */
void preorder_traverse(BinaryTree *tree)
{
    if(tree)
    {
        printf("%c ", tree->data);
        preorder_traverse(tree->LChild);
        preorder_traverse(tree->RChild);
    }
}

void inorder_traverse(BinaryTree *tree)
{
    if(tree)
    {
        inorder_traverse(tree->LChild);
        printf("%c ", tree->data);
        inorder_traverse(tree->RChild);
    }
}

void postorder_traverse(BinaryTree *tree)
{
    if(tree)
    {
        postorder_traverse(tree->LChild);
        postorder_traverse(tree->RChild);
        printf("%c ", tree->data);
    }
}

/*
 * 统计叶子节点的个数
 * 1.先看当前节点是否是叶子节点，如果是叶子节点，sum值加一
 * 2.然后递归的分别统计左右子树中拥有的叶子节点的个数
 * */
int sum_left(BinaryTree *tree)
{
    int sum = 0;
    if(tree)
    {
        if(!tree->LChild && !tree->RChild)
            sum ++;
        if(tree->LChild)
            sum += sum_left(tree->LChild);
        if(tree->RChild)
            sum += sum_left(tree->RChild);
    }
    return sum;
}
/*
 * 1.如果两颗树是空树，则两颗树相等
 * 2.否则，判断当前树的根节点是否相等
 * 3.然后再递归的判断左右子树
 * 4.如果都相同，返回1.否则返回0
 * */
int is_equal(BinaryTree *T1, BinaryTree *T2)
{
    if(!T1 && !T2)
    {
        return 1;
    }
    if(T1 && T2 && T1->data == T2->data)
        if(is_equal(T1->LChild, T2->LChild))
            if(is_equal(T1->RChild, T2->RChild))
                return 1;
    return 0;
}
/*
 * 思路同后序遍历
 * 1.先销毁左右子树
 * 2.然后释放当前根节点的空间
 * 3.将指针的指向   指到NULL
 * Note：free(tree)仅仅收回内存，不会改变T的指向。
 * */
void destory_tree(BinaryTree *tree)
{
    if(tree == NULL)
        return;
    destory_tree(tree->LChild);
    destory_tree(tree->RChild);
    free(tree);
    tree = NULL;
    return;
}

/*
 * 树的复制包含两部分，第一部分是，为根节点设置值和要指向的左右子树
 * 第二部分就是递归的复制左右子树
 * 左右子树的复制，还是同后序遍历
 * */
BinaryTree *get_tree_node(Telemtype item, BinaryTree *LChild, BinaryTree *RChild)
{
    BinaryTree *tree;
    tree = (BinaryTree*)malloc(sizeof(BinaryTree));
    tree->data = item;
    tree->LChild = LChild;
    tree->RChild = RChild;
    return tree;
}

BinaryTree* copy_tree(BinaryTree *tree)
{
    BinaryTree *newLChild, *newRChild, *newtree;
    if(!tree)
        return NULL;
    if(tree->LChild)
        newLChild = copy_tree(tree->LChild);
    else
        newLChild = NULL;

    if(tree->RChild)
        newRChild = copy_tree(tree->RChild);
    else
        newRChild = NULL;

    newtree = get_tree_node(tree->data, newLChild, newRChild);
    return newtree;
}

/*
 * 非递归的遍历就要用到 Stack & Queue
 * 1.Stack的初始化  stack.top = -1;
 * 2.Queue的初始化  queue.front = queue.rear = 0;
 * */
typedef struct TreeStack{
    BinaryTree *stroe[1000];
    int tag[1000];          //后序遍历要用到的标志域
    int top;
}Tstack;
/*
 *1.压栈操作，top+1 然后在当前位置存放节点信息
 *2.出栈操作，返回当前栈顶元素，然后top-1
 * */
void push_stack(Tstack *stack, BinaryTree *tree)
{
    if(stack->top == 1000)
        printf("the stack is full!\n");
    else{
        stack->top++;
        stack->stroe[stack->top] = tree;
    }
}

BinaryTree* pop_stack(Tstack *stack)
{
    if(stack->top == -1)
        return NULL;
    else{
        stack->top--;
        return stack->stroe[stack->top+1];
    }
}

typedef  struct TreeQueue{
    BinaryTree *stroe[1000];
    int front;
    int rear;
}Tqueue;
/*
 * 入队，出队比较简单
 * */
void enqueue(Tqueue *queue, BinaryTree *tree)
{
    if(queue->rear == 1000)
        printf("the queue is full!\n");
    else{
        queue->stroe[queue->rear] = tree;
        queue->rear++;
    }
}

BinaryTree* dequeue(Tqueue *queue)
{
    if(queue->front == queue->rear)
        return NULL;
    else{
        queue->front++;
        return queue->stroe[queue->front-1];
    }

}
/*
 * Note: 请先参照中序遍历，中序遍历是教科书说法，比较准确
 * 先序遍历的非递归算法和中序遍历的非递归算法类似
 * 1.先访问当前根结点，并将根结点入栈，往左走
 * 2.当当前节点没有左孩子时，将当前结点出栈，并访问他的右孩子
 * 3.一直循环，直到栈空
 * */
void non_recursion_preorder(BinaryTree *tree)
{
    Tstack stack;
    stack.top = -1;
    if(!tree)
        printf("the tree is empty!\n");
    else{
        while(tree || stack.top != -1)
        {
            if(tree)
            {
                printf("%c ", tree->data);
                push_stack(&stack, tree);
                tree = tree->LChild;
            }else{
                tree = pop_stack(&stack);
                tree = tree->RChild;
            }
            /*
             while(tree)                        //类似于中序遍历
             {
                printf("%c ", tree->LChild);
                push_stack(&stack, tree);
                tree = tree->LChild;
             }
                tree = pop_stack(&stack);
                tree = tree->RChild;
             * */
        }
    }
}

/*
 * 1.先扫描（并非访问）根结点的所有左结点并将他们一一进栈
 * 2.当当前结点没有左子树（或者左孩子结点已经访问过），将其出栈，访问他
 * 3.然后扫描该结点的右孩子结点，将其进栈，再扫描右孩子结点的所有左结点并一一进栈，如此继续，直到栈空
 * */
void non_recursion_inorder(BinaryTree *tree)
{
    Tstack stack;
    stack.top = -1;
    if(!tree)
    {
        printf("the tree is empty!\n");
    }else {
        while(tree || stack.top != -1)      //树根节点不空，或者栈不空时
        {
            if(tree){
                push_stack(&stack, tree);   //根结点进栈，遍历左子树
                tree = tree->LChild;        //每次遇到非空的左子树，就往左走
            }else{
                tree = pop_stack(&stack);   //根指针退栈，访问根节点，遍历右子树
                printf("%c ", tree->data);
                tree = tree->RChild;
            }

            /*
             while(tree)                     //另外一种好的写法，只要有左子树，就往左走
             {
                 push_stack(&stack, tree);   //根结点进栈，遍历左子树
                 tree = tree->LChild;        //每次遇到非空的左子树，就往左走
             }
             tree = pop_stack(&stack);       //根指针退栈，访问根节点，遍历右子树
             printf("%c ", tree->data);
             tree = tree->RChild;
             * */
        }
    }
}

/*
 * 后序遍历是先访问左右子树，最后访问根结点。
 * 当用栈来存储结点时，必须分清返回根结点时，是从左结点返回的，还是从右结点返回的
 * 用辅助指针可以写（也可以在结点中增加一个标志域）
 * 1.从根结点一直向左走，直到没有左子树
 * 2.转向向右走，先取栈顶指针
 * 3.判断是否有右子树
 *    4.若存在右子树且右子树是否被访问过，转向右子树，将右子树根结点压栈，继续走到最左边
 *    5.不满足4，弹出当前根结点，进行访问，并做标记，将tmp置空,必须将tmp置空，跳过向左走，直接向右走
 *
 * Note:当访问一个结点 *tmp时，栈中的结点恰好是*tmp结点的所有祖先。
 *      从栈底到栈顶结点再加上*tmp结点，刚好构成从根结点到*tmp的一条路径
 *      在很多算法设计中都用到了这一特行，比如：
 *                *求根结点到某结点的路径
 *                *求两个结点的最近公共祖先
 * */

void non_recursion_postorder(BinaryTree *tree)
{
    Tstack stack;
    stack.top = -1;
    BinaryTree *tmp = tree;
    BinaryTree *tag = NULL;
    while(tmp || stack.top != -1)
    {
        if(tmp)                                    //走到最左边
        {
            push_stack(&stack, tmp);
            tmp = tmp->LChild;
        }else{                                      //向右走
            tmp = pop_stack(&stack);                //取栈顶元素  这里应该是获取栈顶元素，但是不能出栈  王道 P.128
            push_stack(&stack, tmp);
            if(tmp->RChild && tmp->RChild != tag)   //如果右子树存在，且未被访问过
            {
                tmp = tmp->RChild;                  //转向右子树
                push_stack(&stack, tmp);            //压栈
                tmp = tmp->LChild;                  //继续走到最左边
            }else{                                  //如果右子树不存在，或者已经访问过
                tmp = pop_stack(&stack);            //弹出当前的根结点
                printf("%c ", tmp->data);           //进行访问
                tag = tmp;                          //标记访问过
                tmp = NULL;                         //访问过后，重置tmp指针,必须将tmp置空，跳过向左走，直接向右走
            }
        }
    }
}

//后序遍历的标记数据域标记写法
void non_recursion_postorder2(BinaryTree *tree)
{
    Tstack stack;
    stack.top = -1;
    if(!tree)
        printf("the tree is empty!\n");
    else{
        while(tree || stack.top != -1) {
            while (tree) {
                push_stack(&stack, tree);
                stack.tag[stack.top] = 0;       //设置访问标记，0为第一次访问，1为第二次访问
                tree = tree->LChild;
            }
            if (stack.tag[stack.top] == 0)       //第一次访问时，转向同层右结点
            {
                tree = stack.stroe[stack.top];  //左走到底时，tree是空，必须有这句话
                stack.tag[stack.top] = 1;
                tree = tree->RChild;
            } else {
                while (stack.tag[stack.top] == 1)//在栈中找到下一个第一次范格纹你的结点，退出循环时并没有pop，所以为其左子结点
                {
                    tree = pop_stack(&stack);
                    printf("%c ", tree->data);
                }
                tree = NULL;
            }
        }
    }
}

/*
 * 层次遍历，其实就是BFS  （广度优先搜索）
 * */
void levelorder(BinaryTree *tree)
{
    Tqueue queue;
    queue.front = queue.rear = 0;
    enqueue(&queue, tree);              //根结点入队
    while(queue.front != queue.rear) {  //队列不为空时，循环
        tree = dequeue(&queue);         //队头元素出队
        printf("%c ", tree->data);      //访问当前结点
        if (tree->LChild != NULL)
            enqueue(&queue, tree->LChild);
        if (tree->RChild != NULL)
            enqueue(&queue, tree->RChild);
    }
}
/*
 * 层次遍历的应用，将树自下而上，自右向左遍历，
 * 就是把层次遍历访问的结点入栈，然后从栈弹出的顺序
 * 王道 P.128
 * */
void invert_levelorder(BinaryTree *tree)
{
    Tqueue queue;
    Tstack stack;
    if(tree != NULL)
    {
        stack.top = -1;
        queue.front = queue.rear = 0;
        enqueue(&queue, tree);              //根结点入队
        while(queue.front != queue.rear) {
            tree = dequeue(&queue);
            push_stack(&stack, tree);      //当前结点 入栈
            if (tree->LChild != NULL)
                enqueue(&queue, tree->LChild);
            if (tree->RChild != NULL)
                enqueue(&queue, tree->RChild);
        }

        while(stack.top != -1)
        {
            tree = pop_stack(&stack);
            printf("%c ", tree->data);
        }
    }
}
/*
 * 王道 第五题 P.129 通过层次遍历获得树的深度
 * */
int tree_depth(BinaryTree *tree)
{
    if(!tree)
        return 0;
    Tqueue queue;
    queue.front = queue.rear = 0;
    int last = 1, level = 0;        //last指向下一层的第一个结点
    enqueue(&queue, tree);          //根结点入队
    while(queue.front != queue.rear)
    {
        tree = dequeue(&queue);
        if(tree->LChild)
            enqueue(&queue, tree->LChild);
        if(tree->RChild)
            enqueue(&queue, tree->RChild);
        //好好理解这里
        if(queue.front == last)     //处理该层的最右结点
        {
            level++;                //层数加一
            last = queue.rear;      //last指向下层
        }
    }
    return level;
}

int max(int a, int b)
{
    return (a > b) ? a : b;
}
/*
 * 统计树的深度，同后序遍历
 * 1.如果树空，深度为零
 * 2.否则分别递归求解左右子树的深度
 * 3.树的深度为 1+左右子树中更大的深度
 * */
int tree_depth2(BinaryTree *tree)
{
    int d = 0, dl, dr;
    if(!tree)
        d = 0;
    else
    {
        dl = tree_depth2(tree->LChild);
        dr = tree_depth2(tree->RChild);
        d = 1 + max(dl, dr);
    }
    return d;
}

/*
 * NOTE: 关键的地方还是区间划分
 * */
BinaryTree* pre_in_create_tree2(Telemtype A[], Telemtype B[], int start1, int end1, int start2, int end2)
{
    if(start1 > end1 || start2 > end2)
        return NULL;
    BinaryTree *tree;
    tree = (BinaryTree*)malloc(sizeof(BinaryTree));
    tree->data = A[start1];                                         //根结点
    for(int i = start2; i <=end2; i++)                       //根结点在中序中的划分
    {
        if(A[start1] == B[i]) {
            tree->LChild = pre_in_create_tree2(A, B, start1 + 1, start1 + i - start2, start2, i - 1);
            tree->RChild = pre_in_create_tree2(A, B, i - start2 + start1 + 1, end1, i + 1, end2);
        }
    }
    return tree;
}

/*
 * 由先序和中序遍历，来唯一确定一棵二叉树
 * 1.根据先序序列确定树的根结点
 * 2.根据根结点在中序遍历中划分左右子树，然后根据左右子树结点在先序序列中的次序，可以确定子树的根结点，（即回到第一步）
 * 王道书上 P.130 第六题
 * */
BinaryTree* pre_in_create_tree(Telemtype A[], Telemtype B[], int startPre, int endPre, int startIn, int endIn)
{
    int i;
    BinaryTree *tree;
    tree = (BinaryTree*)malloc(sizeof(BinaryTree));
    tree->data = A[startPre];
    for(i = startIn; B[i]!=tree->data; ++i);
    int LChild_len = i - startIn;                                    //左子树的长度
    int RChild_len = endIn - i;                                      //右子树的长度

    if(LChild_len)                                                  //递归建立左子树
        tree->LChild = pre_in_create_tree(A, B, startPre+1, startPre+LChild_len, startIn, startIn+LChild_len-1);   //划分的区间，是值得注意的地方
    else
        tree->LChild = NULL;

    if(RChild_len)                                                  //递归建立右子树
        tree->RChild = pre_in_create_tree(A, B, endPre-RChild_len+1, endPre, endIn-RChild_len+1, endIn);
    else
        tree->RChild = NULL;
    return tree;
}
/*
 * 层次遍历的应用
 * 1.将所有结点入队列（包括空结点）。
 * 2.当遇到空结点时，判断其后是否存在非空结点，如果存在，则不是完全二叉树
 * 王道 P.131 第七题
 * */
bool is_complete(BinaryTree *tree)
{
    Tqueue queue;
    queue.front = queue.rear = 0;
    if(!tree)
        return 1;                           //空树为满二叉树
    enqueue(&queue, tree);
    while(queue.front != queue.rear)
    {
        if(!tree)                           //结点非空，将其左右子树入队
        {
            enqueue(&queue, tree->LChild);
            enqueue(&queue, tree->RChild);
        } else {                            //结点非空，检查其后是否有非空结点
            while(queue.front != queue.rear)
            {
                tree = dequeue(&queue);
                if(tree)                    //结点非空，为非完全二叉树
                    return 0;
            }
        }
    }
    return 1;
}
/*
 * 统计双分支结点的个数
 * 递归思路
 * f(root) = 0;                                      若root == NULL
 * f(root) = f(root->LChild) + f(root->RChild) + 1;  当前root结点为双分支结点
 * f(root) = f(root->LChild) + f(root->RChild);      其他情况（当前root为单分支结点，或者root为叶子结点）
 * 王道P.131 第八题
 * */
int double_son_node(BinaryTree *tree)
{
    if(tree == NULL)
        return 0;
    if(tree->LChild != NULL && tree->RChild != NULL)
    {
        return  double_son_node(tree->LChild) + double_son_node(tree->RChild) + 1;
    }else {
        double_son_node(tree->LChild) + double_son_node(tree->RChild);
    }
}

/*
 * 交互二叉树的左右子树(后序遍历的应用)
 * 1.首先交换root的左孩子的左右子树，
 * 2.然后交换root的右孩子的左右子树
 * 3.最后交换root的左右孩子，当结点为空时递归结束
 * 王道  P.131  第九题
 * */
void swap_lrchild(BinaryTree *tree)
{
    BinaryTree *tmp;
    if(tree)
    {
        swap_lrchild(tree->LChild);
        swap_lrchild(tree->RChild);
        tmp = tree->LChild;
        tree->LChild = tree->RChild;
        tree->RChild = tmp;
    }
}
/*
 * 求先序遍历中的第k个结点的值（确保k值在有效范围内）
 * 1.设置一个全局变量itag记录访问过的结点的序号，其初值是根结点在先序序列中的序号，即为1
 * 2.当二叉树tree为空时，返回特殊结点“#”，当itag == k时，表示找到了满足条件的结点，返回 tree->data
 * 3.当itag != k 是，则递归的在左右子树中继续查找
 * 王道   P.131    第十题
 * */
int itag = 1;
Telemtype search_k_node(BinaryTree *tree, int k)
{
    if(tree == NULL)
        return '#';
    if(itag == k)
        return tree->data;
    itag++;
    Telemtype ch = search_k_node(tree->LChild, k);
    if(tree->LChild != NULL)
        return ch;
    ch = search_k_node(tree->RChild, k);
    if(tree->RChild != NULL)                        //确保一定有返回值
        return ch;
    else
        return '#';
}
/*
 * 层次遍历的基本思想，就是找到 X 结点，然后删除它这棵树
 * 1.如果当前树根为X结点，直接删掉
 * 2.否则，进行层次遍历，去找 X,找到了就删掉，
 * Note:应为之前封装的好，明显要比书上的代码形式统一，也好看的多
 * 王道 P.132 第十一题
 * */
void destroy_x_tree(BinaryTree *tree, Telemtype x)
{
    if(tree)
    {
        if(tree->data == x)
        {
            destory_tree(tree);
            return;
        }
        Tqueue queue;
        queue.front = queue.rear = 0;
        enqueue(&queue, tree);
        while(queue.front != queue.rear)
        {
            tree = dequeue(&queue);
            if(tree->LChild)
            {
                if(tree->LChild->data == x)
                {
                    destory_tree(tree->LChild);
                    tree->LChild = NULL;
                } else {
                    enqueue(&queue, tree->LChild);
                }
            }
            if(tree->RChild)
            {
                if(tree->RChild->data == x)
                {
                    destory_tree(tree->RChild);
                    tree->RChild = NULL;
                }else{
                    enqueue(&queue, tree->RChild);
                }
            }
        }
    }
    return;
}

/*
 * 打印X结点的所有祖先，用到了非递归后序遍历的栈中信息
 * 1.非递归后序遍历找到X
 * 2.此时栈中的所有元素均为该结点的祖先结点
 * Note:树上的代码是后序遍历的不同写法，感觉没必要记那种（应该看一下深入理解后序遍历），
 * 会一种就够了了，所以我的代码，就是把上边的后序遍历中的输出语句该为了判断是否是当前结点。
 * 王道 P.133 第十二题
 * */

void print_ancestor_node(BinaryTree *tree, Telemtype x)
{
    Tstack stack;
    stack.top = -1;
    if(!tree)
        printf("the tree is empty!\n");
    else{
        while(tree || stack.top != -1) {
            while (tree) {
                push_stack(&stack, tree);
                stack.tag[stack.top] = 0;       //设置访问标记，0为第一次访问，1为第二次访问
                tree = tree->LChild;
            }
            if (stack.tag[stack.top] == 0)       //第一次访问时，转向同层右结点
            {
                tree = stack.stroe[stack.top];  //左走到底时，tree是空，必须有这句话
                stack.tag[stack.top] = 1;
                tree = tree->RChild;
            } else {
                while (stack.tag[stack.top] == 1)//在栈中找到下一个第一次范格纹你的结点，退出循环时并没有pop，所以为其左子结点
                {
                    tree = pop_stack(&stack);
                    if(tree->data == x)
                    {

                        printf("\n%c ancestor is : \n",tree->data);;
                        for(int i = 0; i <= stack.top; ++i)
                        {
                            printf("%c ", stack.stroe[i]->data);
                        }
                        return;
                    }
                }
                tree = NULL;
            }
        }
    }
}

/*
 * 2016/9/1  今天就写到这里，感觉自己对后序遍历的非递归算法，理解不够。
 * 先不写了回头总结总结
 * */

int main()
{
    BinaryTree *tree;
    tree = create_tree(tree);
    printf("preorder\n");
    //preorder_traverse(tree);
    non_recursion_preorder(tree);
    printf("\ninorder\n");
    //inorder_traverse(tree);
    non_recursion_inorder(tree);
    printf("\npostorder\n");
    //postorder_traverse(tree);
    non_recursion_postorder(tree);
    printf("\nlevelorder\n");
    levelorder(tree);
    printf("\ninvert_levelorder\n");
    invert_levelorder(tree);
    printf("\nleft_node`s number is %d\n", sum_left(tree));
    printf("\ndepth is %d\n", tree_depth2(tree));
    printf("\ndepth is %d\n", tree_depth(tree));
    //Telemtype A[] = {'A','B','C','D','E','F','G','H','K'};
    //Telemtype B[] = {'B','D','C','A','E','H','G','K','F'};
    Telemtype A[] = {' ','1','2','4','7','3','5','6','8'};
    Telemtype B[] = {' ','4','7','2','1','5','3','8','6'};
    BinaryTree *root, *root2;
    root = pre_in_create_tree(A, B, 1, 8, 1, 8);
    puts("\n*********************root traverse\n");
    preorder_traverse(root);
    root2 = pre_in_create_tree2(A, B, 1, 8, 1, 8);
    puts("\n*********************root2 traverse\n");
    preorder_traverse(root2);
    printf("is complete %d\n", is_complete(root));
    printf("double son node is %d\n", double_son_node(root));

    swap_lrchild(root2);
    preorder_traverse(root2);
    printf("\n%c\n", search_k_node(root2, 4));
    destroy_x_tree(root2, '2');
    preorder_traverse(root2);
    puts("\nprint_ancestor_node");
    print_ancestor_node(root, '5');
    printf("\n\nend!!\n\n");
    return 0;
}

　　

 

 

更新一些代码

///练练练
#include <stdio.h>
#include <stdlib.h>
typedef char Telemtype;
typedef struct BinaryTree{
    Telemtype data;
    struct BinaryTree *LChild;
    struct BinaryTree *RChild;
}BinaryTree;
/* function content
 *
 * BinaryTree *create_tree(BinaryTree *root)
 * preorder_traverse(BinaryTree *root)
 * void inorder_traverse(BinaryTree *root)
 * void postorder_traverse(BinaryTree *root)
 * int sum_node(BinaryTree *root)
 * int tree_equal(BinaryTree *T1, BinaryTree *T2)
 * void destory_tree(BinaryTree *root)
 * BinaryTree *copy_tree(BinaryTree *root)
 * void non_recursion_preorder(BinaryTree *root)
 * void non_recursion_inorder(BinaryTree *root)
 * void non_recursion_postorder(BinaryTree *root)
 * void non_recursion_postorder2(BinaryTree *root)
 * void levelorder(BinaryTree *root)
 * void invert_levelorder(BinaryTree *root)
 * int tree_depth(BinaryTree *root)
 * int tree_depth2(BinaryTree *root)
 * void search_x_level(BinaryTree *root, Telemtype x)
 * BinaryTree *pre_in_create_tree(Telemtype A[], Telemtype B[], int startPre, int endPre, int startIn, int endIn)
 * BinaryTree *pre_in_create_tree2(Telemtype A[], Telemtype B[], int s1, int e1, int s2, int e2)
 * int is_complete(BinaryTree *root)
 * int double_son_node(BinaryTree *tree)
 * void swap_lrchild(BinaryTree *tree)
 * void swap_lrchild2(BinaryTree *root)
 * Telemtype search_k_node(BinaryTree *tree, int k)
 * void destroy_x_tree(BinaryTree *tree, Telemtype x)
 * void print_ancestor_node(BinaryTree *tree, Telemtype x)
 * BinaryTree *nearest_comm_ancestor(BinaryTree *tree, Telemtype p, Telemtype q)
 * int tree_width(BinaryTree *root)
 * void pre_to_post(Telemtype pre[], int s1, int e1, Telemtype post[], int s2, int e2)
 * BinaryTree *inorder_List(BinaryTree *root)
 * void link(BinaryTree *root, BinaryTree *head, BinaryTree *tail)
 * int is_similar(BinaryTree *T1, BinaryTree *T2)
 * int WPL(BinaryTree *root)
 * */
/*
 * 建树是通过先序遍历的方法进行，先输如一个字符，如果不是‘0’，则进行
 * 树的创建，否则不建树
 * 树的创建需要有一下几个步骤
 * 1.给树根结点申请空间
 * 2.给根节点的数据域赋值
 * 3.递归的分别创建左右子树
 * */
BinaryTree *create_tree(BinaryTree *root)
{
    Telemtype tmp;
    scanf("%c", &tmp);
    if(tmp == '0')
        return NULL;
    root = (BinaryTree*)malloc(sizeof(BinaryTree));
    root->data = tmp;
    root->LChild = create_tree(root->LChild);
    root->RChild = create_tree(root->RChild);
    return root;
}

/*
 * 递归写法的几种树的遍历（先序，中序，后序），都一样
 * 但是这样的写法其实在其他操作中也类似，
 * 1.比如说进行统计节点个数
 * 2.树的销毁等等
 * 对于时间复杂度，因为每个节点均遍历一次，所以复杂度为O(n)
 * */
void preorder_traverse(BinaryTree *root)
{
    if(root)
    {
        printf("%c ", root->data);
        preorder_traverse(root->LChild);
        preorder_traverse(root->RChild);
    }
}

void inorder_traverse(BinaryTree *root)
{
    if(root)
    {
        inorder_traverse(root->LChild);
        printf("%c ", root->data);
        inorder_traverse(root->RChild);
    }
}

void postorder_traverse(BinaryTree *root)
{
    if(root)
    {
        postorder_traverse(root->LChild);
        postorder_traverse(root->RChild);
        printf("%c ", root->data);
    }
}
/*
 * 统计二叉树中结点的个数
 * */
int sum_node(BinaryTree *root)
{
    if(!root)               //root == NULL
        return 0;
    else{
        return sum_node(root->LChild)
               + sum_node(root->RChild) + 1;
    }
}

/*
 * 统计叶子节点的个数
 * 1.先看当前节点是否是叶子节点，如果是叶子节点，sum值加一
 * 2.然后递归的分别统计左右子树中拥有的叶子节点的个数
 * */
int sum_leaf(BinaryTree *root)
{
    int sum = 0;
    if(root)
    {
        if(!root->LChild && !root->RChild)
            sum ++;
        if(root->LChild)
            sum += sum_leaf(root->LChild);
        if(root->RChild)
            sum += sum_leaf(root->RChild);
    }
    return sum;
}
/*
 * 1.如果两颗树是空树，则两颗树相等
 * 2.否则，判断当前树的根节点是否相等
 * 3.然后再递归的判断左右子树
 * 4.如果都相同，发回1.否则返回0
 * */
int tree_equal(BinaryTree *T1, BinaryTree *T2)
{
    if(!T1 && !T2)
        return 1;

    if(T1 && T2 && T1->data == T2->data)
    if(tree_equal(T1->LChild, T2->LChild))
    if(tree_equal(T1->RChild, T2->RChild))
        return 1;
    return 0;
}
/*
 * 思路同后序遍历
 * 1.先销毁左右子树
 * 2.然后释放当前根节点的空间
 * 3.将指针的指向   指到NULL
 * Note：free(tree)仅仅收回内存，不会改变T的指向。
 * */
void destory_tree(BinaryTree *root)
{
    if(!root)
        return;

    destory_tree(root->LChild);
    destory_tree(root->RChild);
    free(root);
    root = NULL;
    return;
}

/*
 * 树的复制包含两部分，一部分是，为要根节点设置值和要指向的左右子树
 * 第二部分就是递归的复制左右子树
 * 左右子树的复制，还是同后序遍历
 * */
BinaryTree *get_tree_node(Telemtype data, BinaryTree *LChild, BinaryTree *RChild)
{
    BinaryTree *root;
    root = (BinaryTree*)malloc(sizeof(BinaryTree));
    root->data = data;
    root->LChild = LChild;
    root->RChild = RChild;
    return root;
}

BinaryTree *copy_tree(BinaryTree *root)
{
    BinaryTree *newLChild, *newRChild, *newRoot;
    if(!root)
        return NULL;

    if(root->LChild)
        newLChild = copy_tree(root->LChild);
    else
        newLChild = NULL;
    if(root->RChild)
        newRChild = copy_tree(root->RChild);
    else
        newRChild = NULL;

    newRoot = get_tree_node(root->data, newLChild, newRChild);

    return newRoot;
}

/*
 * 非递归的遍历就要用到 Stack & Queue
 * 1.Stack的初始化  stack.top = -1;
 * 2.Queue的初始化  queue.front = queue.rear = 0;
 * */
typedef struct TreeStack{
    BinaryTree *stroe[1000];
    int tag[1000];          //后序遍历要用到的标志域
    int top;
}Tstack;
/*
 *1.压栈操作，top+1 然后在当前位置存放节点信息
 *2.出栈操作，返回当前栈顶元素，然后top-1
 * */
void push_stack(Tstack *stack, BinaryTree *root)
{
    if(stack->top == 1000)
        printf("the stack is full!\n");
    else{
        stack->top++;
        stack->stroe[stack->top] = root;
    }
}

BinaryTree* pop_stack(Tstack *stack)
{
    if(stack->top == -1)
        return NULL;
    else{
        stack->top--;
        return stack->stroe[stack->top+1];
    }
}

typedef  struct TreeQueue{
    BinaryTree *stroe[1000];
    int level[1000];
    int front;
    int rear;
}Tqueue;
/*
 * 入队，出队比较简单
 * */
void enqueue(Tqueue *queue, BinaryTree *root)
{
    if(queue->rear == 1000)
        printf("the queue is full!\n");
    else{
        queue->stroe[queue->rear] = root;
        queue->rear++;
    }
}

BinaryTree* dequeue(Tqueue *queue)
{
    if(queue->front == queue->rear)
        return NULL;
    else{
        queue->front++;
        return queue->stroe[queue->front-1];
    }

}
/*
 * Note: 请先参照中序遍历，中序遍历是教科书说法，比较准确
 * 先序遍历的非递归算法和中序遍历的非递归算法类似
 * 1.先访问当前根结点，并将根结点入栈，往左走
 * 2.当当前节点没有左孩子时，将当前结点出栈，并访问他的右孩子
 * 3.一直循环，直到栈空
 * */
void non_recursion_preorder(BinaryTree *root)
{
    Tstack stack;
    stack.top = -1;
    if(!root)
        printf("the tree is empty!\n");
    else{
        while(root || stack.top != -1)
        {
            if(root)
            {
                printf("%c ", root->data);
                push_stack(&stack, root);
                root = root->LChild;
            }else{
                root = pop_stack(&stack);
                root = root->RChild;
            }
            /*
             while(root)                        //类似于中序遍历,详见下边
             {
                printf("%c ", root->LChild);
                push_stack(&stack, root);
                root = root->LChild;
             }
                root = pop_stack(&stack);
                root = root->RChild;
             * */
        }
    }
}

/*
 * 1.先扫描（并非访问）根结点的所有左结点并将他们一一进栈
 * 2.当当前结点没有左子树（或者做孩子结点已经访问过），将其出栈，访问他
 * 3.然后扫描该结点的右孩子结点，将其进栈，再扫描右孩子结点的所有左结点并一一进栈，如此继续，直到栈空
 * */
void non_recursion_inorder(BinaryTree *root)
{
    Tstack stack;
    stack.top = -1;
    if(!root)
    {
        printf("the tree is empty!\n");
    }else {
        while(root || stack.top != -1)  //树根节点不空，或者栈不空时
        {
            if(root){
                push_stack(&stack, root);   //根结点进栈，遍历左子树
                root = root->LChild;        //每次遇到非空的左子树，就往左走
            }else{
                root = pop_stack(&stack);   //根指针退栈，访问根节点，遍历右子树
                printf("%c ", root->data);
                root = root->RChild;
            }

            /*
             while(root)                     //另外一种好的写法，只要有左子树，就往左走
             {
                 push_stack(&stack, root);   //根结点进栈，遍历左子树
                 root = root->LChild;        //每次遇到非空的左子树，就往左走
             }
             root = pop_stack(&stack);       //根指针退栈，访问根节点，遍历右子树
             printf("%c ", root->data);
             root = root->RChild;
             * */
        }
    }
}

/*
 * 后序遍历是先访问左右子树，最后访问根结点。
 * 当用栈来存储结点时，必须分清返回根结点时，是从左结点返回的，还是从右结点返回的
 * 用辅助指针可以写（也可以在结点中增加一个标志域）
 * 1.从根结点一直向左走，直到没有左子树
 * 2.转向向右走，先取栈顶指针
 * 3.判断是否有右子树
 *    4.若存在右子树且右子树是否被访问过，转向右子树，将右子树根结点压栈，继续走到最左边
 *    5.不满足4，弹出当前根结点，进行访问，并做标记，将root置空,必须将root置空，跳过向左走，直接向右走
 *
 * Note:当访问一个结点 *tmp (就是当前root)时，栈中的结点恰好是*tmp结点的所有祖先。
 *      从栈底到栈顶结点再加上*tmp结点，刚好构成从根结点到*tmp的一条路径
 *      在很多算法设计中都用到了这一特行，比如：
 *                *求根结点到某结点的路径
 *                *求两个结点的最近公共祖先
 * */

void non_recursion_postorder(BinaryTree *root)
{
    Tstack stack;
    stack.top = -1;
    BinaryTree *vis = NULL;

    if(!root)
        printf("the tree is empty!\n");

    while(root || stack.top != -1)
    {
        if(root)                                    //走到最左边
        {
            push_stack(&stack, root);
            root = root->LChild;
        }else{                                      //向右走
            root = stack.stroe[stack.top];           //取栈顶元素    王道 P.128
            if(root->RChild && root->RChild != vis)   //如果右子树存在，且未被访问过
            {
                root = root->RChild;                  //转向右子树
                push_stack(&stack, root);            //压栈
                root = root->LChild;                  //继续走到最左边
            }else{                                  //如果右子树不存在，或者已经访问过
                root = pop_stack(&stack);            //弹出当前的根结点
                printf("%c ", root->data);           //进行访问
                vis = root;                          //标记访问过
                root = NULL;                         //访问过后，重置root指针,必须将root置空，跳过向左走，直接向右走
            }
        }
    }
}

//后序遍历的标记数据域标记写法,这个不推荐
void non_recursion_postorder2(BinaryTree *root)
{
    Tstack stack;
    stack.top = -1;
    if(!root)
        printf("the tree is empty!\n");
    else{
        while(root || stack.top != -1) {
            while (root) {
                push_stack(&stack, root);
                stack.tag[stack.top] = 0;       //设置访问标记，0为第一次访问，1为第二次访问
                root = root->LChild;
            }
            if (stack.tag[stack.top] == 0)       //第一次访问时，转向同层右结点
            {
                root = stack.stroe[stack.top];  //左走到底时，tree是空，必须有这句话
                stack.tag[stack.top] = 1;
                root = root->RChild;
            } else {
                while (stack.tag[stack.top] == 1)//在栈中找到下一个第一次范格纹你的结点，退出循环时并没有pop，所以为其左子结点
                {
                    root = pop_stack(&stack);
                    printf("%c ", root->data);
                }
                root = NULL;
            }
        }
    }
}

/*
 * 层次遍历，其实就是BFS  （广度优先搜索）
 * */
void levelorder(BinaryTree *root)
{
    Tqueue queue;
    queue.front = queue.rear = 0;

    if(!root)
        printf("the tree is empty!\n");

    enqueue(&queue, root);              //根结点入队

    while(queue.front != queue.rear)
    {  //队列不为空时，循环
        root = dequeue(&queue);         //队头元素出队
        printf("%c ", root->data);      //访问当前结点

        if (root->LChild != NULL)
            enqueue(&queue, root->LChild);

        if (root->RChild != NULL)
            enqueue(&queue, root->RChild);
    }
}
/*
 * 层次遍历的应用，将树自下而上，自右向左遍历，
 * 就是把层次遍历访问的结点入栈，然后从栈弹出的顺序
 * 王道 P.128
 * */
void invert_levelorder(BinaryTree *root)
{
    Tqueue queue;
    Tstack stack;

    if(!root)
        printf("the tree is empty!\n");

    stack.top = -1;
    queue.front = queue.rear = 0;
    enqueue(&queue, root);              //根结点入队

    while(queue.front != queue.rear)
    {
        root = dequeue(&queue);
        push_stack(&stack, root);      //当前结点 入栈

        if (root->LChild != NULL)
            enqueue(&queue, root->LChild);

        if (root->RChild != NULL)
            enqueue(&queue, root->RChild);
    }

    while(stack.top != -1)
    {
        root = pop_stack(&stack);
        printf("%c ", root->data);
    }
}
/*
 * 王道 第五题 P.129 通过层次遍历获得树的深度
 * */
int tree_depth(BinaryTree *root)
{
    Tqueue queue;

    if(!root)
        return 0;

    queue.front = queue.rear = 0;
    int last = 1, level = 0;        //last指向下一层的第一个结点
    enqueue(&queue, root);          //根结点入队

    while(queue.front != queue.rear)
    {
        root = dequeue(&queue);

        if(root->LChild)
            enqueue(&queue, root->LChild);
        if(root->RChild)
            enqueue(&queue, root->RChild);

        //好好理解这里
        if(queue.front == last)     //处理该层的最右结点
        {
            level++;                //层数加一
            last = queue.rear;      //last指向下层
        }
    }
    return level;
}

int max(int a, int b)
{
    return (a > b) ? a : b;
}
/*
 * 统计树的深度，同后序遍历
 * 1.如果树空，深度为零
 * 2.否则分别递归求解左右子树的深度
 * 3.树的深度为 1+左右子树中更大的深度
 * */
int tree_depth2(BinaryTree *root)
{
    int d = 0, dl, dr;
    if(!root)
        d = 0;
    else
    {
        dl = tree_depth2(root->LChild);
        dr = tree_depth2(root->RChild);
        d = 1 + max(dl, dr);
    }
    return d;
}

/*
 *求二叉树中值为x的结点所在的层数
 * */
void search_x_level(BinaryTree *root, Telemtype x)
{
    static int level = 1;
    if(root)
    {
        if(root->data == x)
            printf("the x level is %d\n", level) ;
        level++;
        search_x_level(root->LChild, x);
        search_x_level(root->RChild, x);
        level--;
    }
}

/*
 * 下面这种写法，牛逼666,学这个
 * NOTE: 关键的地方还是区间划分
 * s1 : start1, e1 : end1
 * s2 : start2, e2 : end2
 * */
BinaryTree *pre_in_create_tree2(Telemtype A[], Telemtype B[], int s1, int e1, int s2, int e2)
{
    if(s1 > e1 || s2 > e2)
        return NULL;
    BinaryTree *root;
    root = (BinaryTree*)malloc(sizeof(BinaryTree));
    root->data = A[s1];                                         //根结点
    for(int i = s2; i <=e2; i++)                       //根结点在中序中的划分
    {
        if(A[s1] == B[i]) {
            root->LChild = pre_in_create_tree2(A, B, s1 + 1, s1 + i - s2, s2, i - 1);
            root->RChild = pre_in_create_tree2(A, B, i - s2 + s1 + 1, e1, i + 1, e2);
        }
    }
    return root;
}

/*
 * 由先序和中序遍历，来唯一确定一棵二叉树
 * 1.根据先序序列确定树的根结点
 * 2.根据根结点在中序遍历中划分左右子树，然后根据左右子树结点在先序序列中的次序，可以确定子树的根结点，（即回到第一步）
 * 王道书上 P.130 第六题
 * */
BinaryTree *pre_in_create_tree(Telemtype A[], Telemtype B[], int startPre, int endPre, int startIn, int endIn)
{
    int i;
    BinaryTree *root;
    root = (BinaryTree*)malloc(sizeof(BinaryTree));
    root->data = A[startPre];
    for(i = startIn; B[i]!=root->data; ++i);
    int LChild_len = i - startIn;                                    //左子树的长度
    int RChild_len = endIn - i;                                      //右子树的长度

    if(LChild_len)                                                  //递归建立左子树
        root->LChild = pre_in_create_tree(A, B, startPre+1, startPre+LChild_len, startIn, startIn+LChild_len-1);   //划分的区间，是值得注意的地方
    else
        root->LChild = NULL;

    if(RChild_len)                                                  //递归建立右子树
        root->RChild = pre_in_create_tree(A, B, endPre-RChild_len+1, endPre, endIn-RChild_len+1, endIn);
    else
        root->RChild = NULL;

    return root;
}
/*
 * 层次遍历的应用
 * 1.将所有结点加入队列（包括空结点）。
 * 2.当遇到空结点时，判断其后是否存在非空结点，如果存在，则不是完全二叉树
 * 王道 P.131 第七题
 * */
int is_complete(BinaryTree *root)
{
    Tqueue queue;

    if(!root)
        return 1;                           //空树为满二叉树

    queue.front = queue.rear = 0;
    enqueue(&queue, root);

    while(queue.front != queue.rear)
    {
        if(!root)                           //结点非空，将其左右子树入队
        {
            enqueue(&queue, root->LChild);
            enqueue(&queue, root->RChild);
        } else {                            //结点非空，检查其后是否有非空结点
            while(queue.front != queue.rear)
            {
                root = dequeue(&queue);
                if(root)                    //结点非空，为非完全二叉树
                    return 0;
            }
        }
    }
    return 1;
}
/*
 * 统计双分支结点的个数
 * 递归思路
 * f(root) = 0;                                      若root == NULL
 * f(root) = f(root->LChild) + f(root->RChild) + 1;  当前root结点为双分支结点
 * f(root) = f(root->LChild) + f(root->RChild);      其他情况（当前root为单分支结点，或者root为叶子结点）
 * 王道P.131 第八题
 * */
int double_son_node(BinaryTree *tree)
{
    if(tree == NULL)
        return 0;
    if(tree->LChild != NULL && tree->RChild != NULL)
    {
        return  double_son_node(tree->LChild) + double_son_node(tree->RChild) + 1;
    }else
    {
        return double_son_node(tree->LChild) + double_son_node(tree->RChild);
    }
}

/*
 * 交互二叉树的左右子树(后序遍历的应用)
 * 1.首先交换root的左孩子的左右子树，
 * 2.然后交换root的右孩子的左右子树
 * 3.最后交换root的左右孩子，当结点为空时递归结束
 * 王道  P.131  第九题
 * */
void swap_lrchild(BinaryTree *tree)
{
    BinaryTree *tmp;
    if(tree)
    {
        swap_lrchild(tree->LChild);
        swap_lrchild(tree->RChild);
        tmp = tree->LChild;
        tree->LChild = tree->RChild;
        tree->RChild = tmp;
    }
}
/*
 * 借用队列实现左右子树交换
 * */
void swap_lrchild2(BinaryTree *root)
{
    BinaryTree *p, *tmp;
    Tqueue queue;
    queue.front = queue.rear = 0;
    if(root)
        enqueue(&queue, root);
    while(queue.rear != queue.front)
    {
        p = dequeue(&queue);
        if(p->LChild)
            enqueue(&queue, p->LChild);
        if(p->RChild)
            enqueue(&queue, p->RChild);

        tmp = p->LChild;
        p->LChild = p->RChild;
        p->RChild = tmp;
    }

}
/*
 * 求先序遍历中的第k个结点的值（确保k值在有效范围内）
 * 1.设置一个全局变量itag记录访问过的结点的序号，其初值是根结点在先序序列中的序号，即为1
 * 2.当二叉树tree为空时，返回特殊结点“#”，当itag == k时，表示找到了满足条件的结点，返回 tree->data
 * 3.当itag != k 是，则递归的在左右子树中继续查找
 * 王道   P.131    第十题
 * */
int itag = 1;
Telemtype search_k_node(BinaryTree *tree, int k)
{
    if(tree == NULL)
        return '#';
    if(itag == k)
        return tree->data;
    itag++;
    Telemtype ch = search_k_node(tree->LChild, k);
    if(tree->LChild != NULL)
        return ch;
    ch = search_k_node(tree->RChild, k);
    if(tree->RChild != NULL)                        //确保一定有返回值
        return ch;
    else
        return '#';
}
/*
 * 层次遍历的基本思想，就是找到 X 结点，然后删除它这棵树
 * 1.如果当前树根为X结点，直接删掉
 * 2.否则，进行层次遍历，去找 X,找到了就删掉，
 * Note:应为之前封装的好，明显要比书上的代码形式统一，也好看的多
 * 王道 P.132 第十一题
 * */
void destroy_x_tree(BinaryTree *tree, Telemtype x)
{
    if(tree)
    {
        if(tree->data == x)
        {
            destory_tree(tree);
            return;
        }
        Tqueue queue;
        queue.front = queue.rear = 0;
        enqueue(&queue, tree);
        while(queue.front != queue.rear)
        {
            tree = dequeue(&queue);
            if(tree->LChild)
            {
                if(tree->LChild->data == x)
                {
                    destory_tree(tree->LChild);
                    tree->LChild = NULL;
                } else {
                    enqueue(&queue, tree->LChild);
                }
            }
            if(tree->RChild)
            {
                if(tree->RChild->data == x)
                {
                    destory_tree(tree->RChild);
                    tree->RChild = NULL;
                }else{
                    enqueue(&queue, tree->RChild);
                }
            }
        }
    }
    return;
}

/*
 * 打印X结点的所有祖先，用到了非递归后序遍历的栈中信息
 * 1.非递归后序遍历找到X
 * 2.此时栈中的所有元素均为该结点的祖先结点
 * Note:树上的代码是后序遍历的不同写法，感觉没必要记那种（应该看一下深入理解后序遍历），
 * 会一种就够了了，所以我的代码，就是把上边的后序遍历中的输出语句该为了判断是否是当前结点。
 * 王道 P.133 第十二题
 * */

void print_ancestor_node(BinaryTree *tree, Telemtype x)
{
    Tstack stack;
    stack.top = -1;
    if(!tree)
        printf("the tree is empty!\n");
    else{
        while(tree || stack.top != -1) {
            while (tree) {
                push_stack(&stack, tree);
                stack.tag[stack.top] = 0;       //设置访问标记，0为第一次访问，1为第二次访问
                tree = tree->LChild;
            }
            if (stack.tag[stack.top] == 0)       //第一次访问时，转向同层右结点
            {
                tree = stack.stroe[stack.top];  //左走到底时，tree是空，必须有这句话
                stack.tag[stack.top] = 1;
                tree = tree->RChild;
            } else {
                while (stack.tag[stack.top] == 1)//在栈中找到下一个第一次范格纹你的结点，退出循环时并没有pop，所以为其左子结点
                {
                    tree = pop_stack(&stack);
                    //每次根改动都是下边
                    if(tree->data == x)
                    {

                        printf("\n%c ancestor is : \n",tree->data);;
                        for(int i = 0; i <= stack.top; ++i)
                        {
                            printf("%c ", stack.stroe[i]->data);
                        }
                        return;
                    }
                    //*********************
                }
                tree = NULL;
            }
        }
    }
}
/*
 * 求 p q两个结点的最近公共祖先，非递归后序遍历的应用，就是利用栈信息
 * 假设p 在 q的左边
 * 1.后序遍历必然先遍历到 p,这时把栈中的信息借用辅助栈保存起来
 * 2.继续遍历，遍历到 q 结点的时候，将栈中的结点逐个和辅助栈的结点匹配，
 *      第一个相等的元素就是p & q的最近公共祖先
 * 王道 P.134 第13题
 * */
BinaryTree *nearest_comm_ancestor(BinaryTree *tree, Telemtype p, Telemtype q)
{
    Tstack stack;
    Tstack ass_stack;
    stack.top = -1;
    ass_stack.top = -1;
    while(tree || stack.top != -1)
    {
        while(tree)
        {
            push_stack(&stack, tree);
            stack.tag[stack.top] = 0;
            tree = tree->LChild;
        }
        if(stack.tag[stack.top] == 0)
        {
            tree = stack.stroe[stack.top];
            stack.tag[stack.top] = 1;
            tree = tree->RChild;
        } else {
            while(stack.tag[stack.top] == 1)
            {
                tree = pop_stack(&stack);
                //每次根改动都是下边
                if(tree->data == p)
                {
                    for(int i = 0; i <= stack.top; ++i)
                    {
                        ass_stack.stroe[i] = stack.stroe[i];
                        ass_stack.top = stack.top;
                    }
                }
                if(tree->data == q)
                {
                    for(int i = stack.top; i >= 0; --i)
                    {
                        for(int j = ass_stack.top; j >= 0; --j)
                        {
                            if(stack.stroe[i]->data == ass_stack.stroe[j]->data)
                            {
                                return stack.stroe[i];
                            }
                        }
                    }
                }
                //*********************
            }
            tree = NULL;
        }
    }
    return NULL;
}

/*
 * 求树的宽度，二叉树的宽度即 某一层拥有最多的结点树（层次遍历的应用）
 * 将所有节点对应的层次放在一个队列里，然后通过扫描队列求出各层的总结点的个数，最大的层结点即为二叉树的宽度
 * 王道  P.135  第十四题
 * */

int tree_width(BinaryTree *root)
{
    Tqueue queue;
    int k, max, i, n;

    if(!root)
        return 0;

    queue.front = queue.rear = 0;
    enqueue(&queue, root);
    queue.level[queue.rear] = 1;

    while(queue.front != queue.rear)
    {
        root = dequeue(&queue);
        k = queue.level[queue.front];
        if(root->LChild)
        {
            enqueue(&queue, root->LChild);
            queue.level[queue.rear] = k + 1;
        }
        if(root->RChild)
        {
            enqueue(&queue, root->RChild);
            queue.level[queue.rear] = k + 1;
        }
    }

    max = 0; i = 0;                                            ///max保存同一层最多的结点个数
    k = 1;                                                     ///k表示从第一层开始查找
    while(i <= queue.rear)                                     ///i扫描队中所有的元素
    {
        n = 0;                                                  ///n统计第k层的结点个数
        while(i <= queue.rear && queue.level[i] == k)
        {
            n++;
            i++;
        }
        k = queue.level[i];
        if(n > max)
            max = n;
    }
    return  max;
}

/*
 * 15、设有一棵满二叉树（所有结点的值均不相同），已知先序序列，求其后序序列
 *王道P1
 * */

void pre_to_post(Telemtype pre[], int s1, int e1, Telemtype post[], int s2, int e2)
{
    int half;
    if(e1 >= s1)
    {
        post[e2] = pre[s1];
        half = (e1 - s1) / 2;
        pre_to_post(pre, s1+1, s1+half, post, s2, s2+half-1);
        pre_to_post(pre, s1+half+1, e1, post, s1+half, e2-1);
    }
}

/*
 *16、将二叉树的叶节点按从左到右的顺序连城一个单链表，表头指针为head。
 * 二叉树按二叉链表的方式存储，链接时用叶结点的右指针域来存放指针单链表
 * */

BinaryTree *head, *pre = NULL;
BinaryTree *inorder_List(BinaryTree *root)
{
    if(root)
    {
        inorder_List(root->LChild);
        if (!root->LChild && !root->RChild) {
            if (!pre) {
                head = root;
                pre = root;
            } else {
                pre->RChild = root;
                pre = root;
            }
            inorder_List(root->RChild);
            pre->RChild = NULL;
        }
    }
    return head;
}
/*
 * 利用结点的右孩子rchild将一颗二叉树的叶子结点按照从左往右的顺序串成一个单链表
 * */
void link(BinaryTree *root, BinaryTree *head, BinaryTree *tail)
{
    if(root)
    {
        if(!root->LChild && !root->RChild)
        {
            if(!head)
            {
                head = root;
                tail = root;
            }else
            {
                tail->RChild = root;
                tail = root;
            }
        }
        link(root->LChild, head, tail);
        link(root->RChild, head, tail);
    }
}


/*
 *17、判断两颗二叉树是否相似
 * 相似：T1，T2都是空二叉树或都只有一个根结点，或T1的左子树和T2的左子树相似，T1的右子树和T2的右子树相似
 * */
int is_similar(BinaryTree *T1, BinaryTree *T2)
{
    int lvalue, rvalue;
    if(!T1 && !T2)
        return 1;
    else if(!T1 || !T2)
        return 0;
    else
    {
        lvalue = is_similar(T1->LChild, T2->LChild);
        rvalue = is_similar(T1->RChild, T2->RChild);
        return (lvalue&&rvalue);
    }
}

/*
 *18、写出中序线索二叉树里查找指定结点后序的前驱结点的算法
 * */

/*
 *19、求二叉树的带却路径长度（WPL）。
 * WPL指二叉树中所有叶结点的带权路径长度之和。
 * */
int wpl_preorder(BinaryTree *root, int deep)
{
    static int wpl = 0;
    if(!root->LChild && !root->RChild)
        wpl += deep*(root->data - '0');     ///此时data中存放的是权值，但我们data是char型。
    if(root->LChild)
        wpl_preorder(root->LChild, deep+1);
    if(root->RChild)
        wpl_preorder(root->RChild, deep+1);
    return wpl;
}

int WPL(BinaryTree *root)
{
    return wpl_preorder(root, 0);
}

/*
int main()
{
    BinaryTree *tree;
    tree = create_tree(tree);
    printf("preorder\n");
    //preorder_traverse(tree);
    non_recursion_preorder(tree);
    printf("\ninorder\n");
    //inorder_traverse(tree);
    non_recursion_inorder(tree);
    printf("\npostorder\n");
    //postorder_traverse(tree);
    non_recursion_postorder(tree);
    printf("\nlevelorder\n");
    levelorder(tree);
    printf("\ninvert_levelorder\n");
    invert_levelorder(tree);
    printf("\nleft_node`s number is %d\n", sum_leaf(tree));
    printf("\ndepth is %d\n", tree_depth2(tree));
    printf("\ndepth is %d\n", tree_depth(tree));
    //Telemtype A[] = {'A','B','C','D','E','F','G','H','K'};
    //Telemtype B[] = {'B','D','C','A','E','H','G','K','F'};
    Telemtype A[] = {' ', '1', '2', '4', '7', '3', '5', '6', '8'};
    Telemtype B[] = {' ', '4', '7', '2', '1', '5', '3', '8', '6'};
    BinaryTree *root, *root2;
    root = pre_in_create_tree(A, B, 1, 8, 1, 8);
    puts("\n*********************root traverse\n");
    preorder_traverse(root);
    root2 = pre_in_create_tree2(A, B, 1, 8, 1, 8);
    puts("\n*********************root2 traverse\n");
    preorder_traverse(root2);
    printf("is complete %d\n", is_complete(root));
    printf("double son node is %d\n", double_son_node(root));
    printf("\nthe swap_lrChild2\n");
    swap_lrchild2(tree);
    preorder_traverse(tree);
    puts("the end swap_LRChile\n");
    preorder_traverse(root2);
    printf("\n%c\n", search_k_node(root2, 4));
    destroy_x_tree(root2, '2');
    preorder_traverse(root2);
    puts("\nprint_ancestor_node");
    print_ancestor_node(root, '5');
    root2 = nearest_comm_ancestor(root, '5', '6');
    printf("\nthe nearest_comm_ancestor is %c ", root2->data);
    printf("\n\nend!!\n\n");



    ///copy_tree   Test
    BinaryTree *copy_tree_root = copy_tree(tree);
    preorder_traverse(copy_tree_root);
    preorder_traverse(tree);
    ///tree_width  Test
    int width = tree_width(tree);
    printf("\nthe tree`s width is %d\n", width);

    ///search_x_level Test
    search_x_level(tree, '3');
    search_x_level(tree, '2');
    search_x_level(tree, '1');
    search_x_level(tree, '4');

    ///sum_node
    int s_node = sum_node(tree);
    printf("%d\n", s_node);

    return 0;
}
*/
///test case ：12003400500