数据结构(C++)： 二叉搜索树 实现篇

最新推荐文章于 2024-03-19 07:30:07 发布
最新推荐文章于 2024-03-19 07:30:07 发布
阅读量1.4k 收藏 41
点赞数 46
分类专栏： C++ 数据结构(C++) 文章标签： c++ 数据结构 二叉搜索树 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57761086/article/details/127140555
版权

目录

1.二叉搜索树概念

  (1)概念

  (2)示意图

2.二叉搜索树次要操作

  (1)二叉搜索树的查找

  (2)二叉搜索树的插入

    [1]树是空树

    [2]树不是空树

3.二叉搜索树重要操作(删除操作) 

  (1)要删除的结点有双亲

   <1>要删除的结点是双亲的左孩子

      [1]要删除的结点没有孩子结点

      [2]要删除的结点只有左孩子

      [3]要删除的结点只有右孩子

      [4]要删除的结点有左右两个孩子

   <2>要删除的结点是双亲的右孩子

      [1]要删除的结点没有孩子结点

      [2]要删除的结点只有左孩子

      [3]要删除的结点只有右孩子

      [4]要删除的结点有左右两个孩子

  (2)要删除的结点没有双亲

    [1]要删除的结点没有孩子结点

    [2]要删除的结点只有左孩子

    [3]要删除的结点只有右孩子

    [4]要删除的结点有左右两个孩子

3.二叉搜索树实现

  (1)二叉搜索树局部实现

    [1]二叉搜索树结点类

    [2]二叉搜索树成员变量

    [3]无参构造

    [4]析构函数

    [5]插入函数

    [6]查找函数

    [7]中序遍历函数

    [8]删除函数

  (2)二叉搜索树整体实现

        本文在win10系统的vs2019中验证。

1.二叉搜索树概念

  (1)概念

      二叉搜索树又称二叉排序树，它只有两种形态：

        [1]空树

        [2]满足以下性质的二叉树：

  • 若它的左子树不空，则左子树上所有结点的值都小于根节点的值
  • 若它的右子树不空，则右子树上所有结点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树

  (2)示意图

        如下是一棵二叉搜索树，左子树结点值均小于根结点，右子树结点值均大于根结点。

8dbd03493f574582b02f04fc863afe99.png

 

2.二叉搜索树次要操作

  (1)二叉搜索树的查找

        如图是一棵二叉搜索树，需要在树中找到值为9的结点，如何查找？

890bd2bdcae944809d39451f2e4488c6.png

         查找方法：[1]首先找到根结点，比较根结点与9的值，如果相等，证明找到了，返回true。

                           [2]如果根结点的值大于9，那么就去根结点的左子树中找。

                           [3]如果根结点的值小于9，那么就去根结点的右子树中找。

        这个方法会不断地向下查找，如果查到最后一个结点都没有找到，说明没有这个结点，返回false。

  (2)二叉搜索树的插入

        二叉搜索树的插入需要分情况讨论：[1]树是空树 [2]树不是空树

    [1]树是空树

        如果这棵树是空树，那么直接把要插入的元素当作根结点即可。

6c6a56d521f348bf8b8e8114e8ad9173.png

    [2]树不是空树

        如果树不是空树，那么就需要查找适合这个结点的位置。

        如图：在原二叉搜索树的基础上插入结点10，这个过程是怎样的？

        首先将10与根结点比较，10比根结点大，去根结点右子树找。右子树根结点是7，10比7大，去7的右子树找。右子树根结点是8·······，这样依次进行到9这个结点，发现10比9大，但9的右子树是空，那么就10就作为9的右孩子插入。

01635f7d706d423a85099d9b1f83f4c4.png

3.二叉搜索树重要操作(删除操作) 

        二叉搜索树的删除需要考虑很多情况，分为两大类。

        两大类：(1)要删除的结点有双亲 (2)要删除的结点无双亲

        其中(1)类还会分两类：<1>要删除的结点是双亲的左孩子 <2>要删除的结点是双亲的右孩子。

        四小类：[1]要删除的结点没有孩子结点 [2]要删除的结点只有左孩子 [3]要删除的结点只有右孩子 [4]要删除的结点有左右两个孩子

  (1)要删除的结点有双亲

   <1>要删除的结点是双亲的左孩子

      [1]要删除的结点没有孩子结点

        如图：删除0结点，此时直接删除即可

3837076e2040468592bc5f4d06e9eda9.png

      [2]要删除的结点只有左孩子

        如图：删除1结点，此时需要让1结点的双亲结点的左孩子指针指向1结点的左孩子，然后才可以删除1结点。

100ae3b36eed42caa4a8f48ae46d922e.png

      [3]要删除的结点只有右孩子

        如图：删除1结点，此时需要先让1结点的双亲结点的左孩子指针指向1结点的右孩子，然后才可以删除1结点。

6bf406de15084e88be5a32662270abf7.png

      [4]要删除的结点有左右两个孩子

        如图：删除7结点。此时的删除就比较复杂了，我们需要给要删除的结点找到一个替代结点，替代结点有两种找法：1.找要删除的结点的左子树的最大结点(也就是左子树最右侧结点) 2.找要删除的结点的右子树的最小结点(也就是右子树最左侧节点)。

        我们这里采用的是找左子树最大结点。

        需要先找到7结点的左子树中最右侧的结点，此时最右侧结点是6.5，然后把6.5的值赋给原本要删除的7结点。

        此时要删除的那个结点变成了红6.5结点，我们此时只需要删除原本的黑6.5节点即可。

58e3efb3eb2b4001b5e115dfb1a16a17.png

   <2>要删除的结点是双亲的右孩子

      [1]要删除的结点没有孩子结点

        如图：删除9结点，此时直接删除即可

f00616c54d074f20ab3c8b84a42a267c.png

 

      [2]要删除的结点只有左孩子

        如图：删除7结点，此时需要让7结点的双亲结点的右孩子指针指向7结点的左孩子，然后才可以删除7结点。

973d01658c5a4363a6d7b31bd08ef80f.png

      [3]要删除的结点只有右孩子

        如图：删除8结点，此时需要先让8结点的双亲结点的右孩子指针指向8结点的右孩子，然后才可以删除8结点。

b6bfd6917c6e46a5be615ff5c2aad4be.png

      [4]要删除的结点有左右两个孩子

        我们这里采用的是找右子树最小结点。

        如图：需要删除3结点，3结点右子树最左侧结点是4结点。将替代结点4结点的值赋给3结点，此时的3结点就变成了红4结点。然后删除替代节点黑4结点，删除替代结点的时候替代结点也可能有孩子结点，所以需要让红4结点指向替代结点的孩子结点。

609f1402a19142af8e1133b1d659b19e.png

  (2)要删除的结点没有双亲

        没有双亲结点就只能是根结点。

    [1]要删除的结点没有孩子结点

        此时只存在根结点，直接删除根结点就可。

18c39b3e67cb4e90accb19b186675bb7.png

    [2]要删除的结点只有左孩子

        如图：删除5结点。直接让5结点的左孩子当根结点，删除5结点即可。

280062ee47434163aeea5ae28ddb7ba9.png

    [3]要删除的结点只有右孩子

        如图，跟上个情况一样，让5结点的孩子结点当根结点，删除5结点即可。

dc6529b3c8594074aa63e9e1c1f4e063.png

    [4]要删除的结点有左右两个孩子

        这里采用的是找右子树最小结点。

        如图：找到根结点右子树中最左侧的结点是6，用6替换根结点，此时根结点是红6，然后删除替代结点即可。

13f6eb6d691e4aaeb843ed27f6790563.png

3.二叉搜索树实现

        为了实现的方便，我们规定二叉树中的值是唯一的，没有重复的值。

  (1)二叉搜索树局部实现

    [1]二叉搜索树结点类

        二叉搜索树中是用一个一个的结点存储数据的，因此我们需要单独为结点定义一个类。

        因为结点中可能存储各种类型的的元素，因此结点类是模板。这个类中的成员变量：指向左右孩子的指针，存储元素的value变量。成员函数只需要一个构造函数即可，构造一个空的结点。

//二叉搜索树结点类
template<typename T>
struct BSTNode {
	BSTNode<T>* left;//左孩子指针
	BSTNode<T>* right;//右孩子指针
	T value;//存储值

	//构造函数
	BSTNode(const T& _value = T())
		:value(_value)
		,left(nullptr)
		,right(nullptr)
	{}
};

    [2]二叉搜索树成员变量

        因为二叉搜索树是模板，所以不要忘记加上模板参数。同时用typedef关键字给结点类取一个别名，这样使用起来会方便很多。

        二叉搜索树的成员变量只有一个，那就是指向根结点的指针。

//二叉搜索树类
template<typename T>
class BinarySearchTree {
	//为结点类取别名
	typedef BSTNode<T> Node;
private:
	//根结点指针
	Node* root;
};

    [3]无参构造

        因为用无参构造会构造空树，因此根结点需要指向空。

//无参构造
BinarySearchTree()
	:root(nullptr)
{}

    [4]析构函数

        因为析构函数没有参数，所以需要单独设置一个销毁函数。销毁函数的参数是根结点指针，通过递归调用销毁函数，首先销毁根结点的左右孩子，最后销毁根结点自身，不要忘记将根结点指针指向空。

//析构函数
~BinarySearchTree(){
	//内部调用销毁函数
	Destroy(root);
}

//销毁函数
void Destroy(Node*& root) {
	if (root) {
		//递归调用销毁函数对该结点的左子树和右子树进行销毁
		Destroy(root->left);
		Destroy(root->right);
		//将该结点的左右子树销毁后销毁该结点自身
		delete root;
		root = nullptr;
	}
}

    [5]插入函数

        插入函数的步骤在上面已经用图片展示过了，所以这里就不多赘述了，每个步骤的意义已经用注释写上了。

//插入函数
bool Insert(const T& _value) {
	//要插入的是空树
	if (root == nullptr) {
		root = new Node(_value);
		return true;
	}

	//要插入的不是空树
	//parent保存cur的双亲
	Node* cur = root;
	Node* parent = nullptr;

	//用循环结构查找适合_value的位置
	while (cur) {
		//用parent保存cur结点
		parent = cur;
		
		//cur的值小于_value，就去cur的右子树找
		if (cur->value < _value) {
			cur = cur->right;
		}
		//cur的值大于_value，就去cur的左子树找
		else if (cur->value > _value) {
			cur = cur->left;
		}
		//cur的值等于_value，说明树中存在该结点，返回false
		else {
			return false;
		}
	}

	//能运行到这里，说明找到了合适的位置
	// 此时cur指向空，parent是cur的双亲
	//将_value元素放入cur中
	cur = new Node(_value);

	//判断_value应该存储到parent结点的左子树还是右子树
	if (parent->value < _value) {
		parent->right = cur;
	}
	else {
		parent->left = cur;
	}
	//插入成功返回true
	return true;
}

    [6]查找函数

        查找函数也比较简单，根据上文的讲解结合注释也可以很轻松地理解。

//查找函数
Node* Find(const T& _value) {
	//用cur保存根结点，因为是从根结点开始查找
	Node* cur = root;

	while (cur) {
		//cur的值小于_value，说明_value如果存在，就一定在右子树中
		if (cur->value < _value) {
			cur = cur->right;
		}
		//cur的值大于_value，说明_value如果存在，就一定在左子树中
		else if(cur->value > _value){
			cur = cur->left;
		}
		//cur的值等于_value，说明恰好找到，返回cur
		else {
			return cur;
		}
	}
	//循环体没有中途结束，说明整个树中都没找到
	//返回空
	return nullptr;
}

    [7]中序遍历函数

        中序遍历不应该让用户传递指针参数，所以需要单独进行内部实现。中序遍历的遍历顺序：左、根、右。程序的设计也是根据这个顺序进行，首先递归遍历左子树，然后打印根结点，最后递归遍历右子树。

        注意：如果读者用文末提供的代码进行测试就可以发现，中序遍历得到的结果是一个升序的序列。

//中序遍历函数
void InOrder() {
	cout << "中序遍历" << endl;
	InOrder(root);
	cout << endl;
}

//中序遍历函数内部实现
void InOrder(Node* root) {
	if(root){
		//先遍历左子树
		InOrder(root->left);
		//再访问根结点
		cout << root->value << " ";
		//最后遍历右子树
		InOrder(root->right);
	}
}

    [8]删除函数

        删除函数是一个难点，这里需要再详细说一说。

        首先需要判断是否是空树，如果是空树，就返回false，因为空树没有元素，不能删除。如果树不空，需要在书中查找是否有需要删除的这个元素，如果没有返回false。

        如果找到需要被删除的结点，cur就是被删除的结点。然后需要根据cur的孩子的情况进入不同的选择语句。

        进入不同的选择语句后，需要根据cur是否有双亲的情况再次进入不同的选择语句。

        二次进入选择语句后，再次判断cur是双亲的左孩子还是右孩子，进行不同的操作。

        在上文中通过大量图片讲解了每一种情况的处理，希望可以结合图片一起看下面的代码，同时代码中也写了相应的注释。

//删除函数
bool Erase(const T& _value) {
	//如果是空树直接返回false
	if (root == nullptr) {
		return false;
	}

	//parent用来保存cur的双亲
	Node* cur = root;
	Node* parent = nullptr;

	//先查找对应结点
	while (cur) {
		if (cur->value == _value) {
			break;
		}
		else if (cur->value > _value) {
			parent = cur;
			cur = cur->left;
		}
		else {
			parent = cur;
			cur = cur->right;
		}
	}

	//节点不存在，直接返回false
	if (cur == nullptr) {
		return false;
	}

	//结点存在
	//只有右孩子或者是叶子结点
	if (cur->left == nullptr) {

		//双亲结点是空，cur是根
		//让cur的右孩子作为新的根结点
		if (parent == nullptr) {
			root = cur->right;
		}

		//cur有双亲，cur不是根
		else {
			//cur是叶子节点
			//cur是parent的左孩子
			//让parent的左孩子指针指向cur的右孩子
			if(cur == parent->left){
				parent->left = cur->right;
			}
			//cur是parent的右孩子
			//让parent的右孩子指针指向cur的右孩子
			else {
				parent->right = cur->right;
			}
		}
	}
	//只有左孩子
	else if (cur->right == nullptr) {
		//cur是根
		//让cur的左孩子作为新的根结点
		if (parent == nullptr) {
			root = cur->left;
		}
		//cur不是根
		else {
			//cur是parent的左孩子
			//让parent的左孩子指针指向cur的右孩子
			if (cur == parent->left) {
				parent->left = cur->left;
			}
			//cur是parent的右孩子
			//让parent的右孩子指针指向cur的右孩子
			else {
				parent->right = cur->left;
			}
		}
	}
	//cur有两个孩子
	else {
		//假设在右子树找替代节点
		//delNode保存cur的右子树的根结点
		Node* delNode = cur->right;
		//parnet保存delNode的双亲
		parent = cur;

		//只要delNode还有左孩子就一直循环
		//当delNode没有左孩子了
		//那么它的双亲结点parent就是最左侧的结点了
		while (delNode->left) {
			parent = delNode;
			delNode = delNode->left;
		}
		//把替代节点中的值赋值给被删除节点
		cur->value = delNode->value;
		
		//替代结点如果是parent的左孩子
		//就让parent的左孩子指针指向替代节点的右孩子
		//因为替代节点虽然没有左孩子
		//但可能有右孩子
		if (delNode == parent->left) {
			parent->left = delNode->right;
		}
		else {
			parent->right = delNode->right;
		}
		//用cur指向替代节点
		cur = delNode;
	}
	//删除替代结点
	delete cur;
	//结点删除成功，返回true
	return true;
}

  (2)二叉搜索树整体实现

#include "iostream"
using namespace std;

//二叉搜索树结点类
template<typename T>
struct BSTNode {
	BSTNode<T>* left;//左孩子指针
	BSTNode<T>* right;//右孩子指针
	T value;//存储值

	//构造函数
	BSTNode(const T& _value = T())
		:value(_value)
		,left(nullptr)
		,right(nullptr)
	{}
};


//二叉搜索树类
template<typename T>
class BinarySearchTree {
	//为结点类取别名
	typedef BSTNode<T> Node;
private:
	//根结点指针
	Node* root;
public:
	//无参构造
	BinarySearchTree()
		:root(nullptr)
	{}
	
	//析构函数
	~BinarySearchTree(){
		//内部调用销毁函数
		Destroy(root);
	}

	//销毁函数
	void Destroy(Node*& root) {
		if (root) {
			//递归调用销毁函数对该结点的左子树和右子树进行销毁
			Destroy(root->left);
			Destroy(root->right);
			//将该结点的左右子树销毁后销毁该结点自身
			delete root;
			root = nullptr;
		}
	}


	//插入函数
	bool Insert(const T& _value) {
		//要插入的是空树
		if (root == nullptr) {
			root = new Node(_value);
			return true;
		}

		//要插入的不是空树
		//parent保存cur的双亲
		Node* cur = root;
		Node* parent = nullptr;

		//用循环结构查找适合_value的位置
		while (cur) {
			//用parent保存cur结点
			parent = cur;
			
			//cur的值小于_value，就去cur的右子树找
			if (cur->value < _value) {
				cur = cur->right;
			}
			//cur的值大于_value，就去cur的左子树找
			else if (cur->value > _value) {
				cur = cur->left;
			}
			//cur的值等于_value，说明树中存在该结点，返回false
			else {
				return false;
			}
		}

		//能运行到这里，说明找到了合适的位置
		// 此时cur指向空，parent是cur的双亲
		//将_value元素放入cur中
		cur = new Node(_value);

		//判断_value应该存储到parent结点的左子树还是右子树
		if (parent->value < _value) {
			parent->right = cur;
		}
		else {
			parent->left = cur;
		}
		//插入成功返回true
		return true;
	}

	//查找函数
	Node* Find(const T& _value) {
		//用cur保存根结点，因为是从根结点开始查找
		Node* cur = root;

		while (cur) {
			//cur的值小于_value，说明_value如果存在，就一定在右子树中
			if (cur->value < _value) {
				cur = cur->right;
			}
			//cur的值大于_value，说明_value如果存在，就一定在左子树中
			else if(cur->value > _value){
				cur = cur->left;
			}
			//cur的值等于_value，说明恰好找到，返回cur
			else {
				return cur;
			}
		}
		//循环体没有中途结束，说明整个树中都没找到
		//返回空
		return nullptr;
	}

	//中序遍历函数
	void InOrder() {
		cout << "中序遍历" << endl;
		InOrder(root);
		cout << endl;
	}

	//中序遍历函数内部实现
	void InOrder(Node* root) {
		if(root){
			//先遍历左子树
			InOrder(root->left);
			//再访问根结点
			cout << root->value << " ";
			//最后遍历右子树
			InOrder(root->right);
		}
	}

	//删除函数
	bool Erase(const T& _value) {
		//如果是空树直接返回false
		if (root == nullptr) {
			return false;
		}

		//parent用来保存cur的双亲
		Node* cur = root;
		Node* parent = nullptr;

		//先查找对应结点
		while (cur) {
			if (cur->value == _value) {
				break;
			}
			else if (cur->value > _value) {
				parent = cur;
				cur = cur->left;
			}
			else {
				parent = cur;
				cur = cur->right;
			}
		}

		//节点不存在，直接返回false
		if (cur == nullptr) {
			return false;
		}

		//结点存在
		//只有右孩子或者是叶子结点
		if (cur->left == nullptr) {

			//双亲结点是空，cur是根
			//让cur的右孩子作为新的根结点
			if (parent == nullptr) {
				root = cur->right;
			}

			//cur有双亲，cur不是根
			else {
				//cur是叶子节点
				//cur是parent的左孩子
				//让parent的左孩子指针指向cur的右孩子
				if(cur == parent->left){
					parent->left = cur->right;
				}
				//cur是parent的右孩子
				//让parent的右孩子指针指向cur的右孩子
				else {
					parent->right = cur->right;
				}
			}
		}
		//只有左孩子
		else if (cur->right == nullptr) {
			//cur是根
			//让cur的左孩子作为新的根结点
			if (parent == nullptr) {
				root = cur->left;
			}
			//cur不是根
			else {
				//cur是parent的左孩子
				//让parent的左孩子指针指向cur的右孩子
				if (cur == parent->left) {
					parent->left = cur->left;
				}
				//cur是parent的右孩子
				//让parent的右孩子指针指向cur的右孩子
				else {
					parent->right = cur->left;
				}
			}
		}
		//cur有两个孩子
		else {
			//假设在右子树找替代节点
			//delNode保存cur的右子树的根结点
			Node* delNode = cur->right;
			//parnet保存delNode的双亲
			parent = cur;

			//只要delNode还有左孩子就一直循环
			//当delNode没有左孩子了
			//那么它的双亲结点parent就是最左侧的结点了
			while (delNode->left) {
				parent = delNode;
				delNode = delNode->left;
			}
			//把替代节点中的值赋值给被删除节点
			cur->value = delNode->value;
			
			//替代结点如果是parent的左孩子
			//就让parent的左孩子指针指向替代节点的右孩子
			//因为替代节点虽然没有左孩子
			//但可能有右孩子
			if (delNode == parent->left) {
				parent->left = delNode->right;
			}
			else {
				parent->right = delNode->right;
			}
			//用cur指向替代节点
			cur = delNode;
		}
		//删除替代结点
		delete cur;
		//结点删除成功，返回true
		return true;
	}
};

int main(){
	BinarySearchTree<int> bt;
	int arr[] = {6,7,8,9,2,3,0,1,4,5};
	int size = 10;
	int i = 0;
	while (size) {
		bt.Insert(arr[i]);
		i++;
		size--;
	}
	bt.Erase(6);
	bt.Erase(3);
	bt.InOrder();
}

 

 

爱喝酸奶！
关注
  • 46
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 31
    评论
专栏目录
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
二叉搜索树的实现与应用
11-04
本资源是博文【数据结构】二叉搜索树的完整源代码文件，包含K模型搜索树的递归、非递归实现；KV模型搜索树的递归和非递归实现。以及两种模型的测试和应用，主要体现在单词翻译、统计次数、检查单词拼写。可结合以下...
C++数据结构——二叉树
caijiandl的博客
07-31 3363
二叉树 项目 项目 项目 项目1 项目2 项目3 计划任务 完成任务 二叉搜索树 二叉搜索树是二叉树的一种特殊形式。 二叉搜索树具有以下性质：每个节点中的值必须大于（或等于）其左侧子树中的任何值，但小于（或等于）其右侧子树中的任何值。 我们将在本章中更详细地介绍二叉搜索树的定义，并提供一些与二叉搜索树相关的习题。 完成本卡片后，你将： 理解二叉搜索树的特性 熟悉在二叉搜索树中的基本操作 理解高度平衡二叉搜索树的概念 二叉搜索树的定义 **二叉搜索树（BST）**是二叉树的一种
【C++ STL】-- 二叉搜索树
weixin_64609308的博客
11-25 2136
详细配图讲解：搜索二叉树的构建与函数接口实现
C++实现搜索二叉树(Binary Search Tree)
最新发布
2301_81261654的博客
03-19 337
对只有一个key的二叉搜索树稍加改造，这样一个key,value模型就完成了，这种KV模型存在的意义便是，可以通过找到key所在的位置从而找到该位置的val，这个模型的运用场景有很多，以下有一段示例代码。另外还可以利用KV模型进行计数操作，记录key出现的次数，示例代码如下所示。以上便是关于搜素二叉树的实现和运用，希望能够班帮助到大家。
C/C++数据结构（十）—— 二叉查找树
热门推荐
Edison's 小宇宙
01-13 2万+
二叉查找树（Binary Search Tree），也称二叉排序树或二叉搜索树。
二叉查找树（二分搜索树）的C++方法实现
01-20
资源内容：完整的二叉查找树C++头文件，包括运算符重载，bst类构造器、bst类析构器、destroy()、size()、insert()，迭代器类的声明与实现，++运算符重载（前置、后置）、--运算符重载、*运算符重载、！=运算符重载、...
二叉搜索树实现与测试.zip(悉尼大学数据结构作业)
04-27
实现了插入，查找大于某值的最小值，删除节点，右旋。 悉尼大学作业，通过全部测试用例。
BST_fanli.zip.二叉搜索树源码
04-10
在C++中实现二叉搜索树，通常会定义一个结构体或类来表示树节点，包括节点的键、左右子节点的指针，以及可能的附加信息，如节点的父节点指针。以下是一个基本的二叉搜索树节点的C++实现： ```cpp struct Node { ...
二叉排序树C++实现
08-10
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉排序树中...
二叉查找树的C++实现
云飞扬
03-25 454
1.基本概念：二叉查找树是一种有序排列的二叉树，在二叉查找树中，每个节点的左子树的所有元素的值小于该节点的元素的值，而右子树的每个节点的值都大于该节点的值，如果对二叉查找树进行中序遍历，将按照从小到大的顺序输出树里面的所有元素。 2.头文件：BinatyTree.h #ifndef _TREE_H #define _TREE_H #include<iostream> using namespace std; struct TreeNode; typedef int Elemen
【数据结构】二叉查找树
wakawaka
12-03 345
建树 树节点的存储方式与普通的二叉树相似，用结构体存储，其中一个int变量存储数据，两个指针指向左右儿子。 读入一个新数据，从根节点开始寻找，大于当前节点则继续寻找右子树，右子树为空则直接插入，小于当前节点则继续寻找左子树，左子树为空则直接插入。 注： 初始数据要求随机数，为了产生真正意义上的“随机数”，使用时间作为随机数种子。 查找 从根节
c++:二叉搜索树BinarySortTree
qq_43745617的博客
05-13 270
文章目录二叉搜索树BinarySortTree1.二叉搜索树概念2.二叉搜索树操作（1）查找（2）插入节点（3）删除节点3.二叉搜索树的代码实现（1）功能实现（2）测试 二叉搜索树BinarySortTree 1.二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 如图所示 二叉搜索树最大的功能便是搜索；一般来讲它比顺
C++二叉搜索树
weixin_43828675的博客
03-16 153
二叉搜索树（Binary Search Tree，又称BST）。任意一个节点的左子树的值一定小于根节点的值，右子树的值一定大于根节点的值。 二叉搜索树的中序变量递增！以Leetcode第98题为例: 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: tr
C++搜索二叉树的查找、插入、删除
MilkLeong的博客
02-15 2324
以一年十二月的英文缩写为键值而产生二叉搜索树，查找其中的Feb值，及输出最小、最大值： 红框以内为输出，红框以外为输入。
【C++】二叉搜索树
Suk_god的博客
05-22 1221
1、二叉搜索树的概念  二叉搜索树又称二叉排序树，它可以是一颗空树，亦可以是一颗具有如下性质的二叉树：   ①若根节点的左子树不为空，则左子树上的所有节点的值域都小于根节点的值   ②若根节点的右子树不为空，则右子树上的所有节点的值域都大于根节点的值   ③根节点的左右子树分别也是一颗二叉搜索树 例如下面的这棵二叉树就是一棵二叉搜索树： 注意：判定一棵二叉树是否为二叉搜索树一定要紧扣二叉搜索树的概念~ 2、二叉搜索树的操作 声明：该文章讨论的是二叉搜索树中节点值唯一的情况。 二叉搜索树的查找 对于查找部分
二叉搜索树的实现
wjhdd的博客
10-23 402
首先我们先来看看二叉搜索树的性质： 1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。 2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。 3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。 4. 左右子树都是二叉搜索树。 首先来看看二叉搜索树的插入： 1：首先判断树是否为空，为空就new新节点，放入
# C++用一个函数解决二叉树节点查找、求高度、求父节点
qq_42361182的博客
01-06 4063
C++用一个函数解决二叉树节点查找、求高度、求父节点 写代码的原因和思路： 原因：网上好多关于二叉树的节点查找、求高度、求父节点都是分开的，这里推荐一种合体式的解决方法。 思路：首先，以下代码都是在已经成功创建一棵二叉树的情况下进行的。 引导：首先是节点查找。只需要在使用先序、中序、后序遍历的任何一种方法的时候，将访问函数visit()设置为比对即可： 这里以先序遍历为例子： 查找节点 void ...
C++STL 二叉搜索树
09-06
C++ STL中没有直接提供二叉搜索树的实现，但STL中有一些关于树的容器，比如set和map，它们底层的实现就是基于红黑树（一种平衡二叉搜索树）的。你可以使用这些容器来实现二叉搜索树的功能。关于二叉搜索树的一些知识...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 31
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值