二叉搜索树的实现

二叉搜索树又称二叉排序树或二叉查找树，具有以下几个性质：

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

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

    （3）、它的左、右子树也分别为二叉搜索树。

将一个整型数组用二叉排序树表示出来，其中序遍历就是整型数组的升序排序。在常用排序算法中，二叉排序树是排序效率较高的一个，下面是二叉排序树的简单实现：

#include 
   
   
    
    
#include 
    
    
     
     

using namespace std;

struct BSTNode {
	int val;
	struct BSTNode *left, *right;
};

// 二叉排序树的插入
void BST_insert(BSTNode* &T, int element) {
	if (T == NULL) {
		T = new BSTNode;
		T->val = element;
		T->left = NULL;
		T->right = NULL;
		return;
	}

	if (element < T->val)
		BST_insert(T->left, element);
	if (element > T->val)
		BST_insert(T->right, element);
	if (element == T->val)
		return;
}

// 二叉排序树的中序遍历
void inOrder(BSTNode* T) {
	if (T == NULL)
		return;

	stack
     
     
      
       s;
	BSTNode* node = T;

	while (node != NULL || !s.empty()) {
		while (node != NULL) {
			s.push(node);
			node = node->left;
		}

		node = s.top();
		cout << node->val << " ";
		s.pop();

		if (node->right == NULL)
			node = NULL;
		else
			node = node->right;
	}
	cout << endl;
}

//查找二叉搜索树中最小值（递归实现）
BSTNode* findMin(BSTNode* T) {
	BSTNode* _T = T;

	if (_T == NULL)
		return NULL;

	else if (_T->left == NULL)
		return _T;

	else
		return findMin(_T->left);
}

//查找二叉搜索树中最大值（非递归实现）
BSTNode* findMax(BSTNode* T) {
	BSTNode* _T = T;

	if (_T == NULL)
		return NULL;

	while (_T->right) {
		_T = _T->right;
	}

	return _T;
}

//判断二叉查找树是否包含指定的元素
bool BST_contains(BSTNode* T, const int value) {
	if (T == NULL)
		return false;

	else if (value < T->val)
		return BST_contains(T->left, value);

	else if (value > T->val)
		return BST_contains(T->right, value);

	else
		return true;

}

//查找二叉搜索树中指定的元素
BSTNode* BST_search(BSTNode* T, int value) {
	BSTNode* _Tmp = T;
	while (_Tmp != NULL) {
		if (value == _Tmp->val)
			return _Tmp;

		else if (value < _Tmp->val)
			_Tmp = _Tmp->left;

		else if (value > _Tmp->val)
			_Tmp = _Tmp->right;
	}

	return NULL;
}

//删除二叉查找树中指定的元素值
void BST_delete(BSTNode* &T, int value) {
	if (T == NULL)
		return;

	if (value < T->val)
		BST_delete(T->left, value);
	
	else if (value > T->val)
		BST_delete(T->right, value);

	else if (T->left != NULL && T->right != NULL) {
		T->val = findMin(T->right)->val;
		BST_delete(T->right, T->val);
	}

	else if (T->left == NULL && T->right == NULL) {
		delete T;
		T = NULL;
	}

	else if (T->left == NULL || T->right == NULL) {
		BSTNode* temp = T;
		T = (T->left != NULL) ? T->left : T->right;
		delete temp;
	}
}

int main() {
	BSTNode *T = NULL;
	int a[10] = { 3, 2, 8, 6, 9, 7, 0, 1, 4, 5 };
	
	//creatBST(T, a, 10);

	for (int i = 0; i < 10; i++) {
		BST_insert(T, a[i]);
	}

	cout << "中序（从小到大排序）：";
	inOrder(T);

	return 0;
}