二叉排序树

1.作用

①当有序表是静态查找表时，用顺序存储加**二分查找**
②当有序表是动态查找表时，用二叉排序树更为恰当
③二叉排序树只需需改指针不用移动结点

2.操作

①构造二叉排序树(插入)
②查找二叉排序树
③删除二叉排序树某结点

1. 若被删结点无子树，则直接删除
2. 若被删结点有左子树或右子树，则删除后将子树移交给父节点
3. 若被删结点既有左子树又有右子树，则在整颗树内查找被删结点的下一个结点(按找数字大小顺序)。按照下述步骤：①记录下一个结点的值，②删除下一结点(删除此结点需要递归删除)，③将下一节点的值赋值给被删结点
   

3.代码

#pragma once
#include<iostream>
class BstNode {
public:
	int data;
	BstNode* lchild;
	BstNode* rchild;
	BstNode* parent;
	BstNode(int data) {
		this->data = data;
		lchild = nullptr;
		rchild = nullptr;
		parent = nullptr;
	}
};
class BST {
private:
	BstNode *root;
	int high;
public:
	BST(int* a, int length) {
		root = nullptr;
		high = 0;
		BST_Create(a, length);
		int b = 0;
	};
	BstNode* GetRoot() {
		return this->root;
	}
	//搜索二叉排序树中的某个结点
	BstNode* BST_Search(BstNode* Node,int data) {
		if (Node == nullptr)return nullptr;
		if (data == Node->data)return Node;
		if (data < Node->data)
		{
			return BST_Search(Node->lchild, data);
		}
		if (data > Node->data) {
			return BST_Search(Node->rchild, data);
		}
		 
	};
	//在二叉排序树中插入值
	void BST_Insert(BstNode* &Node,BstNode* &parent, int data) {
		if (Node == nullptr) {
			Node = new BstNode(data);
			Node->parent = parent;
			return;
		}
		Node->parent = parent;
		if (data == Node->data) { return; }
		if (data < Node->data) {
			 BST_Insert(Node->lchild,Node,data);
		}
		if (data > Node->data) {
			 BST_Insert(Node->rchild,Node, data);
		}
		
	};
	//使用数组创建二叉排序树
	void BST_Create(int*a,int length) {
		if (a == nullptr)return;
		BstNode* parent = nullptr;
		for (int i = 0; i < length; i++) {
			BST_Insert(root, parent,a[i]);
		}
		int b;
	};
	//删除二叉排序树中的某个结点
	void BST_Delete(BstNode* Node,int data) {
		BstNode* current_node = BST_Search(Node, data);
		//被删除结点左右子树为空
		if (current_node->lchild == nullptr && current_node->rchild == nullptr) {
			//处理当前结点的父节点，让其指向nullprt
			if (current_node == current_node->parent->lchild)current_node->parent->lchild = nullptr;
			else if (current_node == current_node->parent->rchild)current_node->parent->rchild = nullptr;
			delete current_node;
			return;
		}
		//被删除结点左子树为空
		if (current_node->lchild==nullptr && current_node->rchild!=nullptr){
			if (current_node == current_node->parent->lchild) {
				current_node->parent->lchild = current_node->rchild;
				delete current_node;
			}
			else if (current_node == current_node->parent->rchild) {
				current_node->parent->rchild = current_node->rchild;
				delete current_node;
			}
			return;
		}
		//被删除结点右子树为空
		if (current_node->lchild != nullptr && current_node->rchild == nullptr) {
			if (current_node == current_node->parent->lchild) {
				current_node->parent->lchild = current_node->lchild;
				delete current_node;
			}
			else if (current_node == current_node->parent->rchild) {
				current_node->parent->rchild = current_node->lchild;
				delete current_node;
			}
			return;
		}
		//被删除结点左右子树都不为空
		if (current_node->lchild != nullptr && current_node->rchild != nullptr) {
			BstNode* After_Node = current_node->rchild;
			//找到被删除结点按顺序排列的下一个结点
			while (After_Node->lchild != nullptr) {
				After_Node = After_Node->lchild;
			}
			//记录下一结点的值
			int data = After_Node->data;
			//递归删除下一结点，继续用分三种情况分析
			BST_Delete(current_node, After_Node->data);
			current_node->data = data;
			return;
		}

		int a;
	};
	void BST_Foreach(BstNode* Node){
		if (Node == nullptr)return;
		BST_Foreach(Node->lchild);
		Visit(Node);
		BST_Foreach(Node->rchild);
	}
	void Visit(BstNode* Node) {
		std::cout << Node->data<<std::endl;
	}
};




main-------------------------
#include <iostream>
#include"BST.h"
using namespace std;
int main()
{
	int a[] = { 53,17,9,45,23,78,65,94,81,88};
	BST* tree = new BST(a,10);
	BstNode* root = tree->GetRoot();
	tree->BST_Foreach(root);
	cout << endl;
	tree->BST_Delete(root,45);
	cout << endl;
	tree->BST_Foreach(root);



}