二叉查找树实现（C语言版本）

SearchTree.h 文件

#ifndef __Search_TREE_H__
#define __Search_TREE_H__

// 二叉查找树

#include "DataType.h"

typedef struct SearchTreeNode* SearchTreePt;
typedef struct SearchTreeNode  SearchTree;

struct SearchTreeNode
{
	DataType     data;      // 数据元素
	SearchTreePt left;      // 左子树
	SearchTreePt right;     // 右子树
	int          count;     // 数据重复的次数
};

// 接口
void TravelSearchTree( SearchTree* T );                         // 遍历 SearchTree
void ReleaseSearchTree( SearchTree* T );                        // 释放 SearchTree 空间
SearchTree* InsertToSearchTree( DataType X, SearchTree* T );    // 插入新节点 
SearchTree* FindDataInSearchTree( DataType X, SearchTree* T );  // 查找指定数据元素 
SearchTree* FindMinInSearchTree( SearchTree* T );               // 查找最小元素位置
SearchTree* FindMaxInSearchTree( SearchTree* T );               // 查找最大元素位置
SearchTree* DeleteDataOfSearchTree( DataType X, SearchTree* T );// 删除指定元素

#endif

其中DataType.h内容为：

#ifndef __DATA_TYPE_H__
#define __DATA_TYPE_H__
typedef int DataType;
#endif

SearchTree.c文件：

#include "SearchTree.h"

#include <stdlib.h>
#include <stdio.h>

static void __travel( SearchTree* root, int deep );
static SearchTree* __newNode( DataType data );

// 创建节点 
static SearchTree* __newNode( DataType X )
{
	SearchTree* ret = (SearchTree*)malloc(sizeof(SearchTree));
	
	if ( ret == NULL )
	{
		printf("Error: memory out!\n");
		return ret;
	}

	ret->data = X;
	ret->left = ret->right = NULL;
	ret->count = 1;

	return ret;
}

static void __travel( SearchTree* T, int deep )
{
	int i;
	if ( T == NULL )
	{
		return;
	}
	else
	{
		for ( i = 0; i < deep; ++i )
		{
			printf("\t");
		}
		printf("%d(%d)\n", T->data, T->count );
		__travel( T->left, deep+1 );
		__travel( T->right, deep+1 );
	}
}

// 插入新节点 
SearchTree* InsertToSearchTree( DataType X, SearchTree* T )
{
	if ( T == NULL )
		T = __newNode( X );
	else if( X == T->data )
		T->count += 1;
	else if ( X < T->data )
		T->left = InsertToSearchTree( X, T->left );
	else
		T->right = InsertToSearchTree( X, T->right );

	return T;
}

// 遍历 SearchTree
void TravelSearchTree( SearchTree* T )
{
	__travel( T, 0 );
}

// 释放 SearchTree 空间
void ReleaseSearchTree( SearchTree* T )
{
	if ( T != NULL )
	{
		ReleaseSearchTree( T->left );
		ReleaseSearchTree( T->right );
		free( T );
		T = NULL;
	}
}

// 查找数据元素 
SearchTree* FindDataInSearchTree( DataType X, SearchTree* T )
{
	if ( T == NULL || X == T->data )
		return T;
	else if ( X < T->data )
		return FindDataInSearchTree( X, T->left );
	else
		return FindDataInSearchTree( X, T->right );
}

// 查找最小元素位置
SearchTree* FindMinInSearchTree( SearchTree* T )
{
	if ( T == NULL || T->left == NULL )
		return T;
	else
		return FindMinInSearchTree( T->left );
}

// 查找最大元素位置
SearchTree* FindMaxInSearchTree( SearchTree* T )
{
	if ( T == NULL || T->right == NULL )
		return T;
	else
		return FindMaxInSearchTree( T->right );
}

// 删除指定元素
SearchTree* DeleteDataOfSearchTree( DataType X, SearchTree* T )
{
	SearchTree* P;
	if ( T == NULL )
	{
		return T;
	}
	else if( T->data == X )
	{
		if ( T->left == NULL && T->right == NULL ) // 如果是叶节点，直接删除
		{
			free(T);
			return NULL;
		}
		else if ( T->left == NULL )     // 左子树为空，则返回右子树
		{
			P = T;
			T = T->left;
			free( P );
			return T;
		}
		else if ( T->right == NULL )    // 右子树为空，则返回左子树
		{
			P = T;
			T = T->right;
			free( P );
			return T;
		}
		else                      // 左右子树均不空
		{
			// 找到右子树中的最小节点，将当前节点的值置为右子树最小节点的值
			// 然后在右子树中删除最小节点（右子树中最小节点无左子树）
			P = FindMaxInSearchTree( T->right );
			T->data = P->data;
			T->count = P->count;
			T->right = DeleteDataOfSearchTree( T->data, T->right );
		}
	}
	else if ( X < T->data )
	{
		T->left = DeleteDataOfSearchTree( X, T->left );
	}
	else
	{
		T->right = DeleteDataOfSearchTree( X, T->right );
	}

	return T;
}