【数据结构取经之路】二叉搜索树的实现

原创 已于 2024-07-18 21:41:04 修改 · 1.1k 阅读 · 22 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

于 2024-07-13 13:37:49 首次发布

目录

前言

二叉搜索树

概念

性质

二叉搜索树的实现

结点的定义

插入

查找

删除

operator= 

拷贝构造 

析构函数 

二叉搜索树完整代码

前言

首先，二叉搜索树是一种数据结构，了解二叉搜素树有助于理解map和set的特性。

二叉搜索树

概念

二叉搜索树又称二叉排序树，它也可能是一棵空树，走中序遍历得到的结果是有序的。

性质

二叉搜索树如果不为空，它应满足一下性质：

● 每一个节点都有一个键值，而且每一个键值唯一标识一个节点（即二叉搜索树所有节点中没有重复的值）

● 假设根节点的值为X，那么它的左子树上的所有节点的值都小于X，右子树上的所有的结点的值都大于X

● 根的左右子树都是二叉搜索树（递归性质）

二叉搜索树的实现

二叉搜索树的基本操作有插入、查找、删除，其中插入和查找好说，最麻烦的是它的删除操作。

结点的定义

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

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

插入

例如要插入0，0比8小，往左走，遇到3，0比3小，往左走，遇到1，0比1小，往左走，遇到空， 此时可以进行插入了。 总结起来就是：遇到空就可以插入。

直接上代码，后边再总结细节~

bool Insert(const K& key)
{
    //如果根节点为空，第一个插入的结点就充当根节点
	if (_root == nullptr)
	{
		Node* newNode = new Node(key);
		_root = newNode;
		return true;
	}

	Node* cur = _root;
	Node* parent = nullptr;
	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->_key == key，该值插入进入会破坏键值的唯一性，故插入失败
		}
	}

    //不知道上述代码是往左走到空还是往右走到空，
    //所以不确定是插入左边还是右边，需要判断
	Node* newNode = new Node(key);
	if (parent->_key > key)
		parent->_left = newNode;
	else
		parent->_right = newNode;

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

删除

上面的都好说，删除才是重头戏。

首先，查找所删除的结点是否在二叉搜索树中，如果不存在则返回false，如果存在就有以下几种情况。

1）要删除的节点为叶子结点

2）要删除的结点只有左孩子或只有右孩子

3）要删除的结点左右孩子均存在

针对第一种情况，直接删除就好，没什么好说的。

针对第二种情况，请看下面分析。

例如要删除的结点为14，根据上图，我们只需要将结点10的指向调整一下，让它指向13就可以了。当然，我们还要记录被删除结点的父节点才可以正确调整指向。仔细想想，就会返现，情况1和情况2是可以一起处理的。

第三种情况：

 

例如要删除结点3，根据上图，如果我们直接删除肯定是不对的，得用替换法来删除。用谁来替换是有讲究的，我们可以选择使用节点3的左子树的最大值或者是节点3右子树的最小值，简记：左的最大，右的最小。处理成下面这样：

 处理成这样后，删除掉rightMin节点即可。当然，rightMin节点也可能有右孩子（它不可能有左孩子，因为我们找的是右子树的最小值，必然是右子树中的最左节点），我们在删除的时候考虑进去就好了，这个并不难解决。下面，我们按照上面的逻辑来把代码写出来~


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

	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 (parent->_left == cur)
					parent->_left = cur->_right;
				else
					parent->_right = cur->_right;

				delete cur;
				return true;
			}
			else if (cur->_right == nullptr)
			{
				if (parent->_left == cur)
					parent->_left = cur->_left;
				else
					parent->_right = cur->_left;

				delete cur;
				return true;
			}
			else
			{
				Node* rightMin = cur->_right;
				Node* rightMinParent = nullptr;

				while (rightMin->_left)
				{
					rightMinParent = rightMin;
					rightMin = rightMin->_left;
				}

				//可以交换，也可以直接赋值
				cur->_key = rightMin->_key;

				rigntMinParent->_left = rightMin->_right;

				delete rightMin;
				return true;
			}
		}
	}
	return false;
}

我试着用上述代码把所有插入的结点都删掉，但是程序崩了~有以下几个原因。

在这种情况下，分析删除值为8的节点。该节点的parent为空， 程序执行下面的代码：

if (cur->_left == nullptr)
{
	if (parent->_left == cur)
		parent->_left = cur->_right;
	else
		parent->_right = cur->_right;

	delete cur;
	return true;
}

这时候就是对空指针的解引用了，程序当然会崩掉~所以需要对parent为空的情况单独处理。把上述代码改成这样：

if (cur->_left == nullptr)
{
	  //左为空的情况习下，parent为可能空，即单支的树，所以需要判断
	  if (parent == nullptr)
	  {
		_root = cur->_right;
	  }
	  else
	  {
		if (parent->_left == cur)
			parent->_left = cur->_right;
		else
			parent->_right = cur->_right;
	  }

	  if (parent->_left == cur)
			parent->_left = cur->_right;
		else
			parent->_right = cur->_right;

		delete cur;
		return true;
}

上面分析的是只有左支的情况，只有右支的情况同样如此，需要做单独处理。

解决了只有单支的情况后，我又试着删除所有节点，程序还是崩了~原因如下：

3为要删除的结点。此时，按照代码逻辑，rightMin为6，rightMinParent为空， 后面执行这句代码：

rigntMinParent->_left = rightMin->_right;

 所以会崩掉~但此时我们可以看到，rightMin（节点6）的父亲结点为3，并不是空，所以rightMinParent初始化为空并不合理，应该初始化为cur。

完善到这步，也还有一个小问题，按照上面修改之后的逻辑，rightMin为6，rightMinParent为3，执行这句代码：

rigntMinParent->_left = rightMin->_right;

 我们可以很容易发现这是错的，应该是rightMinParent->_right = rightMin->_right; 所以我们还需要加判断，具体如下：

if (rightMinParent->_left == rightMin)
	rightMinParent->_left = rightMin->_right;
else
	rightMinParent->_right = rightMin->_right;

完整的修改后的代码如下：


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

	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)
			{
				//左为空的情况习下，parent为可能空，即单支的树，所以需要判断
				if (parent == nullptr)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_left == cur)
						parent->_left = cur->_right;
					else
						parent->_right = cur->_right;
				}

				delete cur;
				return true;
			}
			else if (cur->_right == nullptr)
			{
				if (parent == nullptr)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
						parent->_left = cur->_left;
					else
						parent->_right = cur->_left;
				}

				delete cur;
				return true;
			}
			else
			{
				Node* rightMin = cur->_right;
				Node* rightMinParent = cur;

				while (rightMin->_left)
				{
					rightMinParent = rightMin;
					rightMin = rightMin->_left;
				}

				//可以交换，也可以直接赋值
				cur->_key = rightMin->_key;

				//不一定是rigntMinParent的左边
				if (rightMinParent->_left == rightMin)
					rightMinParent->_left = rightMin->_right;
				else
					rightMinParent->_right = rightMin->_right;

				delete rightMin;
				return true;
			}
		}
	}
	return false;
}

operator= 

赋值重载，只需交换两棵树的根节点即可。

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

拷贝构造 

拷贝构造需要进行深拷贝，可以递归创建节点。

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()
{
	Destroy(_root);
	_root = nullptr;
}

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

二叉搜索树完整代码

//BSTree.h
#pragma once
#include <iostream>

using namespace std;

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

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

template <class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree() = default;

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

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

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

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

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

		if (parent->_key > value)
			parent->_left = newNode;
		else
			parent->_right = newNode;
		return true;
	}

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

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

		return false;
	}

	bool Erase(const K& value)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key < value)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > value)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)
						_root = cur->_right;
					else
					{
						if (parent->_left == cur)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}

					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr)
						_root = cur->_left;
					else
					{
						if (parent->_left == cur)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}

					delete cur;
					return true;
				}
				else
				{
					Node* rightMin = cur->_right;
					Node* rightMinParent = cur;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					cur->_key = rightMin->_key;

					if (rightMinParent->_left == rightMin)
						rightMinParent->_left = rightMin->_right;
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
					return true;
				}
			}
		}
		return false;
	}

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

	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}

	void swap(Node*& root1, Node*& root2)
	{
		Node* tmp = root1;
		root1 = root2;
		root2 = tmp;
	}

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


//test.cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include "BSTree.h"

void Test()
{
	BSTree<int> bst;
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	for (auto val : a)
	{
		bst.Insert(val);
	}

	bst.Inorder();

	BSTree<int> bst2;
	int arr[] = { 8,3,1,10,6,4 };
	for (auto val : arr)
	{
		bst2.Insert(val);
	}

	bst2.Inorder();

	bst2 = bst;

	bst2.Inorder();

	BSTree<int> bst3 = bst2;
	bst3.Inorder();

	cout << bst3.Find(100) << endl;

	for (auto val : a)
	{
		bst3.Erase(val);
		bst3.Inorder();
	}
}

int main()
{
	Test();
	return 0;
}

完~

【数据结构取经之路】图解红黑树
bit_pan的博客
09-20 1183
AVL-tree之外，另一个颇具历史且被广泛使用的平衡二叉搜索树是红黑树(RB-tree)，这名字听起来除了很抽象外，还颇具大哥味哈，会不会很难？客观地说，难度是有的，下面我们细细道来。//结点的颜色//红黑树结点的定义//结点的左孩子//结点的右孩子//结点的父节点//结点的颜色T _data;//结点的数据域{}以上就是红黑树节点定义，但有两个问题：为什么需要指向父节点的指针？为什么要将结点的默认颜色设置成黑色？先来回答第一个问题，在旋转时需要访问父节点，所以引入了指向父节点的指针。
【数据结构取经之路】图解AVL树
bit_pan的博客
09-17 1202
前两点我相信大家都没有疑问，可能有疑问的点在于：为什么需要指向父节点的指针？请看上图，假设值为-1的结点是新插入的结点，那么在插入之前值为1的结点的平衡因子为0。插入值为-1的结点之后，值为1的结点的平衡因子需要更新为-1。新插入的值为0的结点的左右指针均指向空，那么我们如何能找到新插入节点的父节点，然新它的平衡因子呢？这时引入指向父节点的指针就可以帮助我们简单快速的解决这个问题。通过该指针，我们很容易找到每一个节点的父节点，方便插入节点时修改父节点的平衡因子。
二叉排序树
Creame-Cake的专栏
08-05 473
二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树； （4）没有键值相等的结点。 二叉排序树的查找算法： /* 递归查找二叉排序树T中是否存在key, */ /* 指针f指向T的双亲，其初始调用值为NULL */
二叉树学习之二叉查找树
一步一脚印
11-02 3584
写在前面的话 最近接到几个大学同学研究生毕业不是签华为就是签百度,本人取经得到:操作系统、数据结构与算法、网络编程与数据库是面试中利器。想想自己工作2.5年月薪还不到10K,过着苦逼的码农生活,而他们一出校门就是大放光芒(最起码进入的公司就让人觉得牛逼哄哄的).本人痛定思痛,决定下大功夫学习一下数据结构与算法,我想这应该是根本吧. 之前也看过数据结构,但是一看到那乱七八糟的关系,就觉得还是研究
【C++取经之路】set的详细介绍及其使用
bit_pan的博客
09-05 1038
再谈容器，先问一个问题：何为容器？《STL源码剖析》一书中是这么解释的——容器，置物之所也。根据“数据在容器中的排列”特性，容器可以分为序列式容器和关联式容器两种。 序列式容器，其底层为线性序列的数据结构，里面存储的是数据本身。 关联式容器，其底层是红黑树(一种平衡搜索树)，里面存储的是结构的键值对，也是存储数据本身的。set和map均为关联式容器。
二叉树学习之二叉查找树 http://blog.youkuaiyun.com/callinglove/article/details/40707449
诺尔曼
11-25 461
二叉树学习之二叉查找树 标签： 二叉树二叉树图形化二叉查找树二叉树递归遍历 2014-11-02 10:49 1441人阅读 评论(0) 收藏 举报  分类：   ACM&算法（8）  版权声明：本文为博主原创文章，转载请注明出处 目录(?)[+] 写在前面的话 最近接到几个大学同学研究生毕业不是签华为就是签百度,本
【C++取经之路】红黑树封装set
bit_pan的博客
09-24 867
本文参考《STL源码剖析》中SGI STL对红黑树的结构设计，涉及到红黑树迭代器的实现等，所以在读这篇文章之前，我希望你对红黑树有一定的了解，比如在红黑树插入时的变色和旋转操作，最好自己实现过。不然这篇文章对你可能不太友好，因为本文对红黑树的结构设计较为复杂，插入时的操作细节不会在本文详细说明。说实话，封装set对其实很简单，难点在于前期的红黑树设计上，在设计上的一些细节还是很有挑战的。下面我们进入正题，一起领略写SGI STL的大佬们的风采。//旋转时需要访问父节点//颜色//数据域{}
阿里面试：全国14亿人，统计出重名最多的前100个姓名
架构师尼恩
05-30 2505
在计算机科学中，trie，又称前缀树或字典树，使用一些单词来构建Trie树,如下图所示:根节点没有数据从根节点到某一个节点,将他们的路径进行连接就组成了对应的字符串定义:Trie树，又称为前缀树或字典树, 是一种用于高效存储和检索字符串集合的数据结构, 每个节点代表一个字符, 边表示从一个字符到另一个字符的路径, Trie树通过共享相同前缀的节点来节省存储空间Trie树是一种有序树，用于保存关联数组，其中的键通常是字符串。
踩坑了！Mybatis-Plus的使用小技巧，已拿到offer
m0_56835488的博客
04-17 382
程序员：给多少工资，干多少事 我们不是经常会看到一个关于西游记的“悖论”吗： 为什么孙悟空初期大闹天宫的时候那么厉害？因为他自己当老板，打一群天庭的打工仔。 为什么取经路上又变得不行了？作为一个打工仔，去跟一群出来自己创业的妖怪打架。 很多程序员想跟老板说，但又不太敢说，实际却在做的一件事。 事实却是： “拿着10K的工资，做着20K的事，还要操着30K的心！” 其实，这些情况都不奇怪，甚至是人之常情。 part 1Java基础核心技术总结 万事都离不开根基，Java基础对于一些老鸟来说可能已经很熟悉
数据结构习题 (有答案的)
06-28
9. **查找算法**：二分查找、线性查找、二叉搜索树查找等，理解其原理和效率。 10. **动态规划**：在解决一些优化问题时，动态规划可以避免重复计算，提高效率。例如，斐波那契数列、背包问题、最长公共子序列等。 ...
15_嵌入式场景实战：用数据结构优化外设数据处理
C语言无原生OOP特性，却能借结构体+函数指针实现封装、继承、多态，落地工厂等设计模式。博客中以标准C语法实操教学，融入跨平台兼容设计，助开发者掌握C语言OOP核心与工程实践技巧。
01-02 913
嵌入式开发不是“能跑就行”，而是“在有限资源下跑得稳、跑得快”。串口缓存用环形队列、时序数据用链表、协议解析用哈希表——这些看似基础的数据结构，恰恰是解决外设数据处理痛点的关键。今天的代码片段可以直接移植到你的项目中，记得根据MCU型号和实际场景调整参数（如缓冲区大小、哈希表长度）。如果这篇内容帮你解决了实际开发中的问题，别忘了！后续还会分享更多嵌入式实战技巧，比如中断优化、内存管理、低功耗设计等，让你的代码既稳定又高效～
常用SCSI数据结构的详细注释和用法
追赶时代的博客
01-06 301
本文介绍了SCSI协议在USB存储设备中的核心数据结构及其应用。主要内容包括：1) SCSI命令块包装器(CBW)和状态包装器(CSW)的结构与用途，用于USB存储设备的命令封装和状态返回；2) 设备信息查询(INQUIRY)、容量报告(ReadCapacity)和错误感知(SenseData)等关键数据结构；3) 通用SCSI命令表示和请求封装方法。这些数据结构构成了SCSI协议栈的核心，特别适用于光存储项目中设备通信、识别、容量计算和错误处理等场景，为激光器/DMD控制命令的封装和管理提供了完整解决方案
多模态AI 基于工业级编译技术的PLC数据结构解析与映射工具
会周易的程序猿的博客
01-06 1227
stDataCompiler是一款基于工业级编译技术的PLC数据结构解析工具，能够自动解析ST/C99代码中的变量定义并生成标准化JSON描述文件。该工具采用Flex/Bison构建词法语法分析器，实现从预处理、词法分析到AST构建的完整编译流程，支持结构体、联合体等复杂类型的自动提取和内存布局分析。通过CMake集成版本管理功能，输出结构化JSON数据模型，有效解决工业控制系统中底层数据与上层应用间的语义鸿沟问题，为PLC程序调试、系统集成和数据可视化提供统一的数据基础。
数据结构第四章：串
最新发布
zxs的学习打卡博客
01-07 626
摘要：本文系统介绍了数据结构中"串"的基本概念和存储结构。串是由字符组成的有限序列，包括主串、子串和空串三种类型。存储方式主要有定长顺序、堆分配和块链三种，其中堆分配最灵活实用。重点讲解了模式匹配算法，包括暴力匹配法和KMP算法。KMP算法通过next数组避免主串指针回退，时间复杂度为O(m+n)，显著优于暴力法。文章还介绍了KMP的优化方法nextval数组构造，并强调手算next数组是考研重点。
【C语言】堆(Heap)的数据结构与实现：从构建到应用
qq_67169366的博客
01-04 884
结构特性：堆是一棵完全二叉树，意味着除了最后一层，其他层都是满的，且最后一层的节点都靠左排列顺序特性大根堆：父节点的值 ≥ 子节点的值小根堆：父节点的值 ≤ 子节点的值堆顶特性：堆顶元素（根节点）是整个堆中的极值元素操作时间复杂度说明插入O(log n)向上调整删除堆顶O(log n)向下调整获取堆顶O(1)直接访问建堆O(n log n)逐个插入优化建堆O(n)Floyd算法堆排序O(n log n)所有元素出堆。
Matlab入门案例介绍—常用的运算符及优先级
m0_59012156的博客
01-01 597
本文介绍了MATLAB中常用的运算符及其应用。算术运算符包括基本运算（+,-,,/,^）和矩阵运算（.,./,.^）等；关系运算符（==,~=,>,<,>=,<=）用于比较数值或矩阵；逻辑运算符分为元素级（&,|,~）和短路型（&&,||）。文章详细说明了各类运算符的使用方法、应用场景和注意事项，特别强调了矩阵运算与数组运算的区别。最后总结了MATLAB运算符的优先级顺序，括号运算具有最高优先级。这些运算符是MATLAB编程的基础组成部分，广泛应用于矩阵运算、
408真题解析-2009-10-数据结构-排序
tobias的博客
01-04 445
摘要：本文分析2009年一道排序算法选择题，题目要求根据第二趟排序结果反推所用算法。通过排除法：冒泡和选择排序会固定极值位置（不符合），二路归并排序第二趟应有4元素有序段（不符合），最终确定是插入排序（前3个元素有序）。总结各排序算法"趟"的特征：插入排序前k+1个有序，冒泡排序末尾k个有序，选择排序前k个有序，归并排序每2^k个元素有序。答案为B（插入排序）。
【数据结构】实现二叉树
王璐WL的博客
01-06 940
设⼆叉树的根结点所在层数为1，层序遍历就是从所在⼆叉树的根结点出发，⾸先访问第⼀层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，⾃上⽽下，⾃左⾄右逐层访问树的结点的过程就是层序遍历。通常的⽅法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别⽤来给出该结点左孩⼦和右孩⼦所在的链结点的存储地址， 其结构如下：。根结点的左⼦树和右⼦树分别⼜是由⼦树结点、⼦树结点的左⼦树、⼦树结点的右⼦树组成的，因此⼆叉树定义是递归式的，后序链式⼆叉树的操作中基本都是按照该概念实现的。
【C++】JSON核心数据结构解析及JSONCPP使用
Ape's IT Blog
01-04 775
JSON是一种轻量级数据交换格式，基于键值对组织数据，支持字符串、数字、布尔值、null等基础类型，以及对象和数组两种复合结构。JSON对象是无序键值对集合，数组是有序值列表。实际应用中常组合使用对象和数组表示复杂数据，如列表型数据和多层级结构。JSON语法严格，要求键必须用双引号、末尾不能有多余逗号。JsonCpp是C++的JSON处理库，核心类Json::Value可表示所有JSON数据类型，通过类型枚举区分不同结构。JSON广泛应用于前后端交互和数据存储，是跨平台数据交换的首选格式。
西游记取经动画效果的CSS3实现教程
资源摘要信息:"CSS3实现西游记取经动画代码.rar" CSS3是HTML和XHTML的样式表语言，用于描述在屏幕、纸张、语音或其他媒体上元素的呈现方式。CSS3 引入了许多新的功能和模块，极大地增强了CSS的设计和布局能力。CSS3...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值