数据结构_进阶（1）：搜索二叉树

已于 2023-07-15 15:37:07 修改
阅读量512 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c++
于 2023-07-15 14:57:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60630270/article/details/131738359
版权

1.内容

建议再看这节之前能对C++有一定了解

二叉树在前面C的数据结构阶段时有出过，现在我们对二叉树来学习一些更复杂的类型，也为之后C++学习的 map 和 set 做铺垫

  • 1. map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构
  • 2. 二叉搜索树的特性了解，有助于更好的理解map和set的特性
  • 3. 有些OJ题使用C语言方式实现比较麻烦，比如有些地方要返回动态开辟的二维数组。

因此本节文章所涉及到的知识点有很多都会与C++有关

2.搜索二叉树：

🍉搜索二叉树的概念：

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

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

🍉搜索二叉树的操作

 int  a[ ] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };

🍒二叉搜索树的查找

  • 1. 从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
  • 2. 最多查找高度次，走到到空，还没找到，这个值不存在。

🍒搜索二叉树的插入：

插入的具体过程如下：

  • 1. 树为空，则直接新增节点，赋值给root指针
  • 2. 树不空，按二叉搜索树性质查找插入位置，插入新节点

🍒搜索二叉树的删除

删除时搜索二叉树最复杂的地方，他只要分为三种情况：

1. 删除叶子节点

也就是左右都无孩子的节点，直接删除就行

2. 删除只有一个孩子的节点

左孩子为空，或者右孩子为空

这种情况需要将他们的下一个孩子节点接到其父节点上

3.删除两边都有孩子的节点

如删除 8 或者 3

这种清空就比较复杂，我们用替换原则，找左树的最大节点或者去找右树的最小节点来替换。

比如我们要删除8，就需要找左树的最大节点进行替换，左树的最大节点是7，我们将其与放到8的位置，将6的右节点置为空即可

🍉搜索二叉树的实现：

1.创建：

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

	BSTreeNode(const K& key) //初始化列表进行初始化
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

2. 插入操作：

   	bool Insert(const K& key)
	{
		// 1.先判断跟为空
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		// 利用循环判断cur节点的值与插入值的大小，来缺点插入值放到哪
		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;
	}

3.查找操作：

	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;
	}

4.打印操作：

	// 利用递归打印，因为类外拿不到_root，
    // 所以给递归又加了个嵌套函数，用该类内的函数去调_root
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	// 直接写这个函数，在类外面不能调_root，所以传参比较困难
    // 因为_root是私有成员，所以序号再套上面的一层函数
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
    
    // 中序遍历的逻辑打印
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

5.删除操作

上面所说的删除叶子节点的情况，可以直接放到入到第二种情况下一并解决，

在第二种情况的时候需要注意：

这种情况要去判断要删除的节点是否为根节点，如果是就直接把下面的孩子节点换成根节点就行

bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = Find(key);

		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				// 删除
				// 1、左为空
				// 如果此时根节点只有一个孩子，此时要删除根节点，
				// 就不会进入之前的判断，会导致parent为空的空指针问题
                // 可看上图了解
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}

					}
					delete cur;
				} 
				// 2、右为空
				// 如果此时根节点只有一个孩子，此时要删除根节点，
				// 就不会进入之前的判断，会导致parent为空的空指针问题
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else
				{
					// 找右树最小节点替代，也可以是左树最大节点替代
                    // 这里我们用的是右数的最小节点
					Node* pminRight = cur;	// pminRight是minRight的父节点
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						pminRight = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;

					if (pminRight->_left == minRight)
					{
						pminRight->_left = minRight->_right;
					}
					else
					{
						pminRight->_right = minRight->_right;
					}

					delete minRight;
				}
				return true;
			}
		}
		return false;
	}

🍒源代码如下

#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;
public:
    // 插入
	bool Insert(const K& key)
	{
		// 1.先判断跟为空
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		
		Node* parent = nullptr;
		Node* cur = _root;
		// 利用循环判断cur节点的值与插入值的大小，来缺点插入值放到哪
		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;
	}

    // 查找
	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 = Find(key);

		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				// 删除
				// 1、左为空
				// 如果此时根节点只有一个孩子，此时要删除根节点，
				// 就不会进入之前的判断，会导致parent为空的空指针问题
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}

					}
					delete cur;
				} 
				// 2、右为空
				// 如果此时根节点只有一个孩子，此时要删除根节点，
				// 就不会进入之前的判断，会导致parent为空的空指针问题
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else
				{
					// 找右树最小节点替代，也可以是左树最大节点替代
					Node* pminRight = cur;		// pminRight是minRight的父节点
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						pminRight = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;

					if (pminRight->_left == minRight)
					{
						pminRight->_left = minRight->_right;
					}
					else
					{
						pminRight->_right = minRight->_right;
					}

					delete minRight;
				}
				return true;
			}
		}
		return false;
	}


    // 打印
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

private:
	Node* _root = nullptr;
};




//测试
void TestBSTree()
{
	int a[] = { 8, 3, 1, 6, 4, 7, 10, 14, 13 };
	BSTree<int> t1;

    // 循环插入
	for (auto e : a)
	{
		t1.Insert(e);
	}

	t1.InOrder();

	t1.Erase(13);
	t1.Erase(14);
	t1.Erase(10);
	t1.Erase(4);
	t1.Erase(6);
	t1.Erase(3);

	t1.InOrder();
}
int main()
{
	TestBSTree();

	return 0;
}

3.搜索二叉树的性能分析

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

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

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：$log_2 N$
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：$\frac{N}{2}$

如果退化成单支树，二叉搜索树的性能就失去了。
那能否进行改进，不论按照什么次序插 入关键码，二叉搜索树的性能都能达到最优？

所以我们后面还会对AVL树和红黑树做为重点学习

去找咖啡喝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构课程实验四：二叉树线索化相关操作
m0_64198455的博客
12-22 421
实验日期：2022-12-05一、实验目的1、掌握二叉树线索化的建立2、掌握二叉树线索化的遍历3、掌握二叉树线索化的销毁二、实验内容销毁二叉树；
数据结构进阶篇，二叉树路径和专题
descire
05-24 538
113. 路径总和 II  「题目：」  给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。  叶子节点 是指没有子节点的节点。  「示例：」  输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22，输出：[[5,4,...
【数据结构进阶】之搜索二叉树(C++实现)
wszhj_的博客
03-11 1219
二叉搜索树是一种树形结构之一，它是一种特殊的二叉树，它有着这样的性质：1.根的左子树的值都比根的值要小。2.根的右子树的值都要比根的值要大。注意：搜索二叉树的左右子树也是搜索二叉树。
数据结构（Java）：力扣 二叉树面试OJ题（二）【进阶】
2401_83595513的博客
07-17 1443
二叉树面试OJ题（part2）【进阶】🔥🔥🔥
C++学习_进阶——（三）二叉树进阶
graceyun的博客
07-18 473
目录1 二叉搜索树1.1 二叉搜索树概念1.2 二叉搜索树操作1.3 二叉搜索树的实现1.4 二叉搜索树的应用 1 二叉搜索树 1.1 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int a [] = {5,3,4,1,7,8,2,6,0,9}; 1.2 二叉搜索树操作 二叉搜索树的查找 二叉搜
二叉树进阶面试题：二叉树的层序遍历
aaaaauaan的博客
12-22 220
题目： 二叉树的层序遍历 题目描述： 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7], 返回其层序遍历结果： 思路： 先对二叉树的根节点从左向右进行遍历，然后将遍历后的结果放到队列中，然后将队列的首元素进行遍历，进行保存。 第一次遍历1,2，4： 第二次遍历2的左子树3： 第三次遍历4的左右子树： 第四次遍历： /** * Definition for a binary tree no
二叉树进阶面试题 : 二叉树的后序遍历
aaaaauaan的博客
12-22 177
二叉树的后序遍历，非递归实现 思路： 后序遍历：左右根 1 开始找以cur根的所有的左侧节点入栈，此时cur在3的左侧空的位置，因为3的右侧没有节点，因此最后遍历节点3： 2 同理2,1节点。然后4,5节点一次入栈，此时cur在5的左侧开始遍历，没有节点，遍历5的右侧，也没有节点，因此直接遍历5，然后遍历4节点的右侧。 3 遍历6节点同5节点一样，最后遍历4节点，于是所有的节点都遍历完，最后遍历根节点1。 4 最后栈为空。 class Solution { public: vector&l.
数据结构——二叉树进阶
New_learner55的博客
12-28 320
在我看来，在数据结构中，存在三个最经典的树型结构，他们分别是二叉排序树（BST），二叉平衡树（AVL） 和 红黑树（BRT）。 二叉排序树又叫做二叉搜索树，它可以是一棵空树，也可以是具有三个性质的一棵二叉树。 性质一：若它的左子树不为空，则左子树上的所有结点的值均小于它的根结点的值 性质二： 若它的右子树不为空，则右子树上的所有结点的值均大于它的根结点的值 性质三： 左右子树也是二叉排序树。 构造二叉搜索树的目的是提高查找和插入删除关键字的速度。因为二叉排序树是一个排序好的有序数据集，查找的速度肯定是快于无
数据结构进阶篇，二叉树构造专题
descire
05-16 416
105. 从前序与中序遍历序列构造二叉树  「题目：」  给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。  「示例：」  输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]，输出: [3,9,2...
java二叉树算法源码-Java::pencil:计算机基础:hot_beverage:Java:woman_and_man_holding_hands:面向对象:memo:编程题:floppy_disk:数据库:hammer:消息中间件:open_book:系统设计:laptop:工具:wrench:进阶指南:speak-no-evil_monkey:参考资料
06-05
数据结构和算法 4. HTTP 5. Linux :hot_beverage: Java 1. Java 基础 2. Java 容器 3. Java 虚拟机 4. Java 并发 5. JavaIO 6. 正则表达式 :woman_and_man_holding_hands: 面向对象 1. 设计模式 2. 面向对象思想 :...
1-6章课后练习题答案_数据结构_
10-02
这些练习题答案涵盖了从基础到进阶的数据结构概念，旨在帮助学习者深入理解和掌握相关算法。 第1章通常介绍数据结构的基础知识，包括数组、链表、栈和队列等基本概念。数组是最简单但重要的数据结构，提供了随机...
leetcode卡-leetcode_practices_learncard_binarytree:我的leetcode练习二叉树学习卡
07-06
特别是对于二叉树这种重要的数据结构，LeetCode的二叉树题目更是训练者们的热门选择。本资源“leetcode_practices_learncard_binarytree”是一份全面的二叉树学习卡片，作者通过Java8语言完成了所有相关题目，旨在...
C.zip_数据结构_Visual_C++_
08-11
总的来说，“C.zip_数据结构_Visual_C++_”这个资源包是C语言初学者和进阶者的一份宝贵财富。它将帮助你深入理解C语言，掌握数据结构和经典算法，同时利用Visual C++这一强大工具进行实践，从而在编程之路上更进一步...
Java基础，Java进阶，Java数据结构，十大算法
04-04
1. **数组与链表**：基础数据结构，理解它们的时间复杂度和空间复杂度。 2. **栈与队列**：LIFO（后进先出）和FIFO（先进先出）原理，以及如何使用ArrayList和LinkedList实现。 3. **树**：二叉树、平衡树（AVL、...
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 903
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
数据结构之《栈》
2303_81098358的博客
07-24 1289
在之前我们已经学习了数据结构中线性表里面的顺序表与链表，了解了如何实现顺序表与链表增、删、查、该等功能。其实在线性表中除了顺序表和链表还有其他的类别，在本篇中我们就将学习另外一种线性表——栈，在通过本篇的学习后，你将会对栈的结构有充足的了解，在了解完结构后我们还将进行栈的实现。
【数据结构】：用Java实现链表
Yechiel的博客
07-24 1361
本篇文章用Java介绍了：链表的概念，以及单链表的主要功能的具体实现方法
数据结构——双向链表及其总结
2406_83392683的博客
07-23 426
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
C语言与数据结构进阶指南：中级选手实用篇
作者在书中详细讲解了多个关键的数据结构与算法主题，包括排序、搜索、合并等核心概念。以下是各章的主要内容概览： 1. **第一章：排序、搜索与合并** - 介绍了选择排序和插入排序的方法，以及如何保持已排序列表的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值