【数据结构】---------二叉树面试题（具体的所有实现）

实现二叉树的相关的操作：

• 先序遍历树（递归）
• 中序遍历树（递归）
• 后序遍历树（递归）
• 层序遍历树
• 创建一棵树
• 树的销毁
• 树的拷贝
• 二叉树中节点的个数
• 二叉树叶子节点的个数
• 二叉树第K层节点的个数
• 树的高度
• 在二叉树中查找节点
• 找当前节点的左子树
• 找当前节点的右子树
• 找当前节点的父节点
• 非递归完成先序遍历
• 非递归完成中序遍历
• 非递归完成后序遍历
• 二叉树的镜像
• 非递归完成二叉树的镜像
-

相关的操作的代码如下：

test.h的实现

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>

#define MAXSIZE 100
typedef char TreeNodeType;

typedef struct TreeNode* SeqQType;

typedef struct SeqQ{
        SeqQType data[MAXSIZE];//定义了一个长度为100的队列
    size_t size;//记录当前顺序表的大小
    size_t head;
    size_t tail;
    size_t capacity;
}SeqQ;


typedef struct TreeNode*  StackType;

typedef struct SeqStack{
    StackType* data;//使内存可以动态管理
    int size;//栈元素的有效个数
    int capacity;//栈默认的空间，data这段内存上所能容纳的元素的个数
    }SeqStack;

typedef struct TreeNode{
    struct TreeNode* lchild;
    struct TreeNode* rchild;
    TreeNodeType data;
}TreeNode;

void TreeInit(TreeNode** root,TreeNodeType value); 

void PreOrder(TreeNode* root); 

void InOrder(TreeNode* root); 

void PostOrder(TreeNode* root); 

void LevelOrder(TreeNode* root);

TreeNode*  TreeCreate(TreeNodeType array[], size_t size,size_t  *index, TreeNodeType null_node);  

TreeNode* TreeDestroy(TreeNode** root);

TreeNode* TreeDestroy1(TreeNode** root);
// 深复制树，即克隆
 TreeNode* TreeClone(TreeNode* root);

 // 求树的结点数
 size_t TreeSize1(TreeNode* root);
 size_t TreeSize2(TreeNode* root);

 // 求一棵树的叶子节点数
size_t TreeLeafSize(TreeNode* root);

 // 求一棵树第K层结点的个数
size_t TreeLevelSize(TreeNode* root, size_t K);

// 求树的高度
size_t TreeHight(TreeNode* root);

 // 在树中查找一个元素，并返回它的指针
 TreeNode* TreeFind(TreeNode* root, TreeNodeType to_find);

// 返回节点的左孩子节点
 TreeNode* TreeLchild(TreeNode* root);

 // 返回节点的右孩子节点
TreeNode* TreeRchild(TreeNode* root);

 // 返回当前节点的父节点
 TreeNode* TreeParent(TreeNode* root, TreeNode* node);


 void PreOrderByLoop(TreeNode* root);//非递归完成先序遍历

 void InOrderByLoop(TreeNode* root);//非递归完成中序遍历

 void PostOrderByLoop(TreeNode* root);//非递归完成后序遍历

 void TreeMirror(TreeNode* root);//二叉树的镜像(翻转)

 void TreeMirrorByLoop(TreeNode* root);//非递归完成二叉树的镜像

 int IsCompleteTree(TreeNode* root);//判断一棵树二叉树是否是完全二叉树

test.c的实现

#include "tree.h"


void TreeInit(TreeNode** root,TreeNodeType value)
{
    if(root==NULL)
    {
    return;
    }
    (*root)=malloc(sizeof(TreeNode));
    (*root)->lchild=NULL;
    (*root)->rchild=NULL;
    (*root)->data=value;
}

void PreOrder(TreeNode* root)
{
      if(root==NULL)
    {
    return;
    }
 //先访问根节点
 printf("%c ",root->data);
 //再访问左子树
 PreOrder(root->lchild);
 //访问右子树
 PreOrder(root->rchild);
}


void InOrder(TreeNode* root)
{
    if(root==NULL)
    {
    return;
    }
    //访问左子树
    InOrder(root->lchild);
    //访问根节点
    printf("%c ",root->data);
    //访问右子树
    InOrder(root->rchild);
}

void PostOrder(TreeNode* root)
{
    if(root==NULL)
    {
    return;
    }
    //先访问左子树
    PostOrder(root->lchild);
    //访问右子树
    PostOrder(root->rchild);
    //访问根结点
    printf("%c ",root->data);
}

void SeqQInit(SeqQ* sq)
{
        if (sq == NULL)
    {
       return;
    }
    sq->size = 0;
    sq->head = 0;
    sq->tail = 0;
}

void SeqQResize(SeqQ* sq){
        if (sq == NULL){
        return;
    }
    if (sq->size <= MAXSIZE){
        return;
    }
    int size = MAXSIZE * 2 + 1;
    SeqQType* new = (SeqQType*)malloc(sizeof(SeqQType));
    int i =0;
    for (; i<sq->size; i++){
        new[i] = sq->data[i];
    }
    free(sq->data);
}

void SeqQPush(SeqQ* sq, SeqQType value)
{
        if (sq == NULL){
        return;
    }
    if (sq->size>=MAXSIZE)
    {
        SeqQResize(sq);
    return;
        }  
     sq->data[sq->tail++] = value;
      if (sq->tail >= MAXSIZE){
       sq->tail = 0;
      }
        ++sq->size;
}

void SeqQPop(SeqQ* sq){
        if (sq == NULL){
        return;
    }
    if (sq->size == 0){
        return;
    }
    ++sq->head;
    if (sq->head >= MAXSIZE){
        sq->head = 0;
    }
    --sq->size;
}
int  SeqQFront(SeqQ* sq, SeqQType* value){
        if (sq == NULL || value==NULL){
            return 0;
    }
        if (sq->size == 0){
            return 0;
        }
        *value = sq->data[(sq->head)];//注意在这里考虑优先级的问题
        return 1;
}


void LevelOrder(TreeNode* root)
{
    if(root==NULL)
    {
        return;
    }
     SeqQ sq;
     SeqQInit(&sq);
     SeqQPush(&sq,root);
    //将队首元素进行入队列
   while(1)
   {
    SeqQType front;
    int ret=SeqQFront(&sq,&front);
    //返回值为空时，说明树已经访问完了，循环结束
    if(ret == 0)
    {
    //若取队首失败，则为空，说明遍历结束
    break;
    }
   //访问队首元素
    printf("%c ",front->data);
    SeqQPop(&sq);
    //入队列左右子树
    if(front->lchild!=NULL)
    {
    SeqQPush(&sq,front->lchild);
    }
    if(front->rchild!=NULL)
    {
    SeqQPush(&sq,front->rchild);
    }
   }
}

TreeNode*  TreeNodeCreate(TreeNodeType value)
{
   TreeNode* newnode=(TreeNode*)malloc(sizeof(TreeNode));
   newnode->data=value;
   newnode->lchild=NULL;
   newnode->rchild=NULL;
   return newnode;
}


TreeNode* TreeCreate(TreeNodeType array[], size_t size,size_t  *index, TreeNodeType null_node)
//根据先序遍历的结构，带有空结点的进行标记，构造成一棵树，array[] 先序遍历的结果 
//size 数组中元素个数，null_node 数组中空节点的特殊标记
{
    if(index==NULL)
    {
    return NULL;
    }
    //index表示当前取数组中的哪一个元素

    //index不在有效的范围内
    if(*index>=size){
    return NULL;
    }
    //如果该节点为空节点
    if(array[*index]==null_node)
    {
    return NULL;
    }
    //创建根结点
    TreeNode* newnode=TreeNodeCreate(array[*index]);
    //创建左子树
    ++(*index);
    newnode->lchild=TreeCreate(array,size,index,null_node);
    //创建右子树
    ++(*index);
    newnode->rchild=TreeCreate(array,size,index,null_node);
    return newnode;
} 

void DestroyNode(TreeNode** node)
{
    if(node==NULL || *node==NULL)
    return;
    free(*node);
    *node=NULL;
}

//方法一：使用的是后序便利的方法，不用额外的保存节点信息
TreeNode* TreeDestroy(TreeNode** root)
{
    if(root==NULL)
    {
    return NULL;
    }
    if(*root==NULL)
    {
    //空树
    return NULL;
    }
    //递归的销毁左子树
    TreeDestroy(&(*root)->lchild);
    //递归的销毁右子树
    TreeDestroy(&(*root)->rchild);
    //销毁根结点
    DestroyNode(root);
    *root=NULL;

}
 //方法二：使用先序中序遍历，都要保存它的父节点，这里使用的是先序遍历
 //要能够保证我们找到左右子树
  TreeNode* TreeDestroy1(TreeNode** root)
{
    if(root==NULL)
    {
    return NULL;
    }
    if(*root==NULL)
    {
    return NULL;
    }
    TreeNode* lchild=(*root)->lchild;
    TreeNode* rchild=(*root)->rchild;
    DestroyNode(root);
    TreeDestroy(&lchild);
    TreeDestroy(&rchild);
}

//树的拷贝
//在这里我们需要回顾的是拷贝分为两种：
//①浅拷贝：两个对象同时指向的是同一块地址，(指针拷贝)数据之间会相互影响的
//内存不需要被修改
//②：深拷贝：就是将原有的对象的内存也将会复制一份（开销比较大，数据之间不会受到影响的)
//其实还有一种就是我们在操作系统的过程中学到的写时拷贝，它实际上是深浅拷贝两只进行结合的产物
TreeNode* TreeClone(TreeNode* root)
{
    if(root==NULL)
    {
    return NULL;
    }
    TreeNode* new_node=TreeNodeCreate(root->data);
    new_node->lchild=TreeClone(root->lchild);
    new_node->rchild=TreeClone(root->rchild);
    return new_node;
}


void _Treesize(TreeNode* root,size_t* size)
{
    if(root==NULL)
    {
    return ;
    }
    ++(*size);
    _Treesize(root->lchild,size);
    _Treesize(root->rchild,size);

}

//求二叉树中结点的个数
 size_t TreeSize1(TreeNode* root)
{
    if(root==NULL)
    {
    return 0;
    }
    size_t size=0;
    _Treesize(root,&size);
    return size;
}
//递归的实现
size_t TreeSize2(TreeNode* root)
{
    if(root==NULL)
    {
    return 0;
    }
    return (1+TreeSize2(root->lchild)+TreeSize2(root->rchild));
}

//求二叉树中叶子结点的个数
size_t TreeLeafSize(TreeNode* root)
 {
     if(root==NULL)
     {
     return 0;
     //空节点不是叶子结点
     }
     if(root->lchild==NULL && root->rchild==NULL)
     {
     //根结点也是叶子结点
     return 1;
     }
     return TreeLeafSize(root->lchild)+TreeLeafSize(root->rchild);
}


//求树的第K层结点的个数
//我们转换成的思路是求当前子树的K-1层结点的个数
size_t TreeLevelSize(TreeNode* root, size_t K)
{
    if(root==NULL || K <1)
    {
    return 0;
    }
    if(K==1)
    {
    return 1;
    }
    return TreeLevelSize(root->lchild,K-1)+TreeLevelSize(root->rchild,K-1);
}


//求树的高度
//我们可以看成是左右子树的最大高度加1
size_t TreeHight(TreeNode* root)
{
    if(root==NULL)
    {
    return 0;
    }
    if(root->lchild==NULL && root->rchild==NULL)
    {
    return 1;
    }
    size_t lhight=TreeHight(root->lchild);
    size_t rhight=TreeHight(root->rchild);
    return 1+(lhight>rhight?lhight:rhight);
    //在这里我们要注意优先级的问题
}

 // 在树中查找一个元素，并返回它的指针
TreeNode* TreeFind(TreeNode* root, TreeNodeType to_find)
{
    if(root==NULL)
    {
    return NULL;
    }
    if(root->data==to_find)
    {
    return root;
    }
    else if(root->data<to_find)
    {
    TreeNode* lvalue=TreeFind(root->lchild,to_find);
    }
    return TreeFind(root->rchild,to_find);

}

// 返回节点的左孩子节点
TreeNode* TreeLchild(TreeNode* root)
{
    if(root==NULL)
    {
    return NULL;
    }
    return root->lchild;
}

 // 返回节点的右孩子节点
TreeNode* TreeRchild(TreeNode* root)
{
    if(root==NULL)
    {
    return NULL;
    }
    return root->rchild;
}

 // 返回当前节点的父节点,求child对应的父节点是谁
 TreeNode* TreeParent(TreeNode* root, TreeNode* node)
{
    if(root==NULL || node==NULL)
    {
    return NULL;
    }
    if(root->lchild==node || root->rchild==node)
    {
    return root;
    }
    TreeNode* lvalue=TreeParent(root->lchild,node);
    TreeNode* rvalue=TreeParent(root->rchild,node);
    return lvalue!=NULL?lvalue:rvalue;
}


void SeqStackInit(SeqStack* stack){
    if(stack==NULL){
    return;
    }
    stack->size=0;
    stack->capacity=1000;
    stack->data=(StackType*)malloc(stack->capacity*sizeof(StackType));
}

void SeqStackResize(SeqStack* stack)//扩容
{
    if(stack==NULL){
    return;
    }
    if((stack->size)<(stack->capacity)){
    return;
    }
    stack->capacity=stack->capacity*2+1;
StackType* new=(StackType*)malloc(stack->capacity*sizeof(StackType));
       int i=0;
       for(i=0;i<stack->size;i++){
           new[i]=stack->data[i];
       }
       free(stack->data);
       stack->data=new;

}

void SeqStackPush(SeqStack* stack,StackType value)//入栈
{
    if(stack==NULL){
    return;
    }
    if((stack->size)>=(stack->capacity)){
    SeqStackResize(stack);
    }
    stack->data[stack->size++]=value;
}

void SeqStackPop(SeqStack* stack)//出栈
{ 
    if(stack==NULL){
    return;
    }
    if(stack->size==0){
    return ;
    }//空栈
    --stack->size;
}

int SeqStackTop(SeqStack* stack,StackType* value)//取栈顶元素
{

    if(stack==NULL){
          return 0;
     }
      if(stack->size==0){
      return 0;//空栈
      }
      *value=stack->data[stack->size-1];
      return  1;
}


//采用非递归实现先序我们的主要想法是先把根结点进行入栈，循环开始
//取栈顶元素a，进行访问(此处就是打印)，然后将a的右子树进行入栈
//在再将a的左子树进行入栈，返回到循环继续执行。
//
void PreOrderByLoop(TreeNode* root)
    //非递归完成先序遍历
{
    if(root==NULL)
    {
    return ;
    }
    SeqStack stack;
    SeqStackInit(&stack);
    //1、先把根结点进行入栈
    SeqStackPush(&stack,root);
    TreeNode* cur=NULL;
    //2、循环开始的时候栈为空，
    //a)取栈顶元素为当前的元素
    while(SeqStackTop(&stack,&cur))
    {
    //b)出栈
    SeqStackPop(&stack);
    //c)访问当前的元素(也就是打印当前的元素)
    printf("%c ",cur->data);
    //d)把当前元素的右子树进行入栈
    if(cur->rchild!=NULL)
    {
        SeqStackPush(&stack,cur->rchild);
    }
        //e)把当前元素的左子树进行入栈
    if(cur->lchild!=NULL)
    {
        SeqStackPush(&stack,cur->lchild);
    }
    }
}


void InOrderByLoop(TreeNode* root)//非递归完成中序遍历
{
    if(root==NULL)
    {
    return ;
    }
    SeqStack stack;
    SeqStackInit(&stack);
    //1、定义cur指针指向根结点，将cur入栈
    TreeNode* cur=root;
    //2、循环的判定cur的是否为空，如果不为空就将cur入栈，
    //并且cur指向cur->lchild
    while(1)
    {
    while(cur!=NULL)
    {
        SeqStackPush(&stack,cur);
        cur=cur->lchild;
    }
    //3、如果cur为空，取栈顶元素，访问出栈
    TreeNode* top=NULL;
        int ret=SeqStackTop(&stack,&top);
    if(ret==0)
    {
        //说明已经遍历结束了，取不到栈顶元素，说明已经取完了
        return;
    }
    printf("%c ",top->data);
    SeqStackPop(&stack);
    //4、让cur指向栈顶元素的右子树，重复刚才的循环判定空的过程
    cur=top->rchild;
    }
}

 //我们后序遍历也需要进行栈来维护，定义cur指向的是栈顶元素的右子树
 //后序遍历和中序遍历有一个重要的差别就是取到的栈顶元素不能立即被访问，
 //，需要满足的条件有两个：
 //1、当前的元素没有右子树
 //2、当前元素的右子树已经被访问过了（比较当前元素的右子树是否和上一个结点相同
 //
 void PostOrderByLoop(TreeNode* root)//非递归完成后序遍历
{
    if(root==NULL)
    {
    return ;
    }
    SeqStack stack;
    SeqStackInit(&stack);
//1、定义一个cur指向root的指针
   TreeNode* cur=root;
   TreeNode* pre=NULL;
   //2、循环的判定cur是否为空，要是cur不为空，我们
   //就将cur进行入栈，并且cur指向lchild
   while(1)
   {
       while(cur!=NULL)
       {
       SeqStackPush(&stack,cur);
       cur=cur->lchild;
       }
       //3、如果cur为空，循环的取栈顶元素
       TreeNode* top=NULL;
       int ret=SeqStackTop(&stack,&top);
       if(ret==0)
       {
       return;
       }

       //对栈顶元素进行判定，如果栈顶元素的右子树和访问的上一个元素
       //是同一个元素或者栈顶元素的右子树为空，此时才能访问栈顶元素
       //同时进行出栈
       if(top->rchild==NULL || top->rchild==pre)
       {
       printf("%c ",top->data);
       SeqStackPop(&stack);
       pre=top;
       }
       //如果不满足以上的条件，cur指向的是栈顶元素右子树
       //进行循环
       else
       {
       cur=top->rchild;
       }
   }
}


void swp(TreeNode** a,TreeNode** b)
{
    TreeNode* tmp=*a;
    *a=*b;
    *b=tmp;
}

 void TreeMirror(TreeNode* root)//二叉树的镜像(翻转)
{
    if(root==NULL)
    {
    return ;
    }
        swp(&root->lchild,&root->rchild);
    TreeMirror(root->lchild);
    TreeMirror(root->rchild);
}

 void TreeMirrorByLoop(TreeNode* root)
    //非递归完成二叉树的镜像,这里我们采用的是层序的方法
{
    if(root==NULL)
    {
    return;
    }
    SeqQ sq;
    SeqQInit(&sq);
    SeqQPush(&sq,root);
    TreeNode* cur=NULL;
    while(SeqQFront(&sq,&cur))
    {
    swp(&cur->lchild,&cur->rchild);
    SeqQPop(&sq);
    if(cur->lchild!=NULL)
    {
        SeqQPush(&sq,cur->lchild);
    }
    if(cur->rchild!=NULL)
    {
        SeqQPush(&sq,cur->rchild);
    }
    }
}
//判断一棵树是否是完全二叉树
//层序遍历，遍历分为两个阶段
//阶段一：任何一个节点同时具有左右子树，一旦发现某个节点不是同时具备
//        a）当前节点只有右子树，一定不是完全二叉树
//        b）如果当前节点只有左子树，进入阶段二
//        c）如果当前节点没有子树，也进入阶段二
//阶段二：任何一个节点都必须没有子树
//遍历结束后，若满足所有条件，说明这个树是完全二叉树，否则，就不是
int IsCompleteTree(TreeNode* root)//判断一棵树二叉树是否是完全二叉树
{
 if(root == NULL){
             return 0;
             }
     SeqQ q;
     SeqQInit(&q);
     SeqQPush(&q,root);
    // 设一个标志位表示是否进入阶段二
     int flag = 0;
     TreeNode* cur = NULL;
     while(SeqQFront(&q,&cur)){
     if(flag == 0){
         //阶段一的分支
     if(cur->lchild != NULL && cur->rchild != NULL){  
         //同时具有左右子树  
         SeqQPush(&q,cur->lchild);
         SeqQPush(&q,cur->rchild);
     }
     else if(cur->lchild == NULL && cur->rchild != NULL){
         //只有右子树没有左子树,一定不是完全二叉树
         return 0;
     }else if(cur->lchild != NULL && cur->rchild == NULL){
         //只有左子树没有右子树
         flag = 1;  
         SeqQPush(&q,cur->lchild);
     }else{
         //左右子树都没有
         flag = 1;
     }
     }
         //阶段二的分支   
         if(cur->lchild == NULL && cur->rchild == NULL){
         ;
         }else{
         return 0;
         }//end 阶段一和阶段二的判定
     }//循环结束
     return 1;
}

/////////////////////////////////////////////////////
////////////////test.c//////////////////////////////
////////////////////////////////////////////////////

#define  TEST_HEADER  printf("\n===========%s=============\n",__FUNCTION__);

void test1()
{
    TEST_HEADER;
    TreeNode* root;
    TreeInit(&root,'a');
    //创建节点
    TreeNode* b=TreeNodeCreate('b');
    TreeNode* c=TreeNodeCreate('c');
    TreeNode* d=TreeNodeCreate('d');
    TreeNode* e=TreeNodeCreate('e');
    TreeNode* f=TreeNodeCreate('f');
    TreeNode* g=TreeNodeCreate('g');
    //构建树
    root->lchild=b;
    root->rchild=c;


    b->lchild=d;
    b->rchild=e;
    e->lchild=g;
    c->rchild=f;
    printf("先序遍历树\n");
    PreOrder(root);
    printf("\n");
}

void test2()
{


    TEST_HEADER;
    TreeNode* root;
    TreeInit(&root,'a');
    //创建节点
    TreeNode* b=TreeNodeCreate('b');
    TreeNode* c=TreeNodeCreate('c');
    TreeNode* d=TreeNodeCreate('d');
    TreeNode* e=TreeNodeCreate('e');
    TreeNode* f=TreeNodeCreate('f');
    TreeNode* g=TreeNodeCreate('g');
    //构建树
    root->lchild=b;
    root->rchild=c;
    b->lchild=d;
    b->rchild=e;
    e->lchild=g;
    c->rchild=f;
    printf("中序遍历树\n");
    InOrder(root);
    printf("\n");
}

void test3()
{

    TEST_HEADER;
    TreeNode* root;
    TreeInit(&root,'a');
    //创建节点
    TreeNode* b=TreeNodeCreate('b');
    TreeNode* c=TreeNodeCreate('c');
    TreeNode* d=TreeNodeCreate('d');
    TreeNode* e=TreeNodeCreate('e');
    TreeNode* f=TreeNodeCreate('f');
    TreeNode* g=TreeNodeCreate('g');
    //构建树
    root->lchild=b;
    root->rchild=c;
    b->lchild=d;
    b->rchild=e;
    e->lchild=g;
    c->rchild=f;
    printf("后序遍历树\n");
    PostOrder(root);
    printf("\n");
}

void test4()
{

    TEST_HEADER;
    TreeNode* root;
    TreeInit(&root,'a');
    //创建节点
    TreeNode* b=TreeNodeCreate('b');
    TreeNode* c=TreeNodeCreate('c');
    TreeNode* d=TreeNodeCreate('d');
    TreeNode* e=TreeNodeCreate('e');
    TreeNode* f=TreeNodeCreate('f');
    TreeNode* g=TreeNodeCreate('g');
    //构建树
    root->lchild=b;
    root->rchild=c;
    b->lchild=d;
    b->rchild=e;
    e->lchild=g;
    c->rchild=f;
    printf("层序遍历树\n");
    LevelOrder(root);
    printf("\n");
}

void testtreecreate()
{

    TEST_HEADER;
   // TreeNode* root;
   // TreeInit(&root,'a');
    TreeNodeType array[]="abd##eg###c#f##";
    size_t size=strlen(array);
    size_t index=0;
    TreeNodeType null_node='#';
    TreeNode* tmp=TreeCreate( array, size,&index,null_node);
    PreOrder(tmp);
    printf("\n");

    InOrder(tmp);
    printf("\n");

    PostOrder(tmp);
    printf("\n");

    LevelOrder(tmp);
    printf("\n");
}


void testtreedestroy()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size1=strlen(arr);
    size_t index=0;
    TreeNodeType null_node='#';
    TreeNode* p=TreeCreate( arr, size1,&index,null_node);
    PreOrder(p);
    printf("\n");

    printf("销毁之后的结果为： \n");   
    TreeDestroy(&p);
    printf("\n");

    PreOrder(p);
    printf("\n");

}

void testclone()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    TreeNode* new_node= TreeClone(root);

    printf("对创建好的树进行先中后遍历：\n");
    PreOrder(new_node);
    printf("\n");

    InOrder(new_node);
    printf("\n");


    PostOrder(new_node);
    printf("\n");


}

void testtreesize()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);

    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    size_t tmp=TreeSize2(root);
    printf("%d\n",tmp);
}

void testleafsize()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    size_t tmp=TreeLeafSize(root);
    printf("%d\n",tmp);
}

void testlevelsize()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    size_t  m=4;
    size_t tmp=TreeLevelSize(root,4);
    printf("%d\n",tmp);
}

void testtreehight()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    size_t tmp=TreeHight(root);
    printf("%d\n",tmp);
}

void testfind()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    printf("查找元素‘c'是不是存在树中: \n");
    TreeNode* tmp=TreeFind(root,'c');
    printf("%c\n",tmp->data);
}

void testlchild()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    TreeNode* value=TreeLchild(root);
    printf("%c\n",value->data);
}

void testrchild()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    TreeNode* tmp=TreeRchild(root);
    printf("%c\n",tmp->data);
}

void testparent()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    TreeNode* ret= TreeParent(root, root->lchild->rchild);
    printf("%c\n",ret->data);
}

void testpreorderbyloop()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    printf("非递归的实现先序遍历: \n");
    PreOrderByLoop(root);
    printf("\n");
}


void testinorder()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    printf("非递归的实现中序遍历: \n");
    InOrderByLoop(root);
    printf("\n");
}

void testpostorderloop()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    printf("非递归的实现后序遍历: \n");
    PostOrderByLoop(root);
    printf("\n");
}

void testtreemirror1()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    printf("非递归的实现镜像: ");
    TreeMirror(root);
    printf("\n");
    printf("先序打印镜像后的树: ");
    PreOrder(root);
    printf("\n");
    printf("中序打印镜像后的树：");
    InOrder(root);
    printf("\n");
    printf("后序打印镜像后的树：");
    PostOrder(root);
    printf("\n");
    printf("层序打印镜像后的树：");
    LevelOrder(root);
    printf("\n");
}

void testtreemirror2()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);
    printf("非递归的实现镜像: ");
    TreeMirrorByLoop(root);
    printf("\n");
    printf("先序打印镜像后的树: ");
    PreOrder(root);
    printf("\n");
    printf("中序打印镜像后的树：");
    InOrder(root);
    printf("\n");
    printf("后序打印镜像后的树：");
    PostOrder(root);
    printf("\n");
    printf("层序打印镜像后的树：");
    LevelOrder(root);
    printf("\n");
}

void testiscomplete()
{

    TEST_HEADER;
    TreeNodeType arr[]="abd##eg###c#f##";
    size_t size=strlen(arr);
    size_t index=0;//当我们传入的是*index，就不能实现这种
    TreeNodeType null_node='#';
    TreeNode* root=TreeCreate( arr, size,&index,null_node);

    int value=IsCompleteTree(root);
    printf("IsCompleteTree expect is 0,actual is %d\n",value);
}


int main()
{
    test1();
    test2();
    test3();
    test4();
    testtreecreate();
    testtreedestroy();
    testclone();
    testtreesize();
    testleafsize();
    testlevelsize();
    testtreehight();
    testfind();
    testlchild();
    testrchild();
    testparent();
    testpreorderbyloop();
    testinorder();
    testpostorderloop();
    testtreemirror1();
    testtreemirror2();
    testiscomplete();
    return 0;
}