算法 二叉树 BST树

BST树的定义

BST树又称为：二叉排序树，二叉搜索树

• 二叉搜索树或者是一颗空树，或者是具有下列性质的二叉树

1. 每个结点都有一个作为搜索依据的关键码(key)，所有结点的关键码互不相同
2. 左子树（如果存在）上所有结点的关键码都小于根节点的关键码
3. 右子树（如果存在）上所有结点的关键码都大于根节点的关键码
4. 左子树和右子树也是二叉搜索树
   

总结：如果对一颗二叉搜索树进行中序遍历，可以按从小到大的顺序，将各结点的关键码排列起来，所以也称为二叉搜索树为二叉排序树

与大根堆与小根堆是完全不同的

BST树结构

typedef int KeyType;
typedef struct BstNode
{
	KeyType key;
	BstNode* leftchild;
	BstNode* parent;
	BstNode* rightchild; 
}BstNode,* BstTree;

BST树的创建

typedef int KeyType;
typedef struct BstNode
{
	KeyType key;
	BstNode* leftchild;
	BstNode* parent;
	BstNode* rightchild;
}BstNode,* BstTree;

BstNode* Buynode()
{
	BstNode* s = (BstNode*)malloc(sizeof(BstNode));
	if (s == NULL) exit(1);
	memset(s, 0, sizeof(BstNode));
	return s;
}
BstNode* MakeRoot(KeyType kx)
{
	BstNode* s = Buynode();
	s->key = kx;
	return s;
}
bool Insert(BstNode*& ptr, KeyType kx)
{
	if (ptr == nullptr)
	{
		ptr = MakeRoot(kx);
		return true;
	}
	BstNode* pa = nullptr;
	BstNode* p = ptr;
	while (p != nullptr && p->key != kx)
	{
		pa = p;
		p = kx < p->key ? p->leftchild : p->rightchild;  //寻找合适位置
	}
	if (p != nullptr && p->key == kx) return false;//值相同

	p = Buynode();
	p->key = kx;
	p->parent = pa;
	if (p->key < pa->key)
	{
		pa->leftchild = p;
	}
	else
	{
		pa->rightchild = p;
	}
	return true;
}
void InOrder(BstNode* ptr)
{
	if (ptr != nullptr)
	{
		InOrder(ptr->leftchild);
		cout << ptr->key << " ";
		InOrder(ptr->rightchild);
	}
}

int main()
{
	BstTree root = nullptr;
	int ar[] = { 53,17,78,9,45,65,87,23,81,94,88,100 };
	int n = sizeof(ar) / sizeof(ar[0]);
	for (int i = 0; i < n; ++i)
	{
		cout << Insert(root, ar[i]) << endl;
	}
	InOrder(root);
	return 0;
}

对BST树进行中序遍历，可得到排好序的数组

递归中序遍历

void InOrder(BstNode* ptr)
{
	if (ptr != nullptr)
	{
		InOrder(ptr->leftchild);
		cout << ptr->key << " ";
		InOrder(ptr->rightchild);
	}
}

非递归中序遍历

BstNode* First(BstNode* ptr)  //找到最小结点
{
	while (ptr != nullptr && ptr->leftchild != nullptr)
	{
		ptr = ptr->leftchild;
	}
	return ptr;
}
BstNode* Next(BstNode* ptr) //寻找下一结点
{
	if (ptr == nullptr) return nullptr;
	if (ptr->rightchild != nullptr)
	{
		return First(ptr->rightchild);
	}
	else
	{
		BstNode* pa = ptr->parent;
		while (pa != nullptr && pa->leftchild != ptr)
		{
			ptr = pa;
			pa = ptr->parent;
		}
		return pa;
	}
}
void NiceInOrder(BstNode* ptr)
{
	for (BstNode* p = First(ptr); p != nullptr; p = Next(p)) //直接进行遍历
	{
		cout << p->key << " ";
	}
	cout << endl;
}

逆向非递归中序遍历

BstNode* Last(BstNode* ptr)
{
	while (ptr != nullptr && ptr->rightchild != nullptr)
	{
		ptr = ptr->rightchild;
	}
	return ptr;
}
BstNode* Prev(BstNode* ptr)
{
	if (ptr == nullptr) return nullptr;
	if (ptr->rightchild != nullptr)
	{
		return Last(ptr->leftchild);
	}
	else
	{
		BstNode* pa = ptr->parent;
		while (pa != nullptr && pa->rightchild != ptr)
		{
			ptr = pa;
			pa = ptr->parent;
		}
		return pa;
	}
}
void RevNiceInOrder(BstNode* ptr)
{
	for (BstNode* p = Last(ptr); p != nullptr; p = Prev(p))
	{
		cout << p->key << " ";
	}
	cout << endl;
}

int main()
{
	BstTree root = nullptr;
	int ar[] = { 53,17,78,9,45,65,87,23,81,94,88,100 };
	int n = sizeof(ar) / sizeof(ar[0]);
	for (int i = 0; i < n; ++i)
	{
		cout << Insert(root, ar[i]) << endl;
	}
	//NiceInOrder(root);
	RevNiceInOrder(root);
	return 0;
}

根据前面非递归中序遍历进行小修改就可以得到逆向的中序遍历

删除结点

bool Remove(BstNode*& ptr, KeyType kx)
{
	if (ptr == nullptr) return false;
	BstNode* pa = nullptr;
	BstNode* p = ptr;
	while (p!= nullptr && p->key!=kx)  //寻找该结点
	{
		p = kx < p->key ? p->leftchild : p->rightchild;
	}
	if (p == nullptr) return false;

	//当需要删除的结点为双分支的时候
	if (p->leftchild != nullptr && p->rightchild != nullptr)
	{
		BstNode* q = First(p->rightchild); //将其替换为直接后继
		p->key = q->key; //数值替换
		p = q;
	}

	pa = p->parent;
	//处理单分支
	BstNode* child = p->leftchild != nullptr ? p->leftchild : p->rightchild;
	if (child != nullptr) child->parent = pa; //将子节点的父节点指向自己的父节点
	//处理叶子结点
	if (pa == nullptr) //删除的是根节点
	{
		ptr == child;
	}
	else
	{
		if (pa->leftchild == p)  //删除直接后继或前驱
		{
			pa->leftchild == child;  //如果p为叶子结点，则其子child必定为nullptr
		}
		else
		{
			pa->rightchild == child;
		}

	}
	free(p);
	return true;
}

当我们需要删除一个结点的时候，将该结点于其直接后继交换，将其直接后继进行删除
并根据其直接后继为单分支、双分支或叶节点分别采取不同的替换方式