二叉搜索树基本数据结构实现

最新推荐文章于 2020-06-15 18:33:25 发布

Tander_Tang

最新推荐文章于 2020-06-15 18:33:25 发布

阅读量464

点赞数 1

分类专栏： C++基础数据结构

本文链接：https://blog.csdn.net/tander_tang/article/details/50802648

版权

数据结构同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

C++基础

8 篇文章 0 订阅

订阅专栏

二叉搜索树中一个结点包含3个指针left,right, prev和一个卫星数据key。这三个指针分别指向左儿子，右儿子，父节点。如果孩子结点和父亲结点不存在，相应指针为空。根结点的prev指向空。

1)遍历（中序遍历，先序遍历，后续遍历）

2)查找一个关键字，返回该关键字的结点指针

3).返回最大关键字最小关键字结点指针

4)寻找关键字key的后继结点

5)插入关键字key

6)构建一颗二叉搜索树

7)删除关键字key

1.遍历之中序遍历:递归中序遍历比较简单不多哆嗦。中序遍历非递归方法：首先需要一个栈来保存待遍历的结点：

a.先将根结点T=root压入栈S中

b.若结点T不空或者栈不空，将结点T沿途的左儿子全部压入栈中

c.栈顶元素T=S.top()出栈并访问之，如果T的右儿子存在，则将T右儿子进栈，然后T=T->right

d.重复步骤b

2.查找一个关键字key的方法：首先从树根开始比较。若key==x.key则找到，若key>x.key，则含关键字key的结点在x的右子树中，否则在左字树中。未找到则返回NULL。

3.返回最大最小元素：根据二叉搜索树性质可知，最大元素一定在树的最右端(该结点没有右儿子)，最小结点一定在树的最左端(该结点没有左儿子)。

4.寻找关键字key的后继结点。后继结点：一个结点x的后是大于x->key的最小关键字的结点。方法：如果结点x的右子树非空，x的后继一定是x右子树中最左的结点(右子树中key值最小结点)，若x的右儿子不存在。则x的后继就要向上找，设y是向上寻找中移动的结点，直到遇到y是y父节点的左儿子为止，此时的y的父节点就是x的后继。

5.插入关键字key，先找到插入的位置（一定是某个叶节点处），然后修改指针插入。下面是递归函数代码(后面有非递归代码)

<span style="font-size:12px;">BST* Insert(BST *BT, int key){    /*此代码中没有prev指针*/
	if (!BT){  //找到啦要插入的位置
		BT = new Tree; /*生成结点*/
		BT->key = key;//插入
		BT->left = BT->right = NULL;
	}
	else if (key > BT->key) 
		BT->right = Insert(BT->right, key);  //递归插入到左子树
	else if (key < BT->key)
		BT->left = Insert(BT->left,key);     //插入到右子树
	return BT;                                   //有相等的数就不用插入了
}</span>

6.构建二叉搜索树就是不断地插入关键字

7.删除相对来说有点麻烦；分为四种情况，要删除的结点无儿子，只有左儿子，只有右儿子，同时有左右儿子。递归代码如下：

<span style="font-size:12px;">template<typename T>
Node<T>* Delete(Node<T>*Root, T key){
	Node<T>*x = nullptr;
	if (!Root)
		return nullptr;                          //空指针无法删除
	if (key > Root->key){                        //右子树中删除 
		x = Delete(Root->right, key);
		Root->right = x;
		if (x)                                  //有可能x为空，要注意
			x->prev = Root;
	}
	else if (key < Root->key){                   //左子树中删除
		x = Delete(Root->left, key);
		Root->left = x;
		if (x)                                   //有可能x为空，要注意
	    	x->prev = Root;
	}
	else{                                        //找到了要删除的结点
		x = Root;
		if (!Root->left&&!Root->right)           //没有儿子
			Root = nullptr;
		else if (!Root->left){                   //只有右儿子
			Root = Root->right;
			if (!x->prev)                        //x是根结点
				Root->prev = nullptr;
			else if (x->prev->right == x)        //x是右儿子
				x->prev->right = Root;
			else                                 //x是左儿子
				x->prev->left = Root;
			Root->prev = x->prev;
			delete x;
		}
		else if (!Root->right){                 //只有左儿子
			Root = Root->left;
			if (!x->prev)                        //x是根结点
				Root->prev = nullptr;
			else if (x->prev->right == x)        //x是右儿子
				x->prev->right = Root;
			else                               //x是左儿子
				x->prev->left = Root;
			Root->prev = x->prev;
			delete x;
		}
		else{                                //两个儿子都有
			x = x->right;
			while (x->left)
				x = x->left;                //向左找到替换的结点
			Root->key = x->key;             //卫星数据覆盖
			Node<T>*y = Delete(Root->right, x->key);  //在Root右子树删除x->key
			if (y)                            //漏掉可能异常
		     	y->prev = Root;
			Root->right = y;
		}
	}
	return Root;
}
</span>

以下是二叉搜索树基本数据结构非递归的C++实现。注意模板类的定义和实现在都包含在头文件中。

/*bintree.head*/
#pragma once
#include<iostream>
#include<stack>
using namespace std;
template<typename T>
struct Node{
	T key;
	Node<T>*left = nullptr, *right = nullptr, *prev = nullptr;
};
template<typename T>
class BinTree{
private:
	Node<T>* root;
	int totalNode_; 
	void Transplant(Node<T>*u,Node<T>*v);
public:
	BinTree<T>(){ root = nullptr; totalNode_ = 0; }
	Node<T>*getRoot()const{ return root; }
	int getNumberOfNode()const{ return totalNode_; }
	void insertKey(T const &key);
	void creatBinTree(T const *a, int const &n);
	void inorderPrint();
	Node<T>* findKey(T const &key);                      
	bool deleteKey(T const &key);                               
	Node<T>* treeMaxMum();
	Node<T>* treeMinMum();
	Node<T>* treeSuccessor(Node<T>*z); 
};

template <typename T>
void BinTree<T>::insertKey(T const &key){
	Node<T>* y = new Node<T>;              //申请空间
	y->key = key;
	y->left = y->right = y->prev = NULL;   //初始化指针
	if (!root){                            //插入到头结点
		root = y;
		return;
	}
	Node<T>* x = root;
	Node<T>* X_Prev = nullptr;             //表示x的前驱
	while (x != nullptr){
		X_Prev = x;
		if (key > x->key)
			x = x->right;
		else
			x = x->left;
	}                                     //将y插入在X_Prev后面
	y->prev = X_Prev;
	if (key > X_Prev->key)
		X_Prev->right = y;
	else
		X_Prev->left = y;
	totalNode_++;
}

template<typename T>
void BinTree<T>::inorderPrint(){
	stack<Node<T>*> S;
	Node<T>*nowNode = root;
	while (nowNode || !S.empty()){
		while (nowNode){    //沿途左儿子全部压入栈
			S.push(nowNode);
			nowNode = nowNode->left;
		}
		if (!S.empty()){
			nowNode = S.top();
			S.pop();        //顶元素出栈
			cout << nowNode->key << "  ";
			nowNode = nowNode->right;    //转向右儿子
		}
	}
	cout << endl;
}

template <typename T>
void BinTree<T>::creatBinTree(T const *a, int const &n){
	int i;
	for (i = 0; i < n; i++)
		insertKey(a[i]);
}

template <typename T>
Node<T>* BinTree<T>::findKey(T const &key){
	Node<T>*x = root;
	while (x){
		if (key>x->key)    //比当前节点大，则一定在当前节点右子树
			x = x->right;
		else if (key < x->key)  //小则在左子树
			x = x->left;
		else
			break;            //相等时即为找到
	}
	return x;                 //找到就返回此节点，否则返回空
}

template<typename T>
Node<T>* BinTree<T>::treeMaxMum(){
	Node<T>*x = root;
	while (x->right != nullptr){
		x = x->right;
	}
	return x;
}

template<typename T>
Node<T>* BinTree<T>::treeMinMum(){
	Node<T>* x = root;
	while (x->left != nullptr){
		x = x->left;
	}
	return x;
}

template<typename T>
Node<T>* BinTree<T>::treeSuccessor(Node<T>* z){
	Node<T>*x = z;
	if (x->right) {      //如果有右子树，则一定是右子树的最小结点
		x = x->right;
		while (x->left) x = x->left;
		return x;
	}
	/*否则一定在x的有左孩子的最低层祖先*/
	Node<T>*y = x->prev;
	while (y&&x != y->left){    //向上寻找
		x = y;
		y = x->prev;
	}
	return y;
}

template<typename T>
void BinTree<T>::Transplant(Node<T>*u, Node<T>*v){//用使用根结点为v的子树替代根结点为u的子树
	if (!u->prev)                                 //u是总的树根
		root = v;
	else if (u->prev->right == u)                 //u是右儿子
		u->prev->right = v;
	else                                          //u是左儿子
		u->prev->left = v;
	if (v != nullptr)                               //空间点单独处理
		v->prev = u->prev;
}

template<typename T>
bool BinTree<T>::deleteKey(T const &key){
	Node<T>*DeleteNode = findKey(key);
	if (!DeleteNode)
		return false;
	if (!DeleteNode->left)                        //如果没有左儿子或者没有儿子
		Transplant(DeleteNode, DeleteNode->right); //直接用右子树代替
	else if (!DeleteNode->right)                  //如果没有右儿子
		Transplant(DeleteNode, DeleteNode->left);  //直接用左子树代替
	else{                                         //同时有左儿子和右儿子
		Node<T>*y = DeleteNode->right;            //寻找右边关键字最小的结点
		while (y->left)
			y = y->left;                          //沿路向左找到来替换的儿子结点y
		if (y != DeleteNode->right){              //如若顶替的结点不是要删除结点的右儿子
			Transplant(y, y->right);
			y->right = DeleteNode->right;
			DeleteNode->right->prev = y;         /*这部分if语句是将结点y变为待替换子树结点的根*/
		}
		Transplant(DeleteNode, y);               //完成右边子树代替
		y->left = DeleteNode->left;                //处理DeleteNode左边子树
		DeleteNode->left->prev = y;
	}
	return true;
}</span>

/*源.cpp*/
#include"binTree.h"
int main(){
	/*测试*/
    char a[8] = { 'i','d','y','b', 's','h','c','f'};
	BinTree<char>NewTree;
	NewTree.creatBinTree(a,8);  //构建二叉搜索树
	NewTree.inorderPrint();

	Node<char>*pos = NewTree.findKey('h');
	cout << pos->key << endl;

	pos = NewTree.treeMinMum();
	cout << pos->key << endl;

	pos = NewTree.findKey('c');
	pos = NewTree.treeSuccessor(pos);
	cout << pos->key << endl;

    NewTree.insertKey('a');
	NewTree.inorderPrint();

	NewTree.deleteKey('b');   
	NewTree.inorderPrint();
	return 0;
}

Tander_Tang

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二叉搜索树基本数据结构实现

二叉搜索树基本数据结构实现，非递归与递归。二叉搜索树中一个结点包含3个指针left,right, prev和一个卫星数据key。这三个指针分别指向左儿子，右儿子，父节点。如果孩子结点和父亲结点不存在，相应指针为空。根结点的prev指向空。 1）遍历（中序遍历，先序遍历，后续遍历） 2）查找一个关键字，返回该关键字的结点指针 3).返回最大关键字最小关键字结点指针 4)寻找关键字key的后继结点
复制链接

扫一扫