搜索二叉树的递归实现

#pragma once 
#include<stdio.h>
#include<stdlib.h>
typedef char SearchTreeType;


typedef struct SearchTreeNode {
SearchTreeType data ; 
struct SearchTreeNode* lchild;
struct SearchTreeNode* rchild;
} SearchTreeNode;


void SearchTreeInit(SearchTreeNode** root);


void SearchTreeInsert(SearchTreeNode** root, SearchTreeType data);
void PreOrder(SearchTreeNode* root);
void InOrder(SearchTreeNode* root);
void PostOrder(SearchTreeNode* root);


SearchTreeNode* SearchTreeFind(SearchTreeNode* root,SearchTreeType to_find);

void SearchTreeRemove(SearchTreeNode** root, SearchTreeType data);

#include "seachtree.h"
void SearchTreeInit(SearchTreeNode** pRoot)
{
if (pRoot == NULL)
{
return;
}
*pRoot = NULL;
return;
}
SearchTreeNode* CreatSearchNode(SearchTreeType value)
{
SearchTreeNode* new_node = (SearchTreeNode*)malloc(sizeof(SearchTreeNode));
new_node->data = value;
new_node->lchild = NULL;
new_node->rchild = NULL;
return new_node;
}
SearchDestroyNode(SearchTreeNode* node)
{
free(node);
}
SearchDestroyTreeNode(SearchTreeNode** pRoot)
{
if (pRoot == NULL)
{
return;
}
if (*pRoot == NULL)
{
return;
}
SearchTreeNode* root = *pRoot;
SearchDestroyTreeNode(root->lchild);
SearchDestroyTreeNode(root->rchild);
SearchDestroyNode(root);
*pRoot = NULL;
return;
}
void PreOrder(SearchTreeNode* root)
{
if (root == NULL)
{
return;
}
printf("%c",root->data);
PreOrder(root->lchild);
PreOrder(root->rchild);
}
void InOrder(SearchTreeNode* root)
{
if (root == NULL)
{
return;
}
InOrder(root->lchild);
printf("%c",root->data);
InOrder(root->rchild);
}
void PostOrder(SearchTreeNode* root)
{
if (root == NULL)
{
return;
}
PostOrder(root->lchild);
PostOrder(root->rchild);
printf("%c",root->data);
}
void SearchTreeInsert(SearchTreeNode** root, SearchTreeType to_sert)
{
if (root == NULL){
return;
}
if (*root == NULL)
{
SearchTreeNode* new_node = CreatSearchNode(to_sert);
*root = new_node;
return;
}
SearchTreeNode* cur = *root;
if (to_sert< cur->data)
{
SearchTreeInsert(&cur->lchild,to_sert );
}
else if (to_sert>cur->data)
{
SearchTreeInsert(&cur->rchild, to_sert);
}
else
{
return;
     }
     }
SearchTreeNode* SearchTreeFind(SearchTreeNode* root, SearchTreeType to_find)
{
if (root == NULL)
{
return;
}
if (to_find < root->data)
{
return SearchTreeFind(root->lchild, to_find);
}
else if (to_find>root->data)
{
return SearchTreeFind(root->rchild, to_find);
}
else {
return root;
}
}
void SearchTreeRemove(SearchTreeNode** root, SearchTreeType to_remove)
{
if (root == NULL)
{
return;
}
if (*root == NULL)
{
return;
}
SearchTreeNode* proot = *root;
if (to_remove < proot->data)
{
SearchTreeRemove(&proot->lchild, to_remove);
return;
}
else if (to_remove> proot->data)
{
SearchTreeRemove(&proot->rchild, to_remove);
return;
}
else
{
SearchTreeNode* to_remove_node = *root;
if (proot->lchild == NULL&&proot->rchild == NULL)
{
*root = NULL;
SearchDestroyNode(to_remove_node);
return;
}
else if (proot->lchild != NULL&&proot->rchild == NULL)
{
*root = to_remove_node->lchild;
SearchDestroyNode(to_remove_node);
return;


}
else if (proot->lchild == NULL&&proot->rchild != NULL)
{
*root = to_remove_node->rchild;
SearchDestroyNode(to_remove_node);
return;


}
else {
SearchTreeNode* min = to_remove_node->lchild;
while (min->lchild != NULL)
{
min = min->lchild;
}
to_remove_node->data = min->data;
SearchTreeRemove(&to_remove_node->rchild, min->data);
return;
}
}
return;

}

#include"seachtree.h"
void TestInit(){
SearchTreeNode* root;
SearchTreeInit(&root);
printf("root expected NULL，actual %p\n", root);
}
SearchTreePrintfChar(SearchTreeNode* root, const char* msg)
{
printf("\n[%s]\n", msg);
printf("先序遍历：");
PreOrder(root);
printf("\n");
printf("中序遍历：");
InOrder(root);
printf("\n"); 
printf("后序遍历：");
PostOrder(root);
printf("\n");
}


void TestInsert()
{
SearchTreeNode* root;
SearchTreeInit(&root);
SearchTreeInsert(&root, 'a');
SearchTreeInsert(&root, 'b');
SearchTreeInsert(&root, 'c');
SearchTreeInsert(&root, 'd');
SearchTreeInsert(&root, 'e');
SearchTreeInsert(&root, 'f');
SearchTreeInsert(&root, 'g');
SearchTreeInsert(&root, 'h');
    SearchTreePrintfChar(root, "插入八个元素");
}
void TestRemove()
{
SearchTreeNode* root;
SearchTreeInit(&root);
SearchTreeInsert(&root, 'a');
SearchTreeInsert(&root, 'b');
SearchTreeInsert(&root, 'c');
SearchTreeInsert(&root, 'd');
SearchTreeInsert(&root, 'e');
SearchTreeInsert(&root, 'f');
SearchTreeInsert(&root, 'g');
SearchTreeInsert(&root, 'h');
SearchTreePrintfChar(root, "插入八个元素");
SearchTreeRemove(&root,'g');
SearchTreePrintfChar(root, "删除一个元素");
}
void TestFind()
{
SearchTreeNode* root;
SearchTreeInit(&root);
SearchTreeInsert(&root, 'a');
SearchTreeInsert(&root, 'b');
SearchTreeInsert(&root, 'c');
SearchTreeInsert(&root, 'd');
SearchTreeInsert(&root, 'e');
SearchTreeInsert(&root, 'f');
SearchTreeNode* result = SearchTreeFind(root, 'd');
printf("result data expected d，actual %c\n", result->data);
}
int main()
{
TestInit();
TestInsert();
TestFind();
TestRemove();
return 0;
}