搜索二叉树

已于 2024-06-19 16:16:57 修改
阅读量411 收藏 6
点赞数 5
分类专栏： c++ 文章标签： c++ 算法
于 2024-05-22 15:24:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suinnn/article/details/139121272
版权

文章目录

搜索二叉树的实现

框架和insert函数

我们很容易写出下面的框架和insert函数

struct BSTreeNode
{
	BSTreeNode(const K& val)
	{
		_val = val;
		_left = nullptr;
		_right = nullptr;
	}
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _val;
};

template <class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	bool insert(const K& val)
	{
		// a. 树为空，则直接新增节点，赋值给root指针
		if (_root == nullptr) {
			_root = new BSTreeNode(val);
			return true;
		}
		// b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
		Node* cur = _root, *prev=nullptr;
		while (cur) {
			if (val < cur->_val) {
				prev = cur;
				cur = cur->_left;
			}
            else if (val > cur->_val) {
				prev = cur;
				cur = cur->_right;
			}
			else {
				// val的值和树中某个节点的值相同,返回false
				return false;
			}
		}
		// 找到了一个合适的位置,此时需要链接,注意链接位置
		cur = new Node(val);
		if (val < prev->_val) {
			prev->_left = cur;
			return true;
		}
		else {
			prev->_right = cur;
			return true;
		}
	}
private:
	Node _root = nullptr;
};

中序遍历

我们知道,搜索二叉树的中序遍历是一个有序表,现在我们想要像这样调用

int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
BSTree<int> tree;
for (auto& e : a)
	tree.insert(e);
tree.InOrder();

但是InOrder()需要一个参数root,现在有三种解决办法,a.将_root改为public,b.写一个GetRoot(),c.如下

protected:
void _InOrder(Node* root)
{
	if (root == nullptr)	return;
	_InOrder(root->_left);
	cout << root->_val << ' ';
	_InOrder(root->_right);
}
public:
void InOrder()
{
	_InOrder(_root);
}

有人可能会这样写void _InOrder(Node* root) = _root, 这样是错误的,因为函数的默认参数只能是全局变量或者常量

find(const K& val)

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

erase()函数

image-20240513120013255

其中第②种情况包含第①中情况

bool erase(const K& key)
{
	Node* cur = _root, * prev = nullptr;
	while (cur) {
		if (key < cur->_key) {
			prev = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key) {
			prev = cur;
			cur = cur->_right;
		}
		else {
			// 1.左为空,prev指向cur的_right,但是prev的_left还是_right需要判断
			if (cur->_left == nullptr) {
				if (prev->_left == cur)	prev->_left = cur->_right;
				else prev->_right = cur->_right;
				delete cur;
			}
			// 2.右为空
			else if (cur->_right == nullptr) {
				if (prev->_left == cur)	prev->_left = cur->_left;
				else prev->_right = cur->_left;
				delete cur;
			}
			// 其他情况,需要"找保姆"
			else {
				// 找右树的最小节点
				Node* minRight = cur->_right, * prevMinRight = cur;
				while (minRight->_left) {
					prevMinRight = minRight;
					minRight = minRight->_left;
				}
				cur->_key = minRight->_key;
				/*if (prevMinRight == cur) prevMinRight->_right = minRight->_right;
				else prevMinRight->_left = minRight->_right;*/
				// 这里也需要判断,因为不能保证prevMinRight是否是cur
				if (prevMinRight->_right == minRight) prevMinRight->_right = minRight->_right;
				else prevMinRight->_left = minRight->_right;
				delete minRight;
			}
			return true;
		}
	}
	return false;
}

看似上面的代码没有问题,但面对下面的测试用例时,就会有问题

// 测试erase
void test2()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> tree;
	for (auto& e : a)
		tree.insert(e);
	tree.erase(10);
	tree.erase(14);
	tree.erase(13);
    tree.erase(8);
	tree.InOrder();
}

image-20240520175920684

此时有两种解决办法,一是更新_root,更新为节点3,二是找左子树的最大值来作为cur的prev
左树为空时同理

此时erase变为

bool erase(const K& key)
{
	Node* cur = _root, * prev = nullptr;
	while (cur) {
		if (key < cur->_key) {
			prev = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key) {
			prev = cur;
			cur = cur->_right;
		}
		else {
			// 1.左为空,prev指向cur的_right,但是prev的_left还是_right需要判断
			if (cur->_left == nullptr) {
				if (cur == _root)	_root = cur->_right;
				else {
					if (prev->_left == cur)	prev->_left = cur->_right;
					else prev->_right = cur->_right;
					delete cur;
				}
			}
			// 2.右为空
			else if (cur->_right == nullptr) {
				if (cur == _root) _root = cur->_left;
				else {
					if (prev->_left == cur)	prev->_left = cur->_left;
					else prev->_right = cur->_left;
					delete cur;
				}
			}
			// 其他情况,需要"找保姆"
			else {
				// 找右树的最小节点
				Node* minRight = cur->_right, * prevMinRight = cur;
				while (minRight->_left) {
					prevMinRight = minRight;
					minRight = minRight->_left;
				}
				cur->_key = minRight->_key;
				/*if (prevMinRight == cur) prevMinRight->_right = minRight->_right;
				else prevMinRight->_left = minRight->_right;*/
				// 这里也需要判断,因为不能保证prevMinRight是否是cur
				if (prevMinRight->_right == minRight) prevMinRight->_right = minRight->_right;
				else prevMinRight->_left = minRight->_right;
				delete minRight;
			}
			return true;
		}
	}
	return false;
}

搜索二叉树的递归实现

findR()函数

bool findR(const K& key)
{
    return _findR(_root, key);
}
bool _findR(Node* root, const K& key)
{
    if (root == nullptr)	return false;

    if (root->_key < key)	_findR(root->_right, key);
    else if (root->_key > key)	_findR(root->_left, key);
    else return true;
}

insertR()函数

bool insertR(const K& key)
{
    return _insertR(_root, 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;
}

关于参数为什么是Node*& root,可以看下面的递归展开图

image-20240521105848190

eraseR()函数

bool eraseR(const K& key)
{
	return _eraseR(_root, key);
}

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;
		else if (root->_right == nullptr) root = root->_left;
		else {
			// 找左子树的最大节点
			Node* maxLeft = root->_left;
			while (maxLeft->_right != nullptr) maxLeft = maxLeft->_right;
			swap(root->_key, maxLeft->_key);
			// 转换成子问题去删除
			return _eraseR(root->_left, key);
		}
		delete del;
		return true;
	}
}

注意第16行return _eraseR(root->_left, key);不能改成return _eraseR(maxLeft, key);,因为我们要想让Node*& root这个引用起作用,就需要一层一层的往下递归传递

其他函数

析构函数

~BSTree()
{
	Destroy(_root);
	_root = nullptr; 
}
void Destroy(Node* root)
{
	if (root == nullptr)	return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

拷贝构造函数

BSTree(const BSTree<K>& t)
{
	_root = Copy(t._root);
}
Node* Copy(Node* root)
{
	if (root == nullptr)	return nullptr;
	Node* newRoot = new Node(root->_key);
	newRoot->_left = Copy(root->_left);
	newRoot->_right = Copy(root->_right);

	return newRoot;
}

赋值函数重载

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

全部代码

#pragma once
#include <iostream>
using namespace std;
template <class K>
struct BSTreeNode
{
	BSTreeNode(const K& key)
	{
		_key = key;
		_left = nullptr;
		_right = nullptr;
	}
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;
};

template <class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	~BSTree()
	{
		Destroy(_root);
		_root = nullptr; 
	}

	// BSTree() : _root(nullptr) {}
	// 等价于上面的无参构造函数
	BSTree() = default;

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

	bool insert(const K& key)
	{
		// a. 树为空，则直接新增节点，赋值给root指针
		if (_root == nullptr) {
			_root = new Node(key);
			return true;
		}
		// b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
		Node* cur = _root, * prev = nullptr;
		while (cur) {
			if (key < cur->_key) {
				prev = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key) {
				prev = cur;
				cur = cur->_right;
			}
			else {
				// key的值和树中某个节点的值相同,返回false
				return false;
			}
		}
		// 找到了一个合适的位置,此时需要链接,注意链接位置
		cur = new Node(key);
		if (key < prev->_key) {
			prev->_left = cur;
			return true;
		}
		else {
			prev->_right = cur;
			return true;
		}
	}

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

	bool findR(const K& key)
	{
		return _findR(_root, key);
	}
	
	bool erase(const K& key)
	{
		Node* cur = _root, * prev = nullptr;
		while (cur) {
			if (key < cur->_key) {
				prev = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key) {
				prev = cur;
				cur = cur->_right;
			}
			else {
				// 1.左为空,prev指向cur的_right,但是prev的_left还是_right需要判断
				if (cur->_left == nullptr) {
					if (cur == _root)	_root = cur->_right;
					else {
						if (prev->_left == cur)	prev->_left = cur->_right;
						else prev->_right = cur->_right;
						delete cur;
					}
				}
				// 2.右为空
				else if (cur->_right == nullptr) {
					if (cur == _root) _root = cur->_left;
					else {
						if (prev->_left == cur)	prev->_left = cur->_left;
						else prev->_right = cur->_left;
						delete cur;
					}
				}
				// 其他情况,需要"找保姆"
				else {
					// 找右树的最小节点
					Node* minRight = cur->_right, * prevMinRight = cur;
					while (minRight->_left) {
						prevMinRight = minRight;
						minRight = minRight->_left;
					}
					cur->_key = minRight->_key;
					/*if (prevMinRight == cur) prevMinRight->_right = minRight->_right;
					else prevMinRight->_left = minRight->_right;*/
					// 这里也需要判断,因为不能保证prevMinRight是否是cur
					if (prevMinRight->_right == minRight) prevMinRight->_right = minRight->_right;
					else prevMinRight->_left = minRight->_right;
					delete minRight;
				}
				return true;
			}
		}
		return false;
	}

	bool eraseR(const K& key)
	{
		return _eraseR(_root, key);
	}
	
	void InOrder()
	{
		_InOrder(_root);
	}
protected:
	void _InOrder(Node* root)
	{
		if (root == nullptr)	return;
		_InOrder(root->_left);
		cout << root->_key << ' ';
		_InOrder(root->_right);
	}

	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)	_findR(root->_right, key);
		else if (root->_key > key)	_findR(root->_left, key);
		else return true;
	}

	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;
			else if (root->_right == nullptr) root = root->_left;
			else {
				// 找左子树的最大节点
				Node* maxLeft = root->_left;
				while (maxLeft->_right != nullptr) maxLeft = maxLeft->_right;
				swap(root->_key, maxLeft->_key);
				// 转换成子问题去删除
				return _eraseR(root->_left, key);
			}
			delete del;
			return true;
		}
	}

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

	Node* Copy(Node* root)
	{
		if (root == nullptr)	return nullptr;
		Node* newRoot = new Node(root->_key);
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);

		return newRoot;
	}
private:
	Node* _root = nullptr;
};
冰红茶兑滴水
关注
专栏目录
二叉树递归套路（2）：判断二叉树是否是搜索二叉树、二叉树的最大距离
Java和算法学习的博客
01-03 733
文章目录一、判断二叉树是否是搜索二叉树1、经典做法2、递归套路思路3、递归套路代码二、二叉树的最大距离1、递归套路思路2、递归套路代码 本篇继续来聊聊二叉树的递归套路。 一、判断二叉树是否是搜索二叉树 搜索二叉树定义：二叉树中的任意一个以X为头的子树，左子树都比X小，右子树都比X大。（经典的搜索二叉树是没有重复值的） 1、经典做法 中序遍历，结果是递增的，说明这是搜索二叉树。 2、递归套路思路 分析任意一个以X为头的子树，满足以X为头的子树是搜索二叉树的条件（列出所有可能性） 1）左子树是搜索二叉树 2）右
Leetcode 搜索二叉树中错误节点
一只老风铃
09-06 783
题目描述 一棵二叉树原本是搜索二叉树，但是其中有两个节点调换了位置，使得这棵二叉树不再是搜索二叉树，请按升序输出这两个错误节点的值。(每个节点的值各不相同) 思路： 搜索二叉树最重要性质为中序遍历为升序 那么交换的可能是 前后两个节点交换，那么中序遍历存在一组逆序对 中间隔开若开个节点交换，那么中序遍历存在两组逆序对 那么只要记录下第一组逆序对的第一个元素，以及最后一组逆序对的第二个元素，即为原先交换的两个数 关键实现 对于一组逆序对（first,second） ...
C++搜索二叉树
RXY24601的博客
05-27 1403
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
完全二叉树、搜索二叉树、平衡二叉树和满二叉树（C++）
ymhdt的博客
05-21 1481
完全二叉树是这样定义的：若二叉树的深度为 h，除第 h 层外，其它各层的结点数都达到最大个数，第 h 层所有的叶子结点都连续集中在最左边，这就是完全二叉树。（第 h 层可能包含 [1~2h] 个节点）上面的定义看起来比较复杂。所有节点只存在3种情况：1、有左右2个孩子；2、只有左孩子；3、没有孩子（叶节点），即不存在只有右孩子的情况；我们采用层序遍历的方式遍历节点，当遍历到某一个节点，它只有左孩子，或者没有孩子，则后序所有节点一定都是叶节点。如下所示是完全二叉树节点的左子树只包含小于当前节点的数。
数据结构：搜索二叉树
2303_78940834的博客
09-24 1091
在前面我们已经学习了二叉树的基础操作，但是，仅仅是二叉树，没有太大的作用啊，存数据效果没有顺序表和链表好，那为啥还要学二叉树呢？这不就来了嘛，给二叉树增加一些性质，作用不就出来了嘛。本篇文章将介绍二叉树的进阶版本，给二叉树增加了搜索特性，搜索二叉树。
数据结构：图文详解 搜索二叉树（搜索二叉树的概念与性质，查找，插入，删除）
luming的博客
02-01 1859
搜索二叉树（Binary Search Tree，简称BST）是一种树形数据结构，具有以下性质： 1. 每个节点最多有两个子节点，分别称为左子节点和右子节点。 2. 左子节点的值小于父节点的值，右子节点的值大于父节点的值。 3. 中序遍历BST得到的序列是有序的。 BST提供了快速的插入、删除和搜索操作，因为它能够通过比较节点值来减少搜索的范围。比如，要搜索一个值为x的节点，可以从根节点开始，如果x小于当前节点的值，则继续在左子树中搜索，如果x大于当前节点的值，则继续在右子树中搜索。重复这个过程，直到找
二叉树的概念以及搜索二叉树【建议收藏】
x0919的博客
08-20 2385
hello, everyone. Long time no see. 本期文章，我们主要讲解一下二叉树的相关概念，顺便也把搜索二叉树（也叫二叉排序树）讲一下。我们直接进入正题吧！GitHub源码链接 文章目录一、二叉树的概念二、搜索二叉树 一、二叉树的概念 为什么要使用二叉树？ 为什么要用到树呢?因为它通常结合了另外两种数据结构的优点:一种是有序数组，另一种是链表。在树中查找数据项的速度和在有序数组中查找一样快，并且插入数据项和删除数据项的速度也和链表一样。下面，我们先来稍微思考一下这些话题，然后再深
【中等】调整搜索二叉树中两个错误的节点－Java：原问题
了解➔熟悉➔掌握➔精通
07-03 600
package live.every.day.ProgrammingDesign.CodingInterviewGuide.BinaryTree; import java.util.Stack; /** * 调整搜索二叉树中两个错误的节点 * * 【题目】 * 一棵二叉树原本是搜索二叉树，但是其中有两个节点调换了位置，使得这棵二叉树不再是搜索二叉树，请找到这两个错误节点并返回。 * 已知二叉树中所有节点的值都不一样，给定二叉树的头节点head，返回一个长度为２的二叉树节点类型的数组errs，e
二叉树：搜索二叉树和完全二叉树
小菜鸟也想飞的博客
05-02 6025
二叉树：搜索二叉树和完全二叉树
搜索二叉树c语言版本
08-13
搜索二叉树（Binary Search Tree，简称BST）是一种特殊的二叉树数据结构，它具有以下特性：对于树中的任意一个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。...
数据结构搜索二叉树.rar
07-16
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树...
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归）
02-26
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归） 在计算机科学中，数据结构是存储和组织数据的方式，它直接影响到数据的处理效率。搜索二叉树（BST，Binary Search Tree）是一种特殊类型的数据结构，...
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 845
书生浦语大模型实战营第四期：Linux前置基础
第八天: C语言深度探索：指针与函数的奥秘
最新发布
qq_57484399的博客
10-31 576
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
Qt Designer客户端安装和插件集（pyqt5和pyside2）
Good Luck
10-29 625
GitHub - PyQt5/QtDesignerPlugins: Qt Designer PluginsQt Designer Plugins. Contribute to PyQt5/QtDesignerPlugins development by creating an account on GitHub.https://github.com/PyQt5/QtDesignerPlugins https://github.com/PyQt5/QtDesigner/releaseshttps://gith
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1076
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C语言中的数组并非指针：深入理解数组和指针的区别
极客代码
10-29 592
在C语言中，数组和指针是两个非常重要的概念，它们在很多方面有着紧密的联系，但也存在显著的区别。尽管数组名有时可以像指针那样使用，但它们本质上并不是一回事。理解这些差异对于编写正确和高效的代码至关重要。本文将深入探讨数组和指针的区别，并提供一些示例代码。1. 数组与指针的基础概念数组：数组是一系列相同类型数据的集合，它们在内存中连续存储。数组名本身是一个常量，指向数组的起始位置。指针：指针是一个变量，其值为另一个变量的地址。指针可以指向数组中的任何一个元素。2. 数组与指针的相似之处数组名作为指针。
C语言中的野指针以及避免野指针的常用方式
青衫客36的博客
10-29 214
在C语言中，（Dangling Pointer）是指一个指向无效或已释放内存区域的指针。使用野指针会导致不确定的行为，例如程序崩溃、数据损坏，甚至可能带来安全漏洞。freedelete。
C++实现搜索二叉树
05-30
可以使用结构体和指针来实现搜索二叉树，具体实现方法如下： ```c++ #include using namespace std; // 定义二叉树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值