非递归版的搜索二叉树

#include"searchtree1.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)
{
*root = CreatSearchNode(to_sert);
return;
}
SearchTreeNode* cur = *root;
SearchTreeNode* pre = NULL;
while (1)
{
if (cur == NULL)
{
break;
}
if (to_sert < cur->data)
{
pre = cur;
cur = cur->lchild;


}
else if (to_sert>cur->data)
{
pre = cur;
cur = cur->rchild;
}
else
{
return;
}
}
SearchTreeNode* new_node = CreatSearchNode(to_sert);
if (new_node->data < pre->data)
{
pre->lchild = new_node;
}
else
{
pre->rchild = new_node;
}
return;
}


SearchTreeNode* SearchTreeFind(SearchTreeNode* root, SearchTreeType to_find)
{
if (root == NULL)
{
return;
}
SearchTreeNode* cur = root;
while (1)
{
if (cur == NULL)
{
break;
}
if (to_find < cur->data)
{
cur = cur->lchild;
}
else if (to_find>cur->data)
{
cur = cur->rchild;
}
else
{
break;
}
}
return cur;
}
void SearchTreeRemove(SearchTreeNode** root, SearchTreeType to_remove)
{
if (root == NULL)
{
return;
}
if (*root == NULL)
{
return;
}
SearchTreeNode* to_remove_node = *root;
SearchTreeNode* parent = NULL;
while (1){
if (to_remove < to_remove_node->data)
{
parent = to_remove_node;
to_remove_node = to_remove_node->lchild;
}
else if (to_remove >to_remove_node->data)
{
parent = to_remove_node;
to_remove_node = to_remove_node->rchild;
}
else
{
break;
}
if (to_remove_node->lchild == NULL&&to_remove_node->rchild == NULL)
{
if (to_remove_node == *root)
{
*root = NULL;
}


else {
if (to_remove_node->data < parent->data)
{
parent->lchild = NULL;
}
else
{
parent->rchild = NULL;
}
}
SearchDestroyNode(to_remove_node);
return;
}
else if (to_remove_node->lchild != NULL&&to_remove_node->rchild == NULL)
{
if (to_remove_node == *root)
{
*root = to_remove_node->lchild;
}
else {
if (to_remove_node->data < parent->data)
{
parent->lchild = to_remove_node->lchild;
}
else
{
parent->rchild = to_remove_node->rchild;
}
}
SearchDestroyNode(to_remove_node);
return;
}
else if (to_remove_node->lchild == NULL&&to_remove_node->rchild != NULL)
{
if (to_remove_node == *root)
{
*root = to_remove_node->rchild;
}
else {
if (to_remove_node->data < parent->data)
{
parent->lchild = to_remove_node->rchild;
}
else
{
parent->rchild = to_remove_node->rchild;
}
}
SearchDestroyNode(to_remove_node);
return;
}
else
{
SearchTreeNode* min = to_remove_node->lchild;
SearchTreeNode* min_parent = to_remove_node;
while (min->lchild != NULL)
{
min_parent = min;
min = min->lchild;
            }
to_remove_node->data = min->data;
if (min->data > min_parent->data)
{
min_parent->lchild = min->rchild;
}
SearchDestroyNode(to_remove_node);
return;
}
}

}

#pragma once 
#include<stdio.h>
#include<stdlib.h>
#include<string.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 to_remove);

#include"searchtree1.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 TestFind()
{
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, "插入八个元素");
SearchTreeNode* result = SearchTreeFind(root, 'd');
printf("result data expected d，actual %c\n", result->data);

}
TestRemovve()
{
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,'d');
SearchTreeRemove(&root,'g');
SearchTreeRemove(&root, 'c');
SearchTreeRemove(&root,'f'); 
SearchTreePrintfChar(root, "删除四个元素");
}
int main()
{
TestInit();
TestInsert();
TestFind();
TestRemovve();
return 0;
}