搜索二叉树，插入，搜索，找最值，找父节点

#include <iostream>

using namespace std;

typedef  struct _TreeNode
{
    int data;
    struct _TreeNode* left;
    struct _TreeNode* right;
}TreeNode;


int getTreeHeightByPostOrder(TreeNode* r)
{
    int lH,rH,maxH;
    if(r)
    {
        lH = getTreeHeightByPostOrder(r->left);
        rH = getTreeHeightByPostOrder(r->right);
        maxH = lH>rH?lH:rH;
        return  maxH+1;
    }
    return  0;
}



//搜索二叉树：满足中序遍历则有序的树

//TreeNode* root = NULL; //空树

TreeNode* initBst1()
{
    return  NULL;
}

void initBst(TreeNode** r)
{
    *r = NULL;
}

void insertBst(TreeNode** r,int data)//binary search tree
{
    TreeNode* t = (*r);
    if(*r == NULL)
    {
        *r = (TreeNode*)malloc(sizeof(TreeNode));
        (*r)->data = data;
        (*r)->left = (*r)->right = NULL;
    }
    else
    {
        while (1)
        {
            if(data>t->data)
            {
                if(t->right == NULL)
                {
                    t->right = (TreeNode*)malloc(sizeof(TreeNode));
                    t->right->data = data;
                    t->right->left = t->right->right = NULL;
                    break;
                }
                t = t->right;
             }

            else
            {
                if(t->left==NULL)
                {
                    t->left = (TreeNode*)malloc(sizeof(TreeNode));
                    t->left->data = data;
                    t->left->left = t->left->right = NULL;
                    break;
                }
                t = t->left;
            }
        }
    }
}

void insertBstR(TreeNode** r,int data)//binary search tree recursive
{
    if(*r == NULL)
    {
        *r = (TreeNode*)malloc(sizeof(TreeNode));
        (*r)->data = data;
        (*r)->left = (*r)->right= NULL;
    }
    else
    {
        if(data> (*r)->data)
            insertBstR(&(*r)->right,data);
        else
            insertBstR(&(*r)->left,data);
    }
}

TreeNode* searchBst(TreeNode* r,int find)
{
    while (r)
    {
        if(r->data == find)
            return  r;
        else if(find>r->data)
            r = r->right;
        else
        {
            r = r->left;
        }
    }
    return NULL;
}
TreeNode* searchBstR(TreeNode* r,int find)
{
    if(r)
    {
        if(r->data == find)
            return  r;
        else if(find > r->data)
            return searchBstR(r->right,find);
        else
            return searchBstR(r->left,find);

    }
    return  NULL;

}
TreeNode* getMinNodeBst(TreeNode* r)
{
    if(r)
    {
        while (r->left)
        {
            r = r->left;
        }
        return r;
    }

    return NULL;
}
void midOrderTraverse(TreeNode* r)
{
    if(r)
    {
        midOrderTraverse(r->left);
        printf("%d ",r->data);
        midOrderTraverse(r->right);
    }
}

TreeNode* getParentBst(TreeNode* r,TreeNode* child)
{
    static TreeNode* parent = NULL;
    if(r)
    {
        if(r->left == child||r->right == child)
            parent = r;
        getParentBst(r->left,child);
        getParentBst(r->right,child);
    }
    return parent;
}
int main()
{
    TreeNode* root = NULL;
    insertBstR(&root,30);
    insertBstR(&root,8);
    insertBstR(&root,15);
    insertBstR(&root,36);
    insertBstR(&root,100);
    insertBstR(&root,32);

    midOrderTraverse(root);

    TreeNode* pfind = searchBstR(root,8);
    if(pfind)
        printf("\nfind %d\n",pfind->data);
    else {
        printf("\nfind none\n");
    }

    TreeNode* mi  = getMinNodeBst(root);
    if(mi)
        printf("\n min = %d\n",mi->data);


    TreeNode* parent = getParentBst(root,pfind);
    printf("father nod %d\n",parent->data);
    return 0;
}