数据结构之BST树

BST的概念

二叉排序树，首先得是二叉树

定义如下：

1、空树也是二叉搜索树树

2、若二叉搜索树的左（右）子树不为空，则其二叉搜索树上所有节点中关键值都小（大）于其根节点的关键值

3、若二叉搜索树的右子树不为空，则其二叉搜索树上所有节点中关键值都大于其根节点的关键值

4、二叉搜索树的子树也是二叉搜索树

5、二叉搜索树的关键值互不相同

如果用链式结构来实现二叉搜索树，它既有链表的插入和删除的高效率，并且还拥有快速查找的优点

应用十分广泛，文件系统和数据库里面都会用这种结构进行排序和检索

若要进行中序遍历，一定是递增的

#pragma once
//有效节点定义：
typedef int ELEMTYPE;

typedef struct BstNode
{
    ELEMTYPE data; // 数据域
    struct BstNode* leftchild;//左孩子指针
    struct BstNode* rightchild;//右孩子指针
    struct BstNode* parent;//双亲指针  
}BstNode, * PBstNode;

//辅助节点定义：
typedef struct BSTree
{
    BstNode* root;//用来抓住二叉搜索树的根节点
}BSTree;

//初始化
void Init_BStree(BSTree* pTree);

//查找
BstNode* Search_BST(BSTree* pTree, ELEMTYPE val);

//打印
void Show_Inorder(BstNode* root);

//插入
bool Insert_BST(BSTree* pTree, ELEMTYPE val);

//删除
bool Delete_BST(BSTree* pTree, ELEMTYPE val);

//购买新节点
BstNode* BuyNode();


BstNode* Get_Next(BstNode* p);

BstNode* Get_Prior(BstNode* p);

#include<stdio.h>
#include"BSTree.h"
#include <cassert>
#include <malloc.h>
#include<iostream>
#include<stack>
using namespace std;

//初始化
void Init_BStree(BSTree* pTree)
{
	assert(pTree != NULL);
	pTree->root = NULL;
}

//查找
BstNode* Search_BST(BSTree* pTree, ELEMTYPE val)
{
	assert(pTree != NULL);
	BstNode* pnode = pTree->root;
	while (pnode != NULL)
	{
		if (pnode->data == val)
			return pnode;
		else if (pnode->data > val)
			pnode = pnode->leftchild;
		else
			pnode = pnode->rightchild;
	}
	return NULL;
}

//打印
void Show_Inorder(BstNode* root)
{
	stack<BstNode*> stack;
	stack.push(root);
	bool tag = true;
	while (!stack.empty())
	{
		while (tag == true && stack.top()->leftchild != NULL)
		{
			stack.push(stack.top()->leftchild);
		}
		BstNode* p = stack.top();
		stack.pop();
		printf("%d\n", p->data);
		if (p->rightchild != NULL)
		{
			stack.push(p->rightchild);
			tag = true;
		}
		else
		{
			tag = false;
		}
	}
}

//插入
bool Insert_BST(BSTree* pTree, ELEMTYPE val)
{
	assert(pTree != NULL);
	BstNode* p = pTree->root;
	BstNode* pp = NULL;
	while (p != NULL && p->data != val)
	{
		if (val < p->data)
		{
			pp = p;
			p = p->leftchild;
		}
		else
		{
			pp = p;
			p = p->rightchild;
		}
	}
	if (p != NULL)
		return true;
	BstNode* pnewnode = BuyNode();
	pnewnode->data = val;
	if (pTree->root == NULL)//防止是空的BST树
		pTree->root = pnewnode;
	else
	{
		if (pp->data > val)
			pp->leftchild = pnewnode;
		else
			pp->rightchild = pnewnode;
		pnewnode->parent = pp;
	}
	return true;
}

//删除
bool Delete_BST1(BSTree* pTree, ELEMTYPE val)
{
	assert(pTree != NULL);
	BstNode* p = Search_BST(pTree, val);
	if (p == NULL)
		return false;
	if (p->leftchild == p->rightchild == NULL)
	{
		if (p->parent == NULL)
			pTree->root = NULL;//防止删除的是根节点
		if (p->data < p->parent->data)
			p->parent->leftchild = NULL;
		else
			p->parent->rightchild = NULL;
		free(p);
		p = NULL;
		return true;
	}
	return false;
}

bool Delete_BST2(BSTree* pTree, ELEMTYPE val)
{
	assert(pTree != NULL);
	BstNode* p = Search_BST(pTree, val);
	if (p == NULL)
		return false;
	if (p->leftchild ==NULL|| p->rightchild == NULL)
	{
		if (p->parent == NULL)
			pTree->root = NULL;//防止删除的是根节点
		if (p->data < p->parent->data)
		{
			if (p->leftchild != NULL)
				p->parent->leftchild = p->leftchild;
			else
				p->parent->leftchild = p->rightchild;
		}
		else
		{
			if (p->leftchild != NULL)
				p->parent->rightchild = p->leftchild;
			else
				p->parent->rightchild = p->rightchild;
		}
		free(p);
		p = NULL;
		return true;
	}
	return false;
}

BstNode* BuyNode()
{
	BstNode* pnewnode = (BstNode*)malloc(sizeof(BstNode));
	if (pnewnode == NULL)
		exit(EXIT_FAILURE);
	pnewnode->leftchild = pnewnode->rightchild = pnewnode->parent = NULL;
	return pnewnode;
}

bool Delete_BST(BSTree* pTree, ELEMTYPE val)
{
	assert(pTree != NULL);
	if (pTree->root == NULL)
		return false;
	BstNode* p = Search_BST(pTree, val);
	if (p == NULL)
		return false;
	if (p->leftchild == NULL || p->rightchild == NULL)
	{
		BstNode* cat = p->leftchild;

		if (p->parent == NULL)
			pTree->root = NULL;//防止删除的是根节点
		if (p->data < p->parent->data)
		{
			if (p->leftchild != NULL)
				p->parent->leftchild = p->leftchild;
			else
				p->parent->leftchild = p->rightchild;
		}
		else
		{
			if (p->leftchild != NULL)
				p->parent->rightchild = p->leftchild;
			else
				p->parent->rightchild = p->rightchild;
		}
		free(p);
		p = NULL;
		return true;
	}
	return false;
}

BstNode* Get_Next(BstNode* node)
{
	assert(p != NULL);
	BstNode* node = p;
	while(p->rightchild != NULL)
		p = p->leftchild;
	return p;
	BstNode* pp = node->parent;
	while (pp != NULL&&pp->data<node->data)
			pp = pp->parent;
	return pp;
}

BstNode* Get_Prior(BstNode* p)
{
	assert(p != NULL);
	BstNode* node = p;
	while (p->leftchild != NULL)
		p = p->rightchild;
	return p;
	BstNode* pp = node->parent;
	while (pp != NULL && pp->data > node->data)
		pp = pp->parent;
	return pp;
}