DS二叉搜索树

已于 2024-06-09 22:54:09 修改
阅读量722 收藏 31
点赞数 14
分类专栏： C++进阶 DS进阶 文章标签： 数据结构 c++ 算法
于 2024-05-06 19:39:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75256358/article/details/138492859
版权

前言

我们在数据结构初阶专栏已经对二叉树进行了介绍并用C语言做了实现，但是当时没有对二叉搜树进行介绍，而是把他放到数据结构进阶构专栏的第一期来介绍，原因是后面的map和set（红黑树）是基于搜索树的，这里介绍完后再去学习他们的成本会低一点！

本期内容介绍

二叉搜索树介绍

二叉搜索树的实现

二叉搜索树的应用

二叉搜索树的性能分析

二叉搜索树的介绍

什么是二叉搜索树？

二叉搜索树又称二叉排序树（走中序就是有序的）或二叉查找树。他是一颗空树或满足以下性质的二叉树！

1、如果它的左子树不为空，则左子树的所有节点的值都小于根节点的值

2、如果它的右子树不为空，则右子树的所有节点的值都大于根节点的值

3、它的左右子树也必须都为二叉搜索树

一般把二叉搜索树的节点的值叫做键值（key），一个键值唯一标识唯一一个节点！所以一般的key模型的二叉搜索树是不允许修改的（key_value模型仅可以修改value）；因为在key模型的二叉搜索树中修改了key值会影响二叉搜索的搜索性，修改后可能就不在符合左边比根节点小，右边比根节点大的性质了！！！

二叉搜索树的实现

由于二叉搜索树是不允许修改键值(key)的，他主要作用是查询，所以没有修改接口。

OK，还是和以前一样，先搭个架子出来：我们得有节点的类专门搞节点，然后一个二叉搜索树的类专门负责查找等操作！

template<class K>
struct BSTreeNode
{
	BSTreeNode* _left;
	BSTreeNode* _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;//只有一个成员，给一个缺省参数可以不用自己写构造了
};

下面就是实现插入、查询和删除的接口操作了！

insert

实现思路：

如果是第一次插入即根节点为空则直接new一个值为key的节点连接到_root返回即可！

如果不是第一次插入，则从父节点开始查找合适的插入位置并用parent的变量记录合适位置的父节点的值，如果比当前的节点大，去右边，否则去左边，直到为空即找到了合适的位置，插入！如果是等于说明要插入的值引进存在直接返回！

最后找到了插入位置new一个键值为key的节点连接到合适位置的父节点即可！

但是这里要插到做还是右呢？如果key的值比parent的值大插入到右边，否则插入到左边！

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->_left;//去当前节点的左边
		}
		else if (cur->_key < key)//要插入的值比当前节点的值大
		{
			parent = cur;
			cur = cur->_right;//去当前节点的右边
		}
		else
		{
			return false;//要插入的值已经存在
		}
	}

	//找到了要插入节点的合适位置
	cur = new Node(key);//申请一个键值为key的节点
	if (parent->_key < key)//key的值比父节点小
	{
		parent->_right = cur;//连接到父节点的右边
	}
	else
	{
		parent->_left = cur;//否则连接到父节点的左边
	}

	return true;//插入成功
}

OK，我们知道他的中序是有序的，所以我们可以插入一些乱序的数字然后走个中序看看是否是有序的即可验证师插入！

InOrder

实现思路：先遍历左子树 --> 根 -->右子树

但是这的根节点是BSTree私有的，咋办呢？解决方案右以下几种：

1、把你的测试函数搞成友元，就可以在测试函数中访问_root了（强烈不推荐）

2、提供get和set函数

3、把中序搞成私有的子函数，在提供一个共有的把子函数套一层（推荐）

void _Inorder(const Node* _root)
{
	if (_root == nullptr)
	{
		return;
	}

	_Inorder(_root->_left);
	cout << _root->_key << " ";
	_Inorder(_root->_right);
}

OK，验证一下：

Find

实现思路：比较当前节点的值和key的值，如果比key大去右边，否则去左边找！

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

	return false;//没找到
}

Erase

实现思路

删除可以分为4种情况：1、被删节点的左为空   2、被删节点的右为空  3、被删节点的左右都为空  4、被删节点的左右都不为空。前三中只需要特殊处理一下可以合并为两种！注意：所有的删除都得找到这个节点，否则直接返回false;

被删节点的左为空

        1、如果当前节点是根节点且只有右单枝，让根节点指向它的右单枝的下一个

        2、不是根节点，如果被删节点==它的父节点的左，则把他的右连接到父亲的左

              如果被删节点==它的父节点的右，则把他的右连接到父亲的右

被删节点的右为空 

        1、如果当前节点是根节点且只有左单枝，让根节点指向它的左单枝的下一个

        2、不是根节点，如果被删节点==它的父节点的左，则把他的左连接到父亲的左

              如果被删节点==它的父节点的右，则把他的左连接到父亲的右

被删节点的左右都不为空

        用替换法删除即找一个合适的节点替他删除！可以找左子树最大（右）或 右子树最左         （小）的节点来替换。

        找到替换的节点后可以交换键值也可以赋值，然后删除替换节点即可！

bool Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key > key)//比key大，往左找
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)//比key小，往右找
		{
			parent = cur;
			cur = cur->_right;
		}
		else//找到了
		{
			if (cur->_left == nullptr)//被删除节点的左为空
			{
				if (_root == cur)//删除根且只有右枝没有左枝
				{
					_root = cur->_right;//让根指向它的右
				}
				else
				{
					if (parent->_left == cur)//父亲的左==cur，把cur的右连接到父亲的左
					{
						parent->_left = cur->_right;
					}
					else//父亲的右==cur，把cur的右连接到父亲的右
					{
						parent->_right = cur->_right;
					}
				}

				delete cur;
			}
			else if (cur->_right == nullptr)//被删除节点的右为空
			{
				if (_root == cur)//删除根且只有左枝没有右枝
				{
					_root = cur->_left;//让根指向它的左
				}
				else
				{
					if (parent->_left == cur)//父亲的左==cur，把cur的左连接到父亲的左
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;//父亲的右==cur，把cur的右连接到父亲的左
					}
				}

				delete cur;
			}
			else//被删除节点的左右都不为空则用替换法删除即找到一个合适的节点来替他被删（左子树最（大）右，或右子树的最（小）左）
			{
				Node* rightMinParent = cur;//右子树最（小）左节点的父亲
				Node* rightMin = cur->_right;//右子树的最左节点
				while (rightMin->_left)
				{
					rightMinParent = rightMin;
					rightMin = rightMin->_left;
				}

				swap(cur->_key, rightMin->_key);//右子树左节点与被删节点的值交换
					
				if (rightMinParent->_left == rightMin)//如果rightMinParent的左==rightMin
				{
					rightMinParent->_left = rightMin->_right;//则把rightMin的右连接到rightMinParent的左
				}
				else//如果rightMinParent的右==rightMin
				{
					rightMinParent->_right = rightMin->_right;//则把rightMin的右连接到rightMinParent的右
				}

				delete rightMin;
			}

			return true;
		}
	}

	return false;
}

OK，验证一下：

析构函数

因为只有一个成员，所以直接给一个缺省值就不用写构造了！析构得写，和二叉树的销毁一样！先左子树销毁-->右子树销毁-->根销毁，可以和中序一样搞一个子函数外面套一下即可！

void Destory(Node*& root)
{
	if (root == nullptr)
		return;

	Destory(root->_left);
	Destory(root->_right);

	delete root;
	root = nullptr;
}
~BSTree()
{
	Destory(_root);
}

key模型的全部源码

#pragma once

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

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

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	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->_left;//去当前节点的左边
			}
			else if (cur->_key < key)//要插入的值比当前节点的值大
			{
				parent = cur;
				cur = cur->_right;//去当前节点的右边
			}
			else
			{
				return false;//要插入的值已经存在
			}
		}

		//找到了要插入节点的合适位置
		cur = new Node(key);//申请一个键值为key的节点
		if (parent->_key < key)//key的值比父节点小
		{
			parent->_right = cur;//连接到父节点的右边
		}
		else
		{
			parent->_left = cur;//否则连接到父节点的左边
		}

		return true;//插入成功
	}

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

		return false;//没找到
	}

bool Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key > key)//比key大，往左找
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)//比key小，往右找
		{
			parent = cur;
			cur = cur->_right;
		}
		else//找到了
		{
			if (cur->_left == nullptr)//被删除节点的左为空
			{
				if (_root == cur)//删除根且只有右枝没有左枝
				{
					_root = cur->_right;//让根指向它的右
				}
				else
				{
					if (parent->_left == cur)//父亲的左==cur，把cur的右连接到父亲的左
					{
						parent->_left = cur->_right;
					}
					else//父亲的右==cur，把cur的右连接到父亲的右
					{
						parent->_right = cur->_right;
					}
				}

				delete cur;
			}
			else if (cur->_right == nullptr)//被删除节点的右为空
			{
				if (_root == cur)//删除根且只有左枝没有右枝
				{
					_root = cur->_left;//让根指向它的左
				}
				else
				{
					if (parent->_left == cur)//父亲的左==cur，把cur的左连接到父亲的左
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;//父亲的右==cur，把cur的右连接到父亲的左
					}
				}

				delete cur;
			}
			else//被删除节点的左右都不为空则用替换法删除即找到一个合适的节点来替他被删（左子树最（大）右，或右子树的最（小）左）
			{
				Node* rightMinParent = cur;//右子树最（小）左节点的父亲
				Node* rightMin = cur->_right;//右子树的最左节点
				while (rightMin->_left)
				{
					rightMinParent = rightMin;
					rightMin = rightMin->_left;
				}

				swap(cur->_key, rightMin->_key);//右子树左节点与被删节点的值交换
					
				if (rightMinParent->_left == rightMin)//如果rightMinParent的左==rightMin
				{
					rightMinParent->_left = rightMin->_right;//则把rightMin的右连接到rightMinParent的左
				}
				else//如果rightMinParent的右==rightMin
				{
					rightMinParent->_right = rightMin->_right;//则把rightMin的右连接到rightMinParent的右
				}

				delete rightMin;
			}

			return true;
		}
	}

	return false;
}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}

	~BSTree()
	{
		Destory(_root);
	}

private:
	void _Inorder(const Node* _root)
	{
		if (_root == nullptr)
		{
			return;
		}

		_Inorder(_root->_left);
		cout << _root->_key << " ";
		_Inorder(_root->_right);
	}

	void Destory(Node*& root)
	{
		if (root == nullptr)
			return;

		Destory(root->_left);
		Destory(root->_right);

		delete root;
		root = nullptr;
	}

private:
	Node* _root = nullptr;//只有一个成员，给一个缺省参数可以不用自己写构造了
};

二叉搜索树的应用

1、K模型：就是我们上面介绍和实现的key模型，K模型中只存键值key，不可被修改！这个在生活中也是很常见的，比如说20万个单词找出拼写错误的单词！此时你只需要根据单词库中的单词建立一个key模型的搜索树即可，然后一一查找即可，如果是false的就是错误的！另外，宿舍的门禁系统，你刷脸或刷卡时会放你进去，这个也是一个key模型的搜索树！

2、KV模型：每个节点中不仅存一个键值key还要存一个key对应的value。即<KV>键值对。这个也是很常见的，比如说英汉词典，你的学号对应你等！

key_value模型全部源代码

上面K模型已经实现了，这里KV模型在上面的K上稍加修改即可（插入的时候多加一个value）！

namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode* _left;
		BSTreeNode* _right;
		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;
	public:
		bool insert(const K& key, const V& value)
		{
			if (_root == nullptr)//第一次插入
			{
				_root = new Node(key, value);
				return true;
			}

			Node* parent = nullptr;//记录要插入节点的父节点的位置
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)//要插入的值比当前节点的值小
				{
					parent = cur;
					cur = cur->_left;//去当前节点的左边
				}
				else if (cur->_key < key)//要插入的值比当前节点的值大
				{
					parent = cur;
					cur = cur->_right;//去当前节点的右边
				}
				else
				{
					return false;//要插入的值已经存在
				}
			}

			//找到了要插入节点的合适位置
			cur = new Node(key, value);//申请一个键值为key的节点
			if (parent->_key < key)//key的值比父节点小
			{
				parent->_right = cur;//连接到父节点的右边
			}
			else
			{
				parent->_left = cur;//否则连接到父节点的左边
			}

			return true;//插入成功
		}

		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else
				{
					return cur;//找到了
				}
			}

			return cur;//没找到
		}

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)//比key大，往左找
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_key < key)//比key小，往右找
				{
					parent = cur;
					cur = cur->_right;
				}
				else//找到了
				{
					if (cur->_left == nullptr)//被删除节点的左为空
					{
						if (_root == cur)//删除根且只有右枝没有左枝
						{
							_root = cur->_right;//让根指向它的右
						}
						else
						{
							if (parent->_left == cur)//父亲的左==cur，把cur的右连接到父亲的左
							{
								parent->_left = cur->_right;
							}
							else//父亲的右==cur，把cur的右连接到父亲的右
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;
					}
					else if (cur->_right == nullptr)//被删除节点的右为空
					{
						if (_root == cur)//删除根且只有左枝没有右枝
						{
							_root = cur->_left;//让根指向它的左
						}
						else
						{
							if (parent->_left == cur)//父亲的左==cur，把cur的左连接到父亲的左
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;//父亲的右==cur，把cur的右连接到父亲的左
							}
						}

						delete cur;
					}
					else//被删除节点的左右都不为空则用替换法删除即找到一个合适的节点来替他被删（左子树最（大）右，或右子树的最（小）左）
					{
						Node* rightMinParent = cur;//右子树最（小）左节点的父亲
						Node* rightMin = cur->_right;//右子树的最左节点
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}

						swap(cur->_key, rightMin->_key);//右子树左节点与被删节点的值交换

						if (rightMinParent->_left == rightMin)//如果rightMinParent的左==rightMin
						{
							rightMinParent->_left = rightMin->_right;//则把rightMin的右连接到rightMinParent的左
						}
						else//如果rightMinParent的右==rightMin
						{
							rightMinParent->_right = rightMin->_right;//则把rightMin的右连接到rightMinParent的右
						}

						delete rightMin;
					}

					return true;
				}
			}

			return false;
		}

		void Inorder()
		{
			_Inorder(_root);
			cout << endl;
		}

		~BSTree()
		{
			Destory(_root);
		}

	private:
		void _Inorder(const Node* _root)
		{
			if (_root == nullptr)
			{
				return;
			}

			_Inorder(_root->_left);
			cout << _root->_key << " -> " << _root->_value << endl;
			_Inorder(_root->_right);
		}

		void Destory(Node*& root)
		{
			if (root == nullptr)
				return;

			Destory(root->_left);
			Destory(root->_right);

			delete root;
			root = nullptr;
		}

	private:
		Node* _root = nullptr;//只有一个成员，给一个缺省参数可以不用自己写构造了
	};
}

可以一个类似于英汉单词的效果：

当然还可以统计某些东西的次数等！这里就不演示了！

二叉搜索树的性能分析

要执行插入和删除的操作的前提是得查找到相关的位置或元素，所以查找的效率代表了插入和删除的性能！我们来分析一下二叉搜索树的查找的时间复杂度：如果正常情况下是最多查找高度次所以时间复杂度是:O(logN)但是如果这个数是类似于链表的情况的话就是O（N）了！

这里你可能会担心，如果极端情况下真的退化成单链表那二叉搜索树的搜索性能就消失了，那该咋办呢？其实这个问题已经得到了解决！就是我们后面要介绍的AVL树和红黑树！马上后面会介绍的！

OK，好兄弟，本期分享就到这里，我们下期再见！

结束语：山高路远，看世界，也找自己。

暗恋 懒羊羊
关注
  • 14
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【DS】二叉搜索树的介绍和实现
trong_ 的烂笔头
10-21 1601
二叉搜索树的介绍, 实现其的查找, 插入, 删除, 修改等操作.
DS二叉排序树之查找
半濠春水的博客
10-02 760
题目描述 给出一个数据序列，建立二叉排序树，并实现查找功能 对二叉排序树进行中序遍历，可以得到有序的数据序列 输入 第一行输入t，表示有t个数据序列 第二行输入n，表示首个序列包含n个数据 第三行输入n个数据，都是自然数且互不相同，数据之间用空格隔开 第四行输入m，表示要查找m个数据 从第五行起，输入m行，每行一个要查找的数据，都是自然数 以此类推输入下一个示例 输出 第一行输出有序的数据序列，对二叉排序树进行中序遍历可以得到 从第二行起，输出查找结果，如果查找成功输出查找次数，如果查找失败输出-1 以此.
二叉搜索树及其模拟实现
Nou_Camp的博客
06-03 446
1.二叉搜索树（二叉排序树）的定义 二叉搜索树或者是空树，或者具有以下性质的二叉树： ① 若左子树为空，则左子树上所有结点的关键字值均小于它的根节点的关键字值。 ② 若右子树为空，则右子树上所有结点的关键字值均大于它的根节点的关键字值。 ③左右子树本身又是一颗二叉搜索树。 2.二叉搜索树的查找 查找思路为：若待查找数据元素的关键字值等于二叉搜索树根节点的关键字值，则查找成功；若待查找数据
模拟实现二叉搜索树
Adenson的博客
12-10 666
1、什么是二叉搜索树？ 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树。 2、二叉搜索树基本操作 二叉搜索树的查找： //非递归查找 Node* Find(const K& key) { Node* ...
DS：二叉搜索树
dao_shadow的博客
08-01 277
每个节点都有一个唯一的键值。左子树上所有节点的键值小于它的根节点的键值。右子树上所有节点的键值大于它的根节点的键值。左、右子树也分别是二叉搜索树。这种结构使得二叉搜索树在进行查找、插入和删除操作时，平均时间复杂度达到O(log n)，是一种高效的查找树。按照这样存储数据，将二叉搜索树进行中序遍历后，结果是升序的。
235. 二叉搜索树的最近公共祖先-dfs法
weixin_43327597的博客
07-20 190
百度百科中最近公共祖先的定义为“对于有根树T的两个结点p、q，最近公共祖先表示为一个结点x，满足x是p、q的祖先且x的深度尽可能大（一个节点也可以是它自己的祖先）。输入root=[6,2,8,0,4,7,9,null,null,3,5],p=2,q=8。输入root=[6,2,8,0,4,7,9,null,null,3,5],p=2,q=4。例如，给定如下二叉搜索树root=[6,2,8,0,4,7,9,null,null,3,5]...
230. 二叉搜索树中第K小的元素
尕白白的专栏
07-20 978
然后获取第k个位置，如本题我是使用list,index下标从0开始，因此第k个元素，即获取下标为k-1的元素即可，list.get(k-1);令h为树高，先到达叶子位置（最小节点位置），复杂度为O(h)，然后找到第k小的元素，复杂度为O(k)。即对应的转换为把二叉搜索树，转换为【中序】遍历，并存在容器中，可以是list,数组，或者哈希表，队列均可以。无需遍历全部到元素。时间复杂度O(N)中序遍历，每个元素都遍历到，因此复杂度为O(N)。...
【DS】Java实现一个简单的二叉搜索树
weixin_56952690的博客
03-11 215
【数据结构】本文简单实现二叉搜索树各个基本操作，为以后学习AVL树和红黑树做铺垫。
是否二叉搜索树
Mai___的博客
03-24 704
本题要求实现函数，判断给定二叉树是否二叉搜索树。 函数接口定义： bool IsBST ( BinTree T ); 其中BinTree结构定义如下： typedef struct TNode *Position; typedef Position BinTree; struct TNode{ ElementType Data; BinTree Left; BinTree Right; }; 函数IsBST须判断给定的T是否二叉搜索树，即满足如下定义的二叉树： 定义：一个二叉搜索
二叉搜索树中第K小的元素
HerofH_的博客
01-20 2193
目录 1 题目描述 2 题目分析 3 代码实现 3.1 中序遍历方法 3.2 结点计数方法 1 题目描述 给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。 说明： 你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。 示例 1: 输入: root = [3,1,4,null,2], k = 1 3 / \ 1 ...
6-4 是否二叉搜索树 (12分)
qq_45728926的博客
05-27 1093
6-4 是否二叉搜索树 (12分) 本题要求实现函数，判断给定二叉树是否二叉搜索树。 函数接口定义： bool IsBST ( BinTree T ); 其中BinTree结构定义如下： typedef struct TNode *Position; typedef Position BinTree; struct TNode{ ElementType Data; BinTree Left; BinTree Right; }; 函数IsBST须判断给定的T是否二叉搜索树，即满足如下定义的二叉树： 定义：一个
给定一个二叉树，判断其是否是一个有效的二叉搜索树
Poo_Chai的博客
07-31 3570
给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例1: 输入: 2 / \ 1 3 输出: true 示例2: 输入: 5 / \ 1 4 / \ 3 6 输出...
二叉平衡树（C++）
wo_ai_luo_的博客
02-25 1060
平衡二叉树也叫做AVL树,AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树(Self-Balancing Binary Search Tree,简称平衡二叉树。我们怎么知道这棵二叉搜索树平不平衡呢？我们知道，二叉搜索树的搜索时间和高度是有直接关系的，但是我们按递增、递减序输入之后，高度就和n一样了，所以时间复杂度为O(log n).想要优化，就是改变这棵二叉搜索树的高度。
PTA 函数题 是否二叉搜索树（C语言）
weixin_47073308的博客
11-25 1472
本题要求实现函数，判断给定二叉树是否二叉搜索树。 函数接口定义： bool IsBST ( BinTree T ); 其中BinTree结构定义如下： typedef struct TNode *Position; typedef Position BinTree; struct TNode{ ElementType Data; BinTree Left; BinTree Right; }; 函数IsBST须判断给定的T是否二叉搜索树，即满足如下定义的二叉树：定义：一个二叉搜索树是一
数据结构 数据结构
qq_69971969的博客
09-03 307
空间不连续 访问数据不方便（需要遍历） 插入和删除比较方便 不需要预分配，动态增长。空间连续 访问数据方便 插入和删除需要移动大量数据 需要预分配存储空间。数据的物理结构：数据的逻辑结构在计算机内存中的存储方式。线性结构：一对一的元素关系（数组，链表。图形结构：元素之间的多对多的关系（网状结构）数据的逻辑结构：数据元素与元素之间的关系。树型结构：一对多的元素关系（二叉树）链式存储：一段非连续的空间。程序：数据结构 + 算法。顺序存储：一段连续的空间。数据与数据之间的关系。
冒泡排序；选择排序；插入排序；快排；判断大小端；位运算
qq_56797509的博客
09-03 202
假设有10个元素a[1]-a[10]，将a[1]与a[2]-a[10]比较，若a[1]比a[2]-a[10]都小，则不进行交换。若a[2]-a[10]中有一个以上比a[1]小，则将其中最小的一个与a[1]交换，此时a[1]就存放了10个数中最小的一个。同理，第二轮拿a[2]与a[3]-a[10]比较，a[2]存放a[2]-a[10]中最小的数，以此类推。选一个key值（选第一个值），从后面选一个比其小的值，从前面选一个比其大的值，key值放中间。1.小端：内存低地址存放低数据位称为内存小端。
【笔记】数据结构——8月27日
m0_52024881的博客
08-27 1390
考研用笔记
数据结构---链表
最新发布
2301_78040391的博客
09-03 196
【代码】数据结构---链表。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值