二叉搜索树

二叉搜索树是一个二叉树来组织的，二叉搜索树父节点的左孩子的关键字不大于它的关键字，父节点的右孩子的关键字不小于父节点的关键字。

二叉树的遍历有前序遍历、中序遍历、后序遍历，其中中序遍历输出的关键字按照从小到大的顺序。

我们定义的二叉搜索树类具有查询关键字、返回最大最小关键字、返回某个节点的前驱和后继、插入和删除二叉树某个节点等功能。

以下是二叉树的类定义：

//name:BST.h
#ifndef BINARY_SEARCH_TREE_H
#define BINARY_SEARCH_TREE_H

#include<iostream>

using namespace std;

template<typename Key>
class BST {
private:
	struct BSTnode {
		Key key;
		BSTnode *left, *right;
		BSTnode *parent;

		BSTnode(Key key) {
			this->key = key;
			this->left = this->right = this->parent = NULL;
		}
	};

	BSTnode *root;
	int scount;

public:
	BST() {
		root = NULL;
		scount = 0;
	}

	~BST() { }

	//中序遍历
	void In_Walk_Tree() {
		inOrder(root);
	}

	//前序遍列
	void Pre_Walk_Tree() {
		preOrder(root);
	}

	//后序遍历
	void Post_Walk_Tree() {
		postOrder(root);
	}

	//给定一个以node为根的二叉搜索树
	//查找二叉树中具有关键字key
	//如果查找到，返回指向该节点的指针；如果没有返回NULL
	BSTnode* BST_Search_Key(BSTnode* node,Key key) {
		if (node == NULL || node->key==key)
			return node;
		if (node->key > key)
			BST_Search_Key(node->left, key);
		else
			BST_Search_Key(node->right, key);
	}

	//查找一个以node为根的二叉树中的最大关键字maxKey
	BSTnode* BST_Search_maxKey(BSTnode* node) {
		if (node == NULL)
			return NULL;
		while (node->right!=NULL)
			node = node->right;
		return node;
	}

	//查找一个以node为根的二叉树中的最小关键字minKey
	BSTnode* BST_Search_minKey(BSTnode* node) {
		if (node == NULL)
			return NULL;
		while (node->left!=NULL)
			node = node->left;
		return node;
	}

	//给定一个节点，查找它的后继节点，并返回指向该节点的指针
	//后继节点指第一个比该节点关键字大的关键字的节点
	//该节点不能为二叉搜索树的最大节点
	BSTnode* BST_Successor(BSTnode* node) {
		if (node->right != NULL)
			return BST_Search_minKey(node->right);
		BSTnode* y = node->parent;
		while (y != NULL&&node == y->right) {
			node = y;
			y = y->parent;
		}
		return y;
	}

	//给定一个节点，查找它的前驱节点，并返回指向该节点的指针
	//前驱节点指第一个比这个关键字小的关键字的节点
	//该节点不能为二叉搜索树的最小节点
	BSTnode* BST_Precursor(BSTnode* node) {
		if (node->left != NULL)
			return BST_Search_maxKey(node->left);
		BSTnode* y = node->parent;
		while (y != NULL&&node == y->left) {
			node = y;
			y = y->parent;
		}
		return y;
	}

	//给定一个关键字key，将以关键字为key的节点插入到二叉搜索树中
	void BST_Insert(Key key) {
		BSTnode* insertNode = new BSTnode(key);
		BSTnode* yNode = NULL;
		BSTnode* xNode = root;

		while (xNode != NULL) {
			yNode = xNode;
			if (key < xNode->key)
				xNode = xNode->left;
			else
				xNode = xNode->right;
		}
		insertNode->parent = yNode;
		if (yNode == NULL)
			root = insertNode;
		else if (key < yNode->key)
			yNode->left = insertNode;
		else
			yNode->right = insertNode;
		scount++;
	}

	//给定一个关键字key，将以关键字为key的节点从二叉搜索树中删除
	void BST_Delete(Key key) {
		BSTnode* deleteNode = BST_Search_Key(root, key);
		if (deleteNode->left == NULL)
			transplant(deleteNode, deleteNode->right);
		else if (deleteNode->right == NULL)
			transplant(deleteNode,deleteNode->left);
		else {
			BSTnode* yNode = BST_Search_minKey(deleteNode->right);
			if (deleteNode != yNode->parent) {
				transplant(yNode, yNode->right);
				yNode->right = deleteNode->right;
				yNode->right->parent = yNode; //维护双亲节点
			}
			transplant(deleteNode, yNode);
			yNode->left = deleteNode->left;
			yNode->left->parent = yNode; //维护双亲节点
		}
		scount--;
	}

	//返回二叉搜索树节点的数目
	int sizeOfBST() {
		return scount;
	}

	//判断二叉搜索树是否为空
	bool isEmpty() {
		return scount == 0;
	}

private:
	//中序遍列
	void inOrder(BSTnode* node) {
		if (node!=NULL) {
			inOrder(node->left);
			cout << node->key << " ";
			inOrder(node->right);
		}
	}

	//前序遍列
	void preOrder(BSTnode* node) {
		if (node != NULL) {
			cout << node->key << " ";
			preOrder(node->left);
			preOrder(node->right);
		}
	}

	//后序遍历
	void postOrder(BSTnode* node) {
		if (node != NULL) {
			postOrder(node->left);
			postOrder(node->right);
			cout << node->key << " ";
		}
	}

	//利用以vNode为节点的子树替换以uNode为节点的子树
	void transplant(BSTnode* uNode, BSTnode *vNode) {
		if (uNode == NULL)
			root = vNode;
		else if (uNode == uNode->parent->left)
			uNode->parent->left = vNode;
		else
			uNode->parent->right = vNode;
		if (vNode != NULL)
			vNode->parent = uNode->parent;
	}

};

#endif

以下是测试二叉树的函数：

//name:main.h
#include<vector>
#include"BST.h"

using std::vector;

int main() {
	BST<int> bstree = BST<int>();
	vector<int> testVec = {13,16,7,24,8,1,49,20};
	int vecSize = testVec.size();
	for (int i = 0; i < vecSize; i++) {
		bstree.BST_Insert(testVec[i]);
	}
	bstree.In_Walk_Tree();
	
	bstree.BST_Delete(24);
	bstree.In_Walk_Tree();
	return 0;
}