二叉树的基本操作<2>

////根据先序遍历结果构造一棵树--“abd###c##”
TreeNode* CreatTree(TreeNodeType cur[],size_t *index,size_t size,TreeNodeType null_value){
if(*index == size){
exit(0);
}
if(cur[*index] == null_value){
return NULL;
}
TreeNode* new = CreatTreeNode(cur[*index]);
++(*index);
new->lchild = CreatTree(cur,index,size,'#');
++(*index);
new->rchild = CreatTree(cur,index,size,'#');
return new;
}
//根据先序遍历结果构造一棵树的检测函数
void textCreatTree(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNodeType cur[] = "abd###c##";
printf("cur = %s\n",cur);
size_t size =sizeof(cur)/sizeof(cur[0])-1;
size_t index = 0;
TreeNode* ret = CreatTree(cur,&index,size,'#');
printf("\n************PreOrder********************\n");
PreOrder(ret);
printf("\n************INOrder********************\n");
InOrder(ret);
printf("\n************PostOrder********************\n");
PostOrder(ret);
printf("\n************LevelOrder********************\n");
levelOrder(ret);
printf("\n");
return;
}
void Destroy(TreeNode* root){
free(root);
root =NULL;
return;
}
//销毁树
//通过后续遍历，将访问操作改为删除结点的操作
void TreeDestroy(TreeNode** root){
if(root == NULL){
return;
}
TreeDestroy(&((*root)->lchild));
TreeDestroy(&((*root)->rchild));
if((*root)->lchild==NULL&&(*root)->rchild==NULL){
Destroy(*root);
}
}


void textTreeDestroy(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
TreeDestroy(&A);
if(A==NULL){
printf("销毁成功！\n");
}else{
printf("销毁失败！\n");
}
printf("\n");
return;
}
//树的拷贝
//通过遍历将树进行拷贝
TreeNode* TreeClone(TreeNode* root){
if(root == NULL){
return NULL;
}
TreeNode* new = CreatTreeNode(root->data);
new->lchild = TreeClone(root->lchild);
new->rchild = TreeClone(root->rchild);
return new;
}
void textTreeClone(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
TreeNode* ret = TreeClone(A);
printf("except:a b c d\n");
printf("actual:");
PreOrder(ret);
printf("\n");
}


//求一棵树的叶子结点个数
//先序遍历输出二叉树中叶子结点
size_t TreeLeafSize(TreeNode* root){
int leafcount;
if(root==NULL){
return 0;
}else if((root->lchild==NULL)&&(root->rchild==NULL)){
leafcount = 1;
}else{
leafcount=TreeLeafSize(root->lchild)+TreeLeafSize(root->rchild);
}
return leafcount;
}


void textTreeLeafSize(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
size_t ret = TreeLeafSize(A);
printf("except:2   ,actual:%d\n",ret);
printf("\n");
}
//求一棵树的结点个数
size_t TreeSize(TreeNode* root){
int count;
if(root == NULL){
return 0;
}
return 1+TreeSize(root->lchild)+TreeSize(root->rchild);
}
void textTreeSize(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
size_t ret = TreeSize(A);
printf("except:4   ,actual:%d\n",ret);
return;
}
//求一棵树第K层结点的个数
size_t TreeLevelSize(TreeNode* root,int k){
if(k<1){
printf("非法输入！\n");
exit(1);
}
if(root == NULL){
return;
}
if(k==1){
return 1;
}
return TreeLevelSize(root->lchild,k-1)+TreeLevelSize(root->rchild,k-1);
}
void textTreeLevelSize(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
size_t ret = TreeLevelSize(A,3);
printf("except:1   ,actual:%d\n",ret);
}
//在树中查找元素，这个元素有可能不在这棵树内
TreeNode* TreeFind(TreeNode* root,TreeNodeType to_find){
if(root == NULL){
return NULL;
}
TreeNode* ret= NULL;
if(root->data == to_find){
ret = root;
}
ret = TreeFind(root->lchild,to_find);
if(ret){
return ret;
}
ret = TreeFind(root->rchild,to_find);
if(ret){
return ret;
}
return ret;
}
void textTreeFind(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
TreeNode* ret = TreeFind(A,'f');
if(ret==NULL){
printf("未找到！\n");
return;
}
printf("except:d,   actual:%c\n",ret->data);


}
//求树的高度
size_t TreeHeigh(TreeNode* root){
int hl,hr,max;
if(root!=NULL){
hl = TreeHeigh(root->lchild);
hr = TreeHeigh(root->rchild);
max = hl>hr?hl:hr;
return (max+1);
}else{
return 0;
}
}
void textTreeHeigh(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
size_t ret= TreeHeigh(A);
printf("except:3   actual:%d\n",ret);


}
//求结点的左子树，首先判断该结点是否为空，如果位空，
//返回NULL，反之返回该结点的左子树
TreeNode* LChild(TreeNode* node){
if(node == NULL){
return NULL;
}
return node->lchild;
}
//求结点的右子树
//首先判断该结点是否为空结点，如果是空结点，
//返回NULL，反之返回该结点的右子树
TreeNode* RChild(TreeNode* node){
if(node ==NULL){
return NULL;
}
return node->rchild;
}
void textR_Lchild(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
TreeNode* ret1 = LChild(B);
if(ret1){
printf("左子树：except :d    ,actual:%c\n",ret1->data);
}else{
printf("未找到！\n");
}
TreeNode* ret2 = RChild(A);
if(ret2){
printf("右子树：except:c     ,actual:%c\n",ret2->data);
}else{
printf("未找到！\n");
}
return;
}
//求结点的父结点
TreeNode* parent(TreeNode* root,TreeNode* node){
if(root==NULL){
return NULL;
}
if(root->lchild==node){
return root;
}
if(root->lchild == node){
return root;
}
parent(root->lchild,node);
parent(root->rchild,node);
return NULL;
}
void textParent(){
printf("\n*************%s********************\n",__FUNCTION__);
TreeNode* A = CreatTreeNode('a');
TreeNode* B = CreatTreeNode('b');
TreeNode* C = CreatTreeNode('c');
TreeNode* D = CreatTreeNode('d');
A->lchild = B;
A->rchild = C;
B->lchild = D;
TreeNode* ret = parent(A,B);
if(ret){
printf("except: a   ,actual:%c\n",ret->data);
}else{
printf("未找到！\n");
}
}