# 二叉搜索树--递归和循环实现

search_tree.h


//实现二叉搜索树的递归和非递归版本

#pragma once

#include<stddef.h>

typedef char SearchTreeType;

typedef struct SearchTreeNode {

SearchTreeType key; // 关键码

struct SearchTreeNode* lchild;

struct SearchTreeNode* rchild;

} SearchTreeNode;

void SearchTreeInit(SearchTreeNode** Root);

void SearchTreeInsert(SearchTreeNode** Root, SearchTreeType Key);

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

void SearchTreeRemove(SearchTreeNode** Root, SearchTreeType Key);

void SearchTreeInsertByLoop(SearchTreeNode** Root,SearchTreeType Key);

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

void SearchTreeRemoveByLoop(SearchTreeNode** Root,SearchTreeType Key);


search_tree.c

//实现二叉搜索树的递归和非递归版本

//typedef char SearchTreeType;

//

//typedef struct SearchTreeNode {

//SearchTreeType key; // 关键码

//struct SearchTreeNode* lchild;

//struct SearchTreeNode* rchild;

//} SearchTreeNode;

#include<stdio.h>

#include<stdlib.h>

#include"search_tree.h"

void SearchTreeInit(SearchTreeNode** Root)

{

if(Root==NULL)

{

return;

}

*Root=NULL;

}

SearchTreeNode* CreatSearchNode(SearchTreeType Key)

{

SearchTreeNode* tmp=(SearchTreeNode*)malloc(sizeof(SearchTreeNode));

tmp->key=Key;

tmp->lchild=NULL;

tmp->rchild=NULL;

return tmp;

}

void SearchTreeInsert(SearchTreeNode** Root, SearchTreeType Key)

{

if(Root==NULL)

{

return;

}

if(*Root==NULL)

{

*Root=CreatSearchNode(Key);

return;

}

SearchTreeNode* root=*Root;

if(root->key > Key)

{

SearchTreeInsert(&root->lchild,Key);

}

else if(root->key < Key)

{

SearchTreeInsert(&root->rchild,Key);

}

else

{

return;

}

}

SearchTreeNode* SearchTreeFind(SearchTreeNode* root, SearchTreeType to_find)

{

if(root==NULL)

{

return NULL;

}

if(root->key > to_find)

{

return SearchTreeFind(root->lchild,to_find);

}

else if(root->key < to_find)

{

return  SearchTreeFind(root->rchild,to_find);

}

else

{

return root;

}

}

void SearchTreeRemove(SearchTreeNode** Root, SearchTreeType Key)

{

if(Root==NULL)

{

return;

}

if(*Root==NULL)

{

return;

}

if((*Root)->key > Key)

{

SearchTreeRemove(&(*Root)->lchild,Key);

}

else if((*Root)->key < Key)

{

SearchTreeRemove(&(*Root)->rchild,Key);

}else

{

SearchTreeNode* root=*Root;

SearchTreeNode* to_delete=NULL;

if(root->lchild==NULL && root->rchild==NULL)

{

free(*Root);

*Root=NULL;

}

else if(root->lchild!=NULL && root->rchild==NULL)

{

*Root=root->lchild;

free(root);

}

else if(root->lchild==NULL && root->rchild!=NULL)

{

*Root=root->rchild;

free(root);

}

else

{

//choose lchild rightmost value

root=root->lchild;

while(root->rchild!=NULL)

{

root=root->rchild;

}

(*Root)->key=root->key;

SearchTreeRemove(&(*Root)->lchild,root->key);

}

}

}

void PreOder(SearchTreeNode* root)

{

if(root==NULL)

{

return;

}

printf("%c",root->key);

PreOder(root->lchild);

PreOder(root->rchild);

}

void InOder(SearchTreeNode* root)

{

if(root==NULL)

{

return;

}

InOder(root->lchild);

printf("%c",root->key);

InOder(root->rchild);

}

void Test()

{

SearchTreeNode* searchtree;

SearchTreeInit(&searchtree);

SearchTreeInsert(&searchtree,'b');

SearchTreeInsert(&searchtree,'e');

SearchTreeInsert(&searchtree,'c');

SearchTreeInsert(&searchtree,'a');

SearchTreeInsert(&searchtree,'f');

SearchTreeInsert(&searchtree,'d');

printf("==After insert==\n");

printf("preoder\n");

PreOder(searchtree);

printf("\n");

printf("inoder\n");

InOder(searchtree);

printf("\n");

SearchTreeNode*find= SearchTreeFind(searchtree,'e');

printf("The find result is %c \n",find->key);

find= SearchTreeFind(searchtree,'g');

printf("The find is %p \n",find);

printf("%c \n",searchtree->key);

SearchTreeRemove(&searchtree,'b');

SearchTreeRemove(&searchtree,'e');

SearchTreeRemove(&searchtree,'d');

printf("==After remove==\n");

printf("preoder\n");

PreOder(searchtree);

printf("\n");

printf("inoder\n");

InOder(searchtree);

printf("\n");

}

void SearchTreeInsertByLoop(SearchTreeNode** Root,SearchTreeType Key)

{

if(Root==NULL)

{

return;

}

if(*Root==NULL)

{

*Root=CreatSearchNode(Key);

return;

}

SearchTreeNode* root= *Root;

SearchTreeNode* pre=NULL;

while(1)

{

if(root==NULL)

{

if(pre->key > Key)

{

pre->lchild=CreatSearchNode(Key);

}

else

{

pre->rchild=CreatSearchNode(Key);

}

return;

}

if(root->key > Key)

{

pre=root;

root=root->lchild;

}

else if(root->key < Key)

{

pre=root;

root=root->rchild;

}

else

{

return;

}

}

}

SearchTreeNode* SearchTreeFindByLoop(SearchTreeNode* root,SearchTreeType to_find)

{

if(root==NULL)

{

return NULL;

}

while(1)

{

if(root==NULL)

{

return NULL;

}

if(root->key > to_find)

{

root=root->lchild;

}

else if(root->key < to_find)

{

root=root->rchild;

}

else

{

return root;

}

}

}

void DestoryNode(SearchTreeNode* to_destory)

{

free(to_destory);

return;

}

void SearchTreeRemoveByLoop(SearchTreeNode** Root,SearchTreeType Key)

{

if(Root==NULL)

{

return;

}

if(*Root==NULL)

{

return;

}

SearchTreeNode* pre=NULL;

SearchTreeNode* root=*Root;

while(1)

{

if(root==NULL)

{

return;

}

if(root->key > Key)

{

pre=root;

root=root->lchild;

}

else if(root->key < Key)

{

pre=root;

root=root->rchild;

}

else

{

SearchTreeNode* to_delete=root;

if(root->lchild==NULL && root->rchild==NULL)

{

if(pre==NULL)

{

*Root=NULL;

DestoryNode(to_delete);

return;

}

if(pre->key > Key)

{

pre->lchild=NULL;

}

else

{

pre->rchild=NULL;

}

}

else if(root->lchild!=NULL && root->rchild==NULL)

{

if(pre==NULL)

{

*Root=root->lchild;

DestoryNode(to_delete);

return;

}

if(pre->key > Key)

{

pre->lchild=root->lchild;

}

else

{

pre->rchild=root->lchild;

}

}

else if(root->lchild==NULL && root->rchild!=NULL)

{

if(pre==NULL)

{

*Root=root->rchild;

DestoryNode(to_delete);

return;

}

if(pre->key > Key)

{

pre->lchild=root->rchild;

}

else

{

pre->rchild=root->rchild;

}

}

else

{

// left tree rightmost to change.

pre=root;

root=root->lchild;

while(root->rchild!=NULL)

{

pre=root;

root=root->rchild;

}

to_delete->key=root->key;

to_delete=root;

if(root->lchild==NULL)

{

pre->rchild=NULL;

}

else

{

pre->rchild=root->lchild;

}

}

DestoryNode(to_delete);

return;

}

}

}

void PrintChar(const char* str,SearchTreeNode* root)

{

printf("%s \n",str);

PreOder(root);

printf("\n");

InOder(root);

printf("\n");

}

void TestLoop()

{

SearchTreeNode * root;

SearchTreeInit(&root);

SearchTreeInsert(&root,'e');

SearchTreeInsert(&root,'a');

SearchTreeInsert(&root,'f');

SearchTreeInsert(&root,'b');

SearchTreeInsert(&root,'d');

SearchTreeInsert(&root,'c');

PreOder(root);

printf("\n");

InOder(root);

printf("\n");

SearchTreeNode* find=SearchTreeFindByLoop(root,'b');

printf("The find result is b  actual: %c \n",find->key);

SearchTreeRemoveByLoop(&root,'b');

PrintChar("remove one value",root);

SearchTreeRemoveByLoop(&root,'f');

PrintChar("remove two value",root);

SearchTreeRemoveByLoop(&root,'d');

PrintChar("remove three value",root);

SearchTreeRemoveByLoop(&root,'c');

PrintChar("remove four value",root);

SearchTreeRemoveByLoop(&root,'e');

PrintChar("remove five value",root);

}

int main()

{

Test();

TestLoop();

return 0;

}

=============Test==============
==After insert==
preoder
baecdf
inoder
abcdef
The find result is e
The find is (nil)

==After remove==
preoder
acf
inoder
acf

=============TestLoop==============
eabdcf
abcdef
The find result is b  actual: b
remove one value
acdef
remove two value
acde
remove three value
eac
ace
remove four value
ea
ae
remove five value
a
a