重温二叉搜索树

       二叉搜索树又名为二叉查找树、有序二叉树、查找二叉树，是一种很重要的基础性数据结构，支持多种动态集合操作，包括插入、删除、查找等操作。二叉树的优势在于查找、插入的时间复杂度较低，为O(lg n)，不过如果数据不好，最坏的时间复杂度为O(n)，比如把有序的数据插入二叉树。

     二叉搜索树可以当做字典（其中键就是树节点的关键字，值为任何类型的数据，叫做卫星数据），也可以当做优先队列。

       二叉搜索树是递归定义的，定义是对树中的任一节点x，左子树的关键字y不大于该节点的关键字(key[y]<=key[x])，右子树的节点的关键字y不小于该节点的关键字(key[y]>=key[x])。

      下面是二叉搜索树的代码，花了好长时间调试，有点生疏了。这里的二叉搜索树是没有重复值的。

     

#ifndef __BSTree_H__
#define __BSTree_H__
#include <cassert>

template <typename T>
struct BSTreeNode {
	BSTreeNode *left, *right;
	T val;
	BSTreeNode(T _val, BSTreeNode *_left=NULL, BSTreeNode *_right=NULL):
		val(_val), left(_left), right(_right)
	{}
};

template<typename T>
class BSTree {
private:
	BSTreeNode<T> *root;
	size_t size;
	typedef void (*visitFun)(T);
	//查找值val节点的父亲指针
	BSTreeNode<T>* findParent(BSTreeNode<T> *x)
	{
		assert(x != NULL);
		if (x == root)
			return NULL;
		BSTreeNode<T> *y = root, *p;
		while (y != NULL && y->val != x->val) {
			p = y;
			if (y->val < x->val) {
				y = y->right;
			} else if (y->val > x->val) {
				y = y->left;
			} 
		}
		return p;
	}
	void inOrderTraversal(BSTreeNode<T> *root, visitFun visit) 
	{
		if (root) {
			inOrderTraversal(root->left, visit);  //访问左子树
			//cout << root->val << " ";    //访问该节点
			visit(root->val);
			inOrderTraversal(root->right, visit);  //访问右子树
		}
	}
public:
	
	BSTree()
	{
		root = NULL;
		size = 0;
	}
	~BSTree()
	{
		releaseMemory(root);
	}
	// 释放内存
	void releaseMemory(BSTreeNode<T> *root)
	{
		if (root != NULL) {
			releaseMemory(root->left);
			releaseMemory(root->right);
			delete root;
		}
	}
	//查找值为val的节点，如果成功查找则返回该节点指针，否则返回NULL
	BSTreeNode<T>* find(T val)
	{
		BSTreeNode<T> *x = root;
		while (x != NULL) {
			if (x->val < val) {
				x = x->right;
			} else if (x->val > val) {
				x = x->left;
			} else {
				return x;
			}
		}
		return NULL;
	}

	//插入val，如果成功插入则返回true，否则（已有值为val的节点）则返回false
	bool insert(T val)
	{
		if (root == NULL) {
			root = new BSTreeNode<T>(val);
			++size;
			return true;
		}
		BSTreeNode<T> *x = root, *parent;
		while (x != NULL) {
			parent = x;
			if (x->val < val) {
				x = x->right;
			} else if (x->val > val) {
				x = x->left;
			} else {    // 二叉搜索树中已有值val的节点
				return false;
			}
		}
		//循环结束后，parent为叶节点，p为NULL
		BSTreeNode<T> *nodePtr = new BSTreeNode<T>(val);
		if (parent->val > val)
			parent->left = nodePtr;
		else
			parent->right = nodePtr;
		++size; return true;
	}
	//删除值为val的节点，成功删除则返回true，否则（没找到节点）则返回false
	//Version 1: 写得不好，太繁琐，其实不用找到它的父节点的，可以简化
	/*
	bool remove(T val) 
	{
		BSTreeNode<T> *x = find(val);
		if (x == NULL) {
			return false;
		}
		BSTreeNode<T> *parent = findParent(x);
		// 删除根节点
		if (parent == NULL) {
			if (x->left==NULL && x->right==NULL) {
				delete x;
				root = NULL;
			} else if (x->left != NULL) {
				BSTreeNode<T> *y = x->left, *py = x;
				assert(y!=NULL);
				while (y->right != NULL) {
					py = y;
					y = y->right;
				}
				//y此时是x左子树的最右孩子
				x->val = y->val;
				if (py == x) {
					py->left = y->left;
				} else {
					py->right = y->left;
				}
				delete y;
			} else {
				BSTreeNode<T> *y = x->right, *py = x;
				assert(y!=NULL);
				while (y->left != NULL) {
					py = y;
					y = y->left;
				}
				//y此时是x右子树的最左孩子
				x->val = y->val;
				if (py == x) {
					py->right = y->right;
				} else {
					py->left = y->right;
				}
				delete y;
			}
		}
		// x为叶节点,修改父节点parent指向x的指针为NULL
		else if (x->left==NULL && x->right==NULL) {
			parent->val < x->val ? parent->right=NULL : parent->left=NULL;
			delete x;
		}
		// x只有一个子女，删除x
		else if (x->left==NULL || x->right==NULL) {
			if (x->left == NULL)
				parent->val < x->val ? parent->right=x->right : parent->left=x->right;
			else
				parent->val < x->val ? parent->right=x->left : parent->left=x->left;
			delete x;
		}
		// x有左右孩子，把x的右子树最左节点y赋给x，然后删除y
		else {
			BSTreeNode<T> *y = x->right, *py = x;
			assert(y!=NULL);
			while (y->left != NULL) {
				py = y;
				y = y->left;
			}
			//y此时是x右子树的最左孩子
			x->val = y->val;
			if (py == x) {
				py->right = y->right;
			} else {
				py->left = y->right;
			}
			delete y;
		}
		--size;
		return true;
	}*/
	// Version 2: 删除值为val的节点
	bool remove(T val) 
	{
		BSTreeNode<T> *x = find(val);
		if (!x) {
			return false;
		}
		//x为叶节点，直接删除即可
		if (!x->left && !x->right) {
			if (x == root)    // 需判断是否根节点
				root = NULL;
			delete x;
		} else if (!x->right) {    // 右子树为空，重连左子树
			BSTreeNode<T> *y = x->left;
			x->val = y->val;
			x->left = y->left;
			x->right = y->right;
			delete y;
		} else if (!x->left) {  // 左子树为空，重连右子树
			BSTreeNode<T> *y = x->right;
			x->val = y->val;
			x->left = y->left;
			x->right = y->right;
			delete y;
		} else {   //左右子树非空,把左子树的最右孩子赋给x后删除
			BSTreeNode<T> *y = x->left, *py = x;
			while (y->right) {
				py = y;
				y = y->right;
			}
			x->val = y->val;
			if (py != x) {
				py->right = y->left;
			} else {
				x->left = y->left;
			}
			delete y;
		}
		--size;
		return true;
	}
	// 中序遍历,可以得到有序的数列
	void inOrderTraversal(visitFun visit)
	{
		inOrderTraversal(root, visit);
	}
	size_t getSize() const 
	{
		return size;
	}
		
};
#endif

/* Author: freeliao
   Time: 2014/1/3 14:00   Modified: 1/4 21:00
   Program: Implementation of Binary Serach Tree
   Email:296589764@qq.com
*/
#include <iostream>
#include <ctime>
#include <set>
#include <vector>
#include "BSTree.h"
using namespace std;

vector<int> vb, vs;

void visit(int a)
{
	cout << a <<" ";
}

void copy(int a)
{
	vb.push_back(a);
}

int main()
{
	BSTree<int> bst;
	srand(unsigned(time(NULL)));

	const int MAXNUM = 1000, n = 100;
	int a[MAXNUM], num;
	set<int> s;
	for (int i=0; i<n; ++i) {
		num = rand() % MAXNUM;
		a[i] = num;
		bst.insert(a[i]);
		s.insert(a[i]);
	}

	assert(s.size() == bst.getSize());
	cout << "元素个数" << bst.getSize() << endl;
	
	cout << "===================================\n";
	cout << "比较bst与set元素是否相等\n";
	bst.inOrderTraversal(copy);
	vs.assign(s.begin(), s.end());
	assert(vb == vs);
	cout << "相等\n";

	cout << "==================================\n";
	cout << "从小到大排序结果...\n";
	bst.inOrderTraversal(visit);
	cout << endl;

	cout << "=====================================\n";
	for (int i=0; i<10; ++i) {
		cout << "删除" << a[i] << ":";
		s.erase(a[i]);
		if (bst.remove(a[i]) == true)
			cout << "成功\n";
		else
			cout << "失败\n";
	}
	cout << s.size() << " " << bst.getSize() << endl;
	assert(s.size() == bst.getSize());
	cout << "==================================\n";
	cout << "从小到大排序结果...\n";
	bst.inOrderTraversal(visit);
	cout << endl;

	cout << "===================================\n";
	cout << "比较bst与set元素是否相等\n";
	vb.clear();
	bst.inOrderTraversal(copy);
	vs.clear();
	vs.assign(s.begin(), s.end());
	assert(vb == vs);
	cout << "相等\n";

	system("pause");

	return 0;
}

经过多次测试没有任何问题，虽然代码写得不够精炼。

运行结果如下：