c++ 二叉搜索树实现

1.什么是二叉搜索树？

二叉搜索树是一种特殊的树形结构，他的每一个节点永远比他的左孩子大，且比右孩子小。他的中序遍历，是从小到大排列。

2.他有什么特点：

• 最左边的节点是整个数据结构中最小的数据，最右边为最大。
• 中序遍历为一个递增的排列
• 左右子树也为二叉搜索树
• 他的左右子树也为二叉搜索树

3.代码

 

#pragma once
#include <iostream>
#include <vector>
using namespace std;
template<typename T>
struct BSTreeNode{
	BSTreeNode(const T& data=T())
		:left(nullptr)
		,right(nullptr)
		,data(data)
	{}
	BSTreeNode<T> *left;
	BSTreeNode<T> *right;
	T data;
};
template<typename T>
class BSTree {
public:
	typedef BSTreeNode<T> Node;
	//初始化
	//初始化
	BSTree()
		:pRoot(nullptr)
	{}
	//插入
	bool Insert(const T& data){
		//空树
		if (nullptr == pRoot) {
			pRoot = new Node(data);
			return true;
		}
		//非空
		Node* parent = nullptr;
		Node* pos = pRoot;
		while (pos!=nullptr) {
			if (data < pos->data) {
				parent = pos;
				pos = pos->left;
			}
			else if (data > pos->data) {
				parent = pos;
				pos = pos->right;
			}
			else {
				return false;
			}
		}
		//判断左子树还是右子树为空
		if (data < parent->data) {
			//左子树
			parent->left = new Node(data);
		}
		else if (data > parent->data) {
			parent->right = new Node(data);
		}
		return true;
	}
	//查找
	Node* Find(const T& data) {
		Node* pCur = pRoot;
		Node* parent = nullptr;
		while (pCur!=nullptr) {
			if (data < pCur->data) {
				parent = pCur;
				pCur = pCur->left;
			}
			else if(data>pCur->data){
				parent = pCur->right;
				pCur = pCur->right;
			}
			else {
				return pCur;
			}
		}
		return nullptr;
	}
	//删除
	bool erase(const T& data) {
	//找到该节点
		Node* pCur = pRoot;
		Node* parent = nullptr;
		//找到该节点
		while (pCur!=nullptr) {
			if (data < pCur->data) {
				parent = pCur;
				pCur = pCur->left;
			}
			else if (data > pCur->data) {
				parent = pCur;
				pCur = pCur->right;
			}
			else {
				break;
			}
		}
		//不存在此节点
		if (pCur == nullptr) {
			return false;
		}
		//删除该节点
		if (pCur->left == nullptr) {
			//左孩子不存在，则只剩下右孩子存在，和右孩子不存在的情况
			//父节点只需接管右孩子即可（可为空）
			if (parent == nullptr) {
				pRoot = pCur->right;
			}
			if (parent->left == pCur) {//该节点是左孩子
				parent->left = pCur->right;
			}
			else {//该节点是右孩子
				parent->right = pCur->right;
			}
			delete pCur;
		}
		else if (pCur->right == nullptr) {
			//左孩子存在，右孩子不存在
			if (parent == nullptr) {
				pRoot = pCur->left;
			}
			//父节点直接接管左孩子即可
			if (parent->left == pCur)
				parent->left = pCur->left;
			else
				parent->right = pCur->left;
			delete pCur;
		}
		else{
			//左右节点均存在
			Node* pDel = pCur->right;
			//找到右子树中最小的数替换该节点，并删除最小的节点
			while (pDel->left != nullptr) {
				parent = pDel;
				pDel = pDel->left;
			}
			pCur->data = pDel->data;
			if (parent->left == pDel)
				parent->left == nullptr;
			else
				parent->right == nullptr;
			delete pDel;
		}

	}
	//中序遍历打印
	void _print() {
		print(pRoot);
	}
private:
	void print(Node* pos) {
		if (pos != nullptr) {
			print(pos->left);
			cout << pos->data << " ";
			print(pos->right);
		}		
	}
private:
	Node* pRoot;
};