二叉查找树（c语言实现）

二叉查找树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树：

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

它的左、右子树也分别为二叉排序树。

二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。中序遍历
二叉排序树可得到一个关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即为对无序序列进行排序的过程。每次插入

的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。搜索,插入,删除的复杂度等
于树高，O(log(n)).

/***********************************bstree.h*********************************/

#ifndef _BSTREE_H

#define _BSTREE_H

#ifdef _cplusplus

extern "C"{

#endif

typedef int Value;

struct _BSTreeNode;

typedef struct _BSTreeNode BSTreeNode;

BSTreeNode* binary_search_tree_create();

void binary_search_tree_destroy(BSTreeNode* thiz);

BSTreeNode* binary_search_tree_get_value_by_value(BSTreeNode* thiz,
Value value);

BSTreeNode* binary_search_tree_get_min(BSTreeNode* thiz);

BSTreeNode* binary_search_tree_get_max(BSTreeNode* thiz);

BSTreeNode* binary_search_tree_insert(BSTreeNode* thiz, Value value);

BSTreeNode* binary_search_tree_delete(BSTreeNode* thiz, Value value);

void binary_search_tree_print(BSTreeNode* thiz);

#ifdef _cplusplus

}

#endif

#endif/*_TREE_H*/

/**********************bstree.c*************************/

#include <stdlib.h>

#include <stdio.h>

#include "bstree.h"

struct _BSTreeNode

{

Value value;

BSTreeNode* left;

BSTreeNode* right;

};

/*******************************创建一棵二叉
树**********************************/

BSTreeNode* binary_search_tree_create(Value value)

{

BSTreeNode* thiz = (BSTreeNode*)malloc(sizeof(BSTreeNode));



thiz->value = value;

thiz->left = NULL;

thiz->right = NULL;

return thiz;

}

/******************************销毁这棵二叉树*********************************/

void binary_search_tree_destroy(BSTreeNode* thiz)

{

if(thiz != NULL)

{

if(thiz->left != NULL)

{

binary_search_tree_destroy(thiz->left);

}

if(thiz->right != NULL)

{

binary_search_tree_destroy(thiz->right);

}

}

free(thiz);

thiz = NULL;

return;

}

/**********************在二叉树中查找值为value的节点*************************/

BSTreeNode* binary_search_tree_get_value_by_value(BSTreeNode* thiz,
Value value)

{

BSTreeNode* iter = thiz;

if(iter == NULL)

{

printf("value not found!/n");

return NULL;

}

else if( value < iter->value )

{

return
binary_search_tree_get_value_by_value(iter->left, value);

}

else if( value > iter->value)

{

return
binary_search_tree_get_value_by_value(iter->right, value);

}

else

{

return iter;

}

}

/*****************得到二叉树中最小值的节点(递归算法)*****************/

BSTreeNode* binary_search_tree_get_min(BSTreeNode* thiz)

{

if(thiz == NULL)

{

return NULL;

}

else if(thiz->left == NULL)

{

return thiz;

}

return binary_search_tree_get_min(thiz->left);

}

/****************得到二叉树中最大值的节点(非递归算法)******************/

BSTreeNode* binary_search_tree_get_max(BSTreeNode* thiz)

{

if(thiz != NULL)

while(thiz->right != NULL)

{

thiz = thiz->right;

}



return thiz;

}

/********************在二叉树中插入一个值为value的节点**********************/

BSTreeNode* binary_search_tree_insert(BSTreeNode* thiz, Value value)

{

if(thiz == NULL)

{

thiz = binary_search_tree_create(value);

}

else if(value < thiz->value)

thiz->left = binary_search_tree_insert(thiz->left,
value);

else if(value > thiz->value)

thiz->right =
binary_search_tree_insert(thiz->right, value);

return thiz;

}

/********************在二叉树中删除一个值为value的节点***********************/

BSTreeNode* binary_search_tree_delete(BSTreeNode* thiz, Value
value)

{

BSTreeNode* iter = thiz;

BSTreeNode* tmp = NULL;

if(iter == NULL)

printf("Element not found!/n");

else if(value < thiz->value)

thiz->left = binary_search_tree_delete(thiz->left,
value);

else if(value > thiz->value)

thiz->right =
binary_search_tree_delete(thiz->right, value);

else if(thiz->right != NULL && thiz->left != NULL)

{

iter = binary_search_tree_get_min(thiz->right);

thiz->value = iter->value;

thiz->right =
binary_search_tree_delete(thiz->right, thiz->value);

}

else

{

iter = thiz;

if(thiz->left == NULL)

thiz = thiz->right;

else if(thiz->right == NULL)

thiz = thiz->left;

free(iter);

}

return thiz;

}

/********************二叉树的打印*******************/

void binary_search_tree_print(BSTreeNode* thiz)

{

if(thiz != NULL)

{

printf("%d/t", thiz->value);

if(thiz->left != NULL)

binary_search_tree_print(thiz->left);

if(thiz->right != NULL)

binary_search_tree_print(thiz->right);

}

return;

}

/****************测试函数*****************/

#ifdef BSTREE_TEST

#include "bstree.h"

int main(int argc, char* argv[])

{

BSTreeNode* thiz = NULL;

BSTreeNode* iter = NULL;

int value = 35;

int i = 0;

thiz = binary_search_tree_create(value);

thiz = binary_search_tree_insert(thiz, 30);

thiz = binary_search_tree_insert(thiz, 29);

thiz = binary_search_tree_insert(thiz, 31);

thiz = binary_search_tree_insert(thiz, 27);

thiz = binary_search_tree_insert(thiz, 28);

thiz = binary_search_tree_insert(thiz, 26);

thiz = binary_search_tree_insert(thiz, 37);

thiz = binary_search_tree_insert(thiz, 36);

thiz = binary_search_tree_insert(thiz, 49);

thiz = binary_search_tree_insert(thiz, 45);

thiz = binary_search_tree_insert(thiz, 0);

binary_search_tree_print(thiz);

printf("/n");



iter = binary_search_tree_get_value_by_value(thiz, value);

printf("47's search %d success!/n", iter->value);

iter = binary_search_tree_get_min(thiz);

printf("min value search %d success!/n", iter->value);

iter = binary_search_tree_get_max(thiz);

printf("max value search %d success!/n", iter->value);



thiz = binary_search_tree_delete(thiz, 37);

binary_search_tree_print(thiz);

printf("/n");

thiz = binary_search_tree_delete(thiz, 26);

binary_search_tree_print(thiz);

printf("/n");

binary_search_tree_destroy(thiz);

return 0;

}

#endif/*BSTREE_TEST*/