c语言递归非递归实现二叉搜索树

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。中序遍历二叉排序树可得到一个关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即为对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。搜索,插入,删除的复杂度等于树高，O(log(n)).

#include<stdio.h>   
#include<stdlib.h>  
#include<windows.h>
#include<assert.h>  
#include<windef.h>
#define bool int
#define false 0
#define true 1
#pragma once 

typedef int DataType;

typedef struct BSTreeNode
{
    struct BSTreeNode* _left;
    struct BSTreeNode* _right;

    DataType _data;
}BSTreeNode;

/////////////////////////////////////////////////////// 
// 非递归 
BSTreeNode* BuyBSTreeNode(DataType x);
int BSTreeInsert(BSTreeNode** tree, DataType x);
const BSTreeNode* BSTreeFind(BSTreeNode* tree, DataType x);
int BSTreeRemove(BSTreeNode** tree, DataType x);
void BSTreeDestory(BSTreeNode* tree);
BSTreeNode* BuyBSTreeNode(DataType x)//创建二叉树
{
    BSTreeNode*newnode = (BSTreeNode*)malloc(sizeof(BSTreeNode));
    assert(newnode);
    newnode->_left = NULL;
    newnode->_right = NULL;
    newnode->_data = x;
    return newnode;
}

int REBSTreeInsert(BSTreeNode** tree, DataType x)//递归插入
{
    if (*tree == NULL)
    {
        *tree = BuyBSTreeNode(x);
        return;
    }
    if ((*tree)->_data < x)
    {
        REBSTreeInsert((*tree)->_right, x);
    }
    if ((*tree)->_data > x)
    {
        REBSTreeInsert((*tree)->_left, x);
        return;
    }

}
const BSTreeNode* REBSTreeFind(BSTreeNode* tree, DataType x)//递归查找
{
    if (tree == NULL)
    {
        return -1;
    }
    if (tree->_data > x)
    {
        return BSTreeFind(tree->_left, x);
    }
    else if (tree->_data<x)
    {
        return BSTreeFind(tree->_right, x);
    }
    else
    {
        printf("找到了=%d\n",tree->_data);
        return true;
    }

}
int REBSTreeRemove(BSTreeNode **tree, DataType x)//递归删除一个数
{   
    if (tree == NULL)
    {
        return -1;
    }
    else if ((*tree)->_data > x)
    {
        return BSTreeRemove((*tree)->_left, x);
    }
    else if ((*tree)->_data < x)
    {
        return BSTreeRemove((*tree)->_right, x);
    }
    else
    {
        BSTreeNode *tmp = *tree;
        BSTreeNode *parent = tmp;
        BSTreeNode *cur = tmp->_right;
        if (tmp->_left == NULL)
        {
            tmp = tmp->_right;
        }
        else if (tmp->_right == NULL)
        {
            tmp = tmp->_left;
        }
        else
        {

            while (cur->_left)
            {
                parent = cur;
                cur = cur->_left;
            }
            tmp = cur;
            tmp->_data = cur->_data;
            if (parent->_left == cur)
            {
                parent->_left = cur->_right;
            }
            else
            {
                parent->_right = cur->_right;
            }
        }
        free(cur);
        cur = NULL;
    }
    return true;
}
int BSTreeInsert(BSTreeNode** tree, DataType x)//非递归插入
{
    if (*tree == NULL)
        {
            *tree = BuyBSTreeNode(x);
            printf("%d",(*tree)->_data);
            return true;
        }
    BSTreeNode *cur = *tree;
    BSTreeNode *parent = NULL;
     if ((*tree)->_data == x)
        {
         printf("已存在该数");
            return tree;
        }
     else
     {
         while (cur)
         {
             if (cur->_data > x)
             {
                 parent = cur;
                 cur = cur->_left;
             }
             else if (cur->_data < x)
             {
                 parent = cur;
                 cur = cur->_right;
             }
             else
             {
                 printf("已存在该数");
                 return *tree;
             }
         }
         if (parent->_data > x)
         {
             parent->_left = BuyBSTreeNode(x);
             printf("%d", parent->_left->_data);
             return true;
         }
         if (parent->_data <x)
         {
             parent->_right = BuyBSTreeNode(x);
             printf("%d", parent->_right->_data);
             return true;
         }
             }


}
const BSTreeNode* BSTreeFind(BSTreeNode* tree, DataType x)//非递归查找
{
    BSTreeNode *cur = tree;
    if (tree->_data == x)
    {
        return true;
    }
    while (cur)
    {
        if (cur->_data>x)
        {
            cur = cur->_left;
        }
        else if (cur->_data < x)
        {
            cur = cur->_right;
        }
        else
        {
            printf("找到了");
            return true;
        }
    }
    if (cur == NULL)
    {
        return false;
    }
}
int BSTreeRemove(BSTreeNode **tree, DataType x)//非递归删除一个数
{
    if (tree == NULL)
    {
        return -1;
    }
    BSTreeNode *tmp = *tree;
    while (tmp->_data!=x)
    {
        if (tmp->_left > x)
        {
            tmp = tmp->_left;
        }
        if (tmp->_right < x)
        {
            tmp = tmp->_right;
        }
    }
    BSTreeNode *cur = tmp->_right;
    BSTreeNode *parent = cur;
    while (cur)
    {
        parent = cur;
        cur = cur->_left;
    }
    tmp->_data = cur->_data;
        free(cur);
    cur=NULL;
    return true;
}
void TestBSTree() 
{ 
 BSTreeNode* tree = NULL; 
 BSTreeInsert(&tree, 4); 
 BSTreeInsert(&tree, 2); 
 BSTreeInsert(&tree, 1); 
 BSTreeInsert(&tree, 3); 
 BSTreeInsert(&tree, 2); 

 const BSTreeNode* node = REBSTreeFind(tree, 2);  
}

int main()
{
    TestBSTree();
    system("pause");
    return 0;
}