二叉排序树（BST）查找算法详解之C语言版

一、算法原理

二叉排序树（Binary Sort Tree或 Binary Search Tree）又称二叉查找树，可以用来实现数据的快速查找，也方便数据的插入、删除等工作，因此适用于数据的动态查找。
二叉排序树是一棵二叉树，其左子树上的元素都小于树根，右子树上的元素都大于树根，所有的子树也满足这个性质。
在二叉排序树上查找某个结点，其实就是遍历二叉树。由于二叉排序树上的结点是有序的，因此不需要使用普通二叉树的遍历算法，其有自己一套简单的遍历算法，即从树根开始进行遍历，如果待查找元素小于树根元素，则向左遍历，否则向右遍历，如果相等结束遍历。
下面以具体案例给出二叉排序树查找的详细过程。

Demo 1 ：假设有二叉排序树如下图所示，想要查找数据10。

Step 1：引入一个临时指针p指向树根，结果如下图所示。

Step 2：用10与p指向结点中的元素进行比较，10 < 18，则p指向p的左子树树根，结果如下图所示。

Step 3：用10与p指向结点中的元素进行比较，10 > 3，则p指向p的右子树树根，结果如下图所示。

Step 4：用10与p指向结点中的元素进行比较，10 > 7，则p指向p的右子树树根，结果如下图所示。

Step 5：用10与p指向结点中的元素进行比较，10 < 14，则p指向p的左子树树根，但是此时p的左子树为空，因此结束查找，查找结果为该二叉排序树上没有元素10。
Demo 2 ：如果想要查找数据19，则具体如下：
Step 1：引入一个临时指针p指向树根，结果如下图所示。

Step 2：用19与p指向结点中的元素进行比较，19 > 18，则p指向p的右子树树根，结果如下图所示。

Step 3：用19与p指向结点中的元素进行比较，19 < 20，则p指向p的左子树树根，结果如下图所示。

Step 4：用19与p指向结点中的元素进行比较，19== 19为真，则查找成功，结束查找。

从上述查找过程可以看出，平均查找长度约等于BST树的深度，因此其查找效率比较高。

二、二叉排序树查找算法的C程序

1. 二叉排序树查找函数—非递归算法

int SearchBST( BST *T, int key )
{
	int flag = 0; //查找成功标志，初始化为失败 
	BST *p = T; 
	while( p != NULL )
	{
		if ( p->data == key )
		{
			flag = 1;
			break;
		}
		else if( key < p->data )
		{
			p = p->LChild;
		}
		else
		{
			p = p->RChild;
		}
	}
	return( flag );
}

2.测试代码（仅供参考）

#include"stdio.h" 
#include"malloc.h"

#define MAX_NODE 100

typedef struct node
{
	int data;
	struct node *LChild;
	struct node *RChild;
}BST;
void CreateBST( BST *T, int arr[], int n );
int SearchBST( BST *T, int key );

int main()
{
	int arr[] = { 18, 3, 7, 20, 14, 19, 27, 2 };
	BST *T = ( BST * )malloc( sizeof( BST ) );
	CreateBST( T, arr, 8 );
	
	int flag, key;
	key = 10;
	flag = SearchBST( T, key );
	if( flag == 0 )
	{
		printf( "failure : %d is not on the BST\n", key );
	}
	else
	{
		printf( "success : %d is on the BST\n", key );
	}
	
	key = 19;
	flag = SearchBST( T, key );
	if( flag == 0 )
	{
		printf( "failure : %d is not on the BST\n", key );
	}
	else
	{
		printf( "success : %d is on the BST\n", key );
	}
	return 0;
}//main
//根据已知的数组arr创建二叉排序树 
void CreateBST( BST *T, int arr[], int n ) 
{
	BST *s, *p, *q; 
	int i; 
	T->data = arr[0]; 
	T->LChild = NULL; 
	T->RChild = NULL; 
	for( i = 1; i < n; i++ ) 
	{
		s = (BST *)malloc( sizeof(BST) ); 
		s->data   = arr[i];
		s->LChild = NULL;
		s->RChild = NULL;
		p = T;
		while( p != NULL )
		{
			if( s->data == p->data )
			{
				printf( "%d existed.\n", s->data );
				q = NULL;
				break; 
			}
			q = p;
			if( s->data < p->data )
			{
				p = p->LChild;
			}
			else if( s->data > p->data )
			{
				p = p->RChild;			
			}
		} 
		if( q != NULL && s->data < q->data )
		{
			q->LChild = s;
		}
		else if( q != NULL && s->data > q->data )
		{
			q->RChild = s;
		}	
	}
}//CreateBST
//在BST树上查找元素key，返回查找成功与失败的标志 
int SearchBST( BST *T, int key )
{
	int flag = 0; //查找成功标志，初始化为失败 
	BST *p = T; 
	while( p != NULL )
	{
		if ( p->data == key )
		{
			flag = 1;
			break;
		}
		else if( key < p->data )
		{
			p = p->LChild;
		}
		else
		{
			p = p->RChild;
		}
	}
	return( flag );
}//SearchBST

3.运行结果