[C++](17)数据结构：二叉搜索树的操作与实现

已于 2022-10-03 10:59:29 修改
阅读量444 收藏 7
点赞数 7
分类专栏： C++学习 数据结构 文章标签： 数据结构 c++ 算法 后端 开发语言
于 2022-07-29 16:38:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CegghnnoR/article/details/126058989
版权

文章目录

概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：

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

操作

如图是一棵二叉搜索树：

img

  1. 查找：如要找7，则可以按路径 8-3-6-7 找到，查找次数不大于二叉树深度。
  2. 删除：找到要删除的结点，要保证删除后依然是一棵二叉搜索树。
  3. 插入：从上往下找，将一个带有新的值的结点插入到合适的位置。本文讲的二叉搜索树是不支持重复数据的版本。

性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

同一组数据，采用不同的插入顺序，得到的二叉搜索树的结构是不一样的。

img

最优情况：二叉搜索树为完全二叉树（或者接近完全二叉树），其平均比较次数为： log ⁡ 2 n \log_2n log2​n

最差情况：二叉搜索树退化为单支树（或者类似单支），其平均比较次数为： n 2 \frac n2 2n​

退化成单支树的二叉搜索树性能较低，那么能否对其进行干预，保持数的平衡呢？这个需要我们后续学习了AVL树和红黑树来解决。

实现

框架

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	K _key;

	BSTreeNode(const K& key)
		: _left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:

private:
	Node* _root = nullptr;
};

插入

迭代写法

  • 若插入 key 值，则从根结点向下找，key 比结点大，则往右子树找，比结点小，则往左子树找，直到找到空结点，然后将 key 结点接上去。
  • 接结点需要结点位置的父结点，所以定义一个 cur 和一个 parent 指针。
  • 遇到相同的元素直接返回 false，不插入，我们实现的是不支持重复数据的二叉搜索树。
bool Insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}

	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else return false;
	}
	cur = new Node(key);
	if (parent->_key < key)
		parent->_right = cur;
	else
		parent->_left = cur;
	return true;
}

为了方便查看结果，这里写个递归的中序遍历：

因为递归函数需要传入根结点，但是外部无法访问内部的 _root 这里的解决方案是，

中序遍历的递归函数作为子函数 _Inorder 设为私有，对外提供函数接口 Inorder

public:
	void InOrder()
	{
		_InOrder(_root);
	}

private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << ' ';
		_InOrder(root->_right);
	}

中序遍历的结果就是数据的升序排列。

测试：

void TestBSTree()
{
	BSTree<int> t;
	int a[] = { 8,3,1,10,6,4,7,14,13 };
	for (auto e : a)
	{
		t.Insert(e);
	}
	t.InOrder();
}
//结果：1 3 4 6 7 8 10 13 14

递归写法

public:
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}
private:
	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key < key)
			return _InsertR(root->_right, key);
		else if (root->_key > key)
			return _InsertR(root->_left, key);
		else
			return false;
	}

逻辑看起来很简单，不过这个写法妙就妙在参数 Node*& root ，当 root == nullptr，也就是找到要插入的位置时，root 就是父结点的左/右指针的别名，root = new Node(key); 就直接把结点成功连接上去了。而不需要额外的 parent 参数。

查找

迭代写法

bool Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
			cur = cur->_right;
		else if (cur->_key > key)
			cur = cur->_left;
		else
			return true;
	}
	return false;
}

递归写法

public:
	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}
private:
	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
			return _FindR(root->_right, key);
		else if (root->_key > key)
			return _FindR(root->_left, key);
		else
			return true;
	}

删除

迭代写法

删除结点要保证删除后仍是二叉搜索树，分三种情况：

  1. 要删除的结点没有孩子：可以直接删除
  2. 要删除的结点有一个孩子：删除该结点后令它的父结点指向它的孩子结点
  3. 要删除的结点有两个孩子：替换法，把要删除的结点和它左子树的最大结点或右子树的最小结点替换，然后按1、2两种情况删除被替换的结点。
bool Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		//寻找要删除的结点
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else //找到要删除的结点
		{	
			//有一个孩子或没有孩子(左为空或右为空，包括叶子结点)
			if (cur->_left == nullptr) //只有右孩子
			{
				if (cur == _root) //特殊判断，删除根结点
				{
					_root = cur->_right;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
				cur = nullptr;
			}
			else if (cur->_right == nullptr) //只有左孩子
			{
				if (cur == _root) //特殊判断，删除根结点
				{
					_root = cur->_left;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
				cur = nullptr;
			}
			else //有两个孩子
			{
				//这里选择找右子树的最小结点，其可能有右孩子，删除的时候需要其父结点
				Node* minParent = cur;
				Node* minRight = cur->_right;
				while (minRight->_left) //找右子树的最小结点
				{
					minParent = minRight;
					minRight = minRight->_left;
				}
				cur->_key = minRight->_key; //覆盖要删除的值
				//注意判断minRight是父结点的左孩子还是右孩子
				//因为minRight可能是右子树的根结点，此时就是右孩子，不是根结点，则是左孩子
				if (minParent->_left == minRight)
				{
					minParent->_left = minRight->_right;
				}
				else
				{
					minParent->_right = minRight->_right;
				}
				delete minRight;
			}
			return true;
		}
	}
	return false;
}

尤其要注意第三种情况，如下图：

  • 删除3，则是用其右子树的4去替换，最后直接删除6的左结点4。
    • 如果4有个右孩子5，则5需要接到6的左子树上，然后将4删除
  • 删除8，则是用其右子树的根结点的值10去替换，然后将14接到8的右子树上

img

递归写法

public:
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
private:
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else //删除
		{
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
				delete del;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
				delete del;
			}
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
				swap(root->_key, minRight->_key);
				return _EraseR(root->_right, key);
			}
		}
	}

类似于插入的递归写法，这里我们也用了指针的引用 Node*& root 。

  • 重点在于删除逻辑，root 就是父结点的左/右指针的引用，具体是左还是右，已经隐含在里面了，免去了判断它是左孩子还是右孩子的步骤，根结点的情况也不用特别判断。
  • 对于有两个孩子的结点删除，依然要先找右子树的最小结点。然后使用 swap 去替换，注意，迭代写法是覆盖，和这里不同。目的是为了接下来能够通过递归在右子树中找到值被替换成 key 的结点，该结点必没有左孩子，会按照前两种情况进行删除。

构造和析构、赋值重载

拷贝构造需要深拷贝，前序构造，后序析构，详关于其递归写法的详细讲解：[数据结构二叉树的遍历_世真的博客-CSDN博客](https://blog.csdn.net/CegghnnoR/article/details/124234117)

private:
	void DestroyTree(Node* root)
	{
		if (root == nullptr)
			return;
		DestroyTree(root->_left);
		DestroyTree(root->_right);
		delete root;
	}

	Node* CopyTree(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* copyNode = new Node(root->_key);
		copyNode->_left = CopyTree(root->_left);
		copyNode->_right = CopyTree(root->_right);
		return copyNode;
	}
public:
	BSTree() = default; //C++11语法，强制编译器生成默认构造

	BSTree(const BSTree<K>& t)
	{
		_root = CopyTree(t._root);
	}

	~BSTree()
	{
		DestroyTree(_root);
		_root = nullptr;
	}

赋值重载可以采用现代写法：

	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

完整代码

#pragma once
#include <iostream>
using namespace std;

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	K _key;

	BSTreeNode(const K& key)
		: _left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
private:
	void DestroyTree(Node* root)
	{
		if (root == nullptr)
			return;
		DestroyTree(root->_left);
		DestroyTree(root->_right);
		delete root;
	}

	Node* CopyTree(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* copyNode = new Node(root->_key);
		copyNode->_left = CopyTree(root->_left);
		copyNode->_right = CopyTree(root->_right);
		return copyNode;
	}
public:
	BSTree() = default;

	BSTree(const BSTree<K>& t)
	{
		_root = CopyTree(t._root);
	}

	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

	~BSTree()
	{
		DestroyTree(_root);
		_root = nullptr;
	}

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else return false;
		}
		cur = new Node(key);
		if (parent->_key < key)
			parent->_right = cur;
		else
			parent->_left = cur;
		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
	}

	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
				cur = cur->_right;
			else if (cur->_key > key)
				cur = cur->_left;
			else
				return true;
		}
		return false;
	}

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			//寻找要删除的结点
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else //找到要删除的结点
			{	
				//有一个孩子或没有孩子(左为空或右为空，包括叶子结点)
				if (cur->_left == nullptr) //只有右孩子
				{
					if (cur == _root) //特殊判断，删除根结点
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					cur = nullptr;
				}
				else if (cur->_right == nullptr) //只有左孩子
				{
					if (cur == _root) //特殊判断，删除根结点
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					cur = nullptr;
				}
				else //有两个孩子
				{
					//这里选择找右子树的最小结点，其可能有右孩子，删除的时候需要其父结点
					Node* minParent = cur;
					Node* minRight = cur->_right;
					while (minRight->_left) //找右子树的最小结点
					{
						minParent = minRight;
						minRight = minRight->_left;
					}
					cur->_key = minRight->_key; //覆盖要删除的值
					//注意判断minRight是父结点的左孩子还是右孩子
					//因为minRight可能是右子树的根结点，此时就是右孩子，不是根结点，则是左孩子
					if (minParent->_left == minRight)
					{
						minParent->_left = minRight->_right;
					}
					else
					{
						minParent->_right = minRight->_right;
					}
					delete minRight;
				}
				return true;
			}
		}
		return false;
	}

	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}

	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

private:
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
				delete del;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
				delete del;
			}
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
				swap(root->_key, minRight->_key);
				return _EraseR(root->_right, key);
			}
		}
	}

	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key < key)
			return _InsertR(root->_right, key);
		else if (root->_key > key)
			return _InsertR(root->_left, key);
		else
			return false;
	}

	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
			return _FindR(root->_right, key);
		else if (root->_key > key)
			return _FindR(root->_left, key);
		else
			return true;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << ' ';
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptr;
};

应用

  1. K模型：K模型只有 key 作为关键码，结构中只需要存储 key 即可，关键码即为需要搜索到的值。我们刚刚写的就属于 K 模型的二叉搜索树。

    如给一个单词，判断该单词是狗拼写正确，具体方式如下：

    • 以词库中每个单词作为 key，构建一棵二叉搜索树
    • 在二叉搜索树中搜索该单词是否存在， 存在则拼写正确，否则拼写错误。

  2. KV模型：每一个关键码 key，都有与之对应的值 value，即 <key, value> 键值对。

    • 如英汉词典中的英文与中文形成对应关系，通过英文可以快速找到其对应的中文，英文单词与其对应的中文 <word, chinese> 就构成一种键值对

    • 再如统计单词次数，统计成功后，给定单词就可以快速找到其出现的次数，单词与其出现的次数就是 <word, count> 就构成一种键值对。

下面以递归版本为例，将K模型改为KV模型：

对于结点类，增加一个模板参数，下面的实现也相应的增加。

template<class K, class V>
struct BSTreeNode
{
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

	const K _key;
	V _value;

	BSTreeNode(const K& key, const V& value)
		: _left(nullptr)
		, _right(nullptr)
		, _key(key)
		, _value(value)
	{}
};

template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
    
private:
	Node* _root = nullptr;
};

find 要返回结点指针，因为要支持修改返回的结点的 value：

public:
	Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}
private:
	Node* _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return nullptr;
		if (root->_key < key)
			return _FindR(root->_right, key);
		else if (root->_key > key)
			return _FindR(root->_left, key);
		else
			return root;
	}

插入时要增加一个值 value：

public:
	bool InsertR(const K& key, const V& value)
	{
		return _InsertR(_root, key, value);
	}
private:
	bool _InsertR(Node*& root, const K& key, const V& value)
	{
		if (root == nullptr)
		{
			root = new Node(key, value);
			return true;
		}
		if (root->_key < key)
			return _InsertR(root->_right, key, value);
		else if (root->_key > key)
			return _InsertR(root->_left, key, value);
		else
			return false;
	}

测试：

我们插入几个词，这就相当于一个小词典了，然后输入单词进行查找。

void test()
{
	BSTree<string, string> ECDict;
	ECDict.InsertR("apple", "苹果");
	ECDict.InsertR("banana", "香蕉");
	ECDict.InsertR("cherry", "樱桃");
	ECDict.InsertR("pear", "梨");

	string str;
	while (cin >> str)
	{
		BSTreeNode<string, string>* ret = ECDict.FindR(str);
		if (ret != nullptr)
		{
			cout << "中文：" << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}
//结果：
//apple
//中文：苹果
//banana
//中文：香蕉
//grape
//无此单词
世真
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
【C语言】【树】【孩子表示法】使用孩子表示法存储简易学生信息
Xunyira箐的博客
02-10 310
如题，本程序利用孩树的子表示法存储简易学生信息（姓名与成绩） 初学者作品，欢迎大佬斧正 // 孩子表示法的本质是每个节点设置一个孩子链表，利用顺序结构存储根的节点和孩子们的头指针 //鉴于表示方便，本试验程序用二叉树代替树进行存储 #include <stdio.h> #include <stdlib.h> #include <string.h> #define Max 50 struct Cnode{ //组成孩子链表 int child; //孩子序号
C语言平衡二叉排序树：学生管理系统
qq_52209002的博客
01-03 1593
#include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX(A, B) ((A)>(B)?(A):(B)) #define Malloc(type) (type*)malloc(sizeof(type)) struct stu_grade { char stu_name[15];//姓名 float grade;//成绩 char number[15];//编号（学.
C语言学生成绩管理系统（二叉排序树）
程序设计
09-19 1561
学生成绩管理系统可以对学生表（学号、姓名、性别)、课程表（课程号、课程名、学分)、选课表（学号、课程号、成绩）进行管理，学生可以选择某门课程，考试得到一个成绩。要求学生表8使用学号作为关键字构建二叉排序树(学号不能重复)，课程表(课程号不能重复)和选课表采用顺序结构。(4）根据姓名，查询某个学生的所有成绩（课程名，得分）和平均成绩。(5）根据课程名，查询某门课的所有成绩(姓名，得分）和平均成绩。(6）选做:退出时，将学生、课程及选课信息保存到文件中。(1）学生表的插入和删除。(3）选课表的插入和删除。
基于二叉树实现一个学生成绩信息管理系统
m0_48298397的博客
08-15 1万+
众所周知，二叉树在数据结构领域属于一个较难的课题，本文针对二叉树的基本操作逻辑，实现了一个基于二叉树的学生成绩管理系统，包含初始化增加删除打印等各大基本功能，和大家一起分享，小编也是个初学者，有什么不正确的地方望指正。 本代码用了大量的递归函数，小白慎进，毕竟这是个很掉头发的东西，可真让人头秃！！！ 本代码实现五大功能，分别是： 1、添加学生编号、姓名和成绩，将数据插入二叉树中 2、输入编号，找到相应的二叉树节点，可查询学生成绩信息 3、打印出二叉树所有节点的信息 4、按编号删除相应的节点.
C++学习笔记(七)——学生信息管理系统
热门推荐
m0_58367586的博客
11-02 1万+
前面已经学了C++的类和对象，对C++已经有了初步了解，为了加深对其应用，下面和大家一起学习编写学生信息管理系统。
假如班级有5位同学（每个同学包含学号，姓名，成绩信息），使用二叉树进行信息存储，结构如下图所示
shadoubudongp的博客
04-15 1182
请用语句创建二叉树存储结构，并实现二叉树的前序，中序，后序遍历。 分享一段作业代码 先创建出一个学生类 StudentNode写出遍历方法 package shu; public class StudentNode{ public int id; public String name; public int cj; public StudentNode left; //默认null public StudentNode right; pub...
二叉搜索树的实现与应用
11-04
本资源是博文【数据结构】二叉搜索树的完整源代码文件，包含K模型搜索树的递归、非递归实现；KV模型搜索树的递归和非递归实现。以及两种模型的测试和应用，主要体现在单词翻译、统计次数、检查单词拼写。可结合以下...
binary-search-tree:二叉搜索树 OOP 的简单 C++ 实现
06-27
二叉搜索树（Binary Search Tree...通过阅读和理解这个项目中的源代码，你可以深入学习二叉搜索树的工作原理，以及如何用 C++ 的 OOP 思维来实现数据结构。这对于提升 C++ 编程技能和理解数据结构与算法有着重要作用。
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
总之，二叉搜索树是一种重要的数据结构，它在C++中的实现涉及到节点结构的设计和插入、查找、删除等操作的实现。理解并掌握二叉搜索树的原理和操作是提升算法能力的关键，而自平衡二叉搜索树则进一步提高了在大规模...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
二叉搜索树实现与测试.zip(悉尼大学数据结构作业)
04-27
悉尼大学的这个数据结构作业主要涉及了二叉搜索树的这些基本操作。 首先，**插入操作**是将一个新元素添加到二叉搜索树中的过程。新节点应被放置在正确的位置，以保持树的性质。如果新值小于当前节点，就向左子树...
学生成绩管理系统（含二叉树内容）
12-28
C语言程序实现学生成绩管理系统，含有二叉树的一部风内容，大家可以在原有链表的实现方式上的一种算法的提高，可以看看……
C语言二叉查找树(图文详解)(超详细)
qq_28229519的博客
08-14 5536
本人在第一次学习二叉树的时候,感觉很懵懵懂懂,勉强知道了二叉树的结构和查找方式,但要我自己去动手写的时候,可是难上加难,所以这里我用干货+实际例子的方式让你上手二叉树,这个例子几乎可以套用到所有链式结构问题,我们开始吧!...
基于二叉平衡树的学生信息管理系统
weixin_46080371的博客
07-01 2970
二叉平衡树的插入，删除函数参考了这位大佬的代码 详见 https://www.cnblogs.com/sench/p/7786718.html添加链接描述 对函数进行了一点改进 注意：本程序中的二叉平衡树的lr旋转函数、rl旋转函数与网上博客名字相反（比如网上是lr,本程序是rl,内容一致）！！！ 运行界面： 头文件： typedef struct stu { unsigned long long num; //学号 char name[9]; // 字符串结束符 勿忘 ！！！ int
数据结构使用二叉树进行信息存储,班级有5为同学，每个同学包含学号，姓名，成绩。
qq_51279057的博客
04-18 1528
班级有5为同学（每个同学包含学号，姓名，成绩），使用二叉树进行信息存储，结构如下图所示（笔记） 要求前、中、后序遍历 StudentNode public class StudentNode { public int id; public String name; public int fs; public StudentNode left; //默认null public StudentNode right;
学籍管理系统（二叉排序树）
幽涧恋桥
12-16 6225
二叉排序树
leetcode_二叉搜索树中插入数
Snow_Jie的博客
07-11 534
给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 保证原始二叉搜索树中不存在新值。注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。例如, 给定二叉搜索树: 4 / \ 2 7 / \ 1 3 和 插入的值: 5 你可以返回...
数据结构系列，二叉平衡树的构建
lin20080410的专栏
01-12 4875
平衡二叉树 平衡二叉树，首先要是一种二叉排序树， 然后，其中每一个结点的左子树，右子树的高度差（左子树的高度 – 右子树的高度）至多等于1，二叉树的高度就是这棵树有几层。 将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF，所有结点的平衡因子的值，只可能是-1, 0, 1。只要二叉树上有一个结点的平衡因子绝对值大于1，则该二叉树就是不平衡的。 距离插入结点最近的，且平衡因子...
二叉排序树构造学生管理系统
mxf999的专栏
06-02 5120
<br />本程序以二叉排序树为数据结构，构造了一个学生信息管理系统，可以进行建立 编辑 插入 删除 查找学生信息，本程序设计的亮点在于FindBSTree函数，此函数为通用函数，供建立 编辑 插入 查找 等操作服务<br />#include<stdio.h><br />#include<stdlib.h><br />#include<string.h><br />typedef struct BSTree<br />{ int num;<br />char name[20];<br />char sex
C++实现二叉树、二叉搜索树与堆的操作
"该资源包含一个C++代码文档，用于实现与数据结构相关的二叉树、二叉搜索树和堆的操作。提供了`Main.cpp`、`CLASS.h`两个主要文件，其中`Main.cpp`是主程序，而`CLASS.h`包含了`TreeNode`模板类和未完全展示的`Tree`...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

世真

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值