数据结构--二叉树

实现功能：
构建二叉树，能够插入、删除、查找结点
二叉树的前序、中序、后序、双序遍历
求二叉树深度
镜像二叉树

//
//  main.cpp
//  tree
//
//  Created by voidwalker on 2018/4/10.
//  Copyright © 2018年 voidwalker. All rights reserved.
//

//代码实现功能：
//构建二叉树，能够插入、删除、查找结点
//二叉树的前序、中序、后序、双序遍历
//求二叉树深度
//镜像二叉树

#include <iostream>
#include <cmath>
using namespace std;
#define OVERFLOW 2

typedef struct BTNode{
    char data;
    struct BTNode *lchild;
    struct BTNode *rchild;
}BTNode;

void insert(BTNode **root, int x){
    BTNode *tmp = NULL;
    if(!(*root)){
        tmp = (BTNode *)malloc(sizeof(BTNode));
        if(!tmp) exit(OVERFLOW);

        tmp->lchild = NULL;
        tmp->rchild = NULL;
        tmp->data = x;
        *root = tmp;
        return ;
    }

    if(x < (*root)->data){
        insert(&(*root)->lchild, x);
    }
    else if(x > (*root)->data){                 //当x已存在时不再添加结点
        insert(&(*root)->rchild, x);
    }

}

void destroy(BTNode *root){
    if(root){
        destroy(root->lchild);
        destroy(root->rchild);
        free(root);
        root = NULL;
    }
}

//查找二叉树中值为x的结点，并返回其指针
BTNode *find(BTNode *root, int x){
    BTNode *tmp = root;
    while(tmp != NULL && tmp->data != x){
        if(tmp->data < x){
            tmp = tmp->lchild;
        }
        else{
            tmp = tmp->rchild;
        }
    }
    return tmp;
}

//删除二叉树中值为x的结点
void deleteNode(BTNode **root, int x){
    BTNode *delet = *root;
    BTNode *parent = NULL;

    while(delet != NULL && delet->data != x){
        parent = delet;
        if(x < delet->data){
            delet = delet->lchild;
        }
        else{
            delet = delet->rchild;
        }
    }
    if(delet == NULL){
        cout<<"Not found"<<endl;
        return ;
    }
    if(!delet->lchild && !delet->rchild){       //要删除结点不存在子结点
        if(delet == *root){                     //要删除结点是根节点，将根节点删除置空
            free(delet);
            delet = NULL;
        }
        else{                                   //否则，将指向要删除结点的指针置空
            if(parent->lchild == delet){
                parent->lchild = NULL;
            }
            else{
                parent->rchild = NULL;
            }
            free(delet);
            delet = NULL;
        }
    }

    else if(!delet->lchild || !delet->rchild){  //要删除结点有一个子结点
        if(delet->lchild){                      //如果要删除结点存在左子树
            if(delet == *root){                 //如果要删除结点是根节点
                *root = delet->lchild;
            }
            else{
                if(parent->lchild == delet){    //如果删除节点是其父结点的左子树
                    parent->lchild = delet->lchild;
                }
                else{
                    parent->rchild = delet->lchild;
                }
            }
        }
        else{                                   //如果要删除结点存在右子树
            if(delet == *root){
                *root = delet->rchild;
            }
            else{
                if(parent->lchild == delet){
                    parent->lchild = delet->lchild;
                }
                else{
                    parent->rchild = delet->rchild;
                }
            }
        }
        free(delet);
        delet = NULL;
    }
    //删除结点左右子树都存在，则用左子树的最右结点替换删除结点
    else{                                        //要删除结点存在2个子结点
        parent = delet;
        BTNode *tmp = parent->lchild;            //找要删除结点的左子树的最右结点
        while(tmp->rchild){
            parent = tmp;
            tmp = tmp->rchild;
        }
        delet->data = tmp->data;

        if(parent->lchild == tmp){
            parent->lchild = tmp->lchild;
        }
        else{
            parent->rchild = tmp->rchild;
        }
        free(tmp);
        tmp = NULL;
    }
}

void visit(int x){
    cout<<x<<" ";
}

void PreOrderTraverse(BTNode *root){
    if(!root) return ;
    visit(root->data);
    PreOrderTraverse(root->lchild);
    PreOrderTraverse(root->rchild);
}

void InOrderTraverse(BTNode *root){
    if(!root) return ;
    InOrderTraverse(root->lchild);
    visit(root->data);
    InOrderTraverse(root->rchild);
}

void PostOrderTraverse(BTNode *root){
    if(!root) return ;
    PostOrderTraverse(root->lchild);
    PostOrderTraverse(root->rchild);
    visit(root->data);
}

//双序遍历：先访问该结点，再按双序遍历其左子树，再次访问该结点，最后按双序遍历访问其右子树
void DoubleOrderTraverse(BTNode *root){
    if(!root) return ;
    visit(root->data);
    DoubleOrderTraverse(root->lchild);
    visit(root->data);
    DoubleOrderTraverse(root->rchild);
}

//获得二叉树的深度
int getdepth(BTNode *root){
    if(!root) return 0;
    return 1 + max(getdepth(root->lchild), getdepth(root->rchild));
}

//镜像二叉树
void mirrorBTree(BTNode **root){
    if(!(*root)) return ;
    BTNode *tmp = (*root)->lchild;
    (*root)->lchild = (*root)->rchild;
    (*root)->rchild = tmp;
    mirrorBTree(&(*root)->lchild);
    mirrorBTree(&(*root)->rchild);
}

int main(int argc, const char * argv[]) {

    BTNode *root = NULL;
    insert(&root, 6);
    insert(&root, 7);
    insert(&root, 3);
    insert(&root, 8);
    insert(&root, 1);
    insert(&root, 5);
    insert(&root, 9);
    insert(&root, 4);

    cout<<"PreOrderTraverse: ";
    PreOrderTraverse(root);
    cout<<endl;

    cout<<"InOrderTraverse: ";
    InOrderTraverse(root);
    cout<<endl;

    cout<<"PostOrderTraverse: ";
    PostOrderTraverse(root);
    cout<<endl;

    cout<<"DoubleOrderTraverse: ";
    DoubleOrderTraverse(root);
    cout<<endl;

    cout<<"Depth of BTree: "<<getdepth(root)<<endl;

    cout<<"After mirror, PreOrderTraverse: ";
    mirrorBTree(&root);
    PreOrderTraverse(root);
    cout<<endl;

    deleteNode(&root, 5);
    cout<<"After delete,PreOrderTraverse: ";
    PreOrderTraverse(root);
    cout<<endl;

    destroy(root);

    return 0;
}