C++——搜索二叉树

最新推荐文章于 2025-04-05 23:46:25 发布
最新推荐文章于 2025-04-05 23:46:25 发布
阅读量963 收藏 11
点赞数 31
分类专栏： C++学习之路 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/l315225/article/details/136218667
版权
本文介绍了搜索二叉树，其左子树节点键值比根小，右子树比根大，中序遍历键值升序且键值唯一。它有基于键和键值对两种模式，分别有不同应用。还阐述了基于键的搜索二叉树查、增、删的基本操作，包括非递归和递归方式，并提及键值对搜索二叉树的实现差异。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

搜索二叉树

本章思维导图：
在这里插入图片描述注：本章思维导图对应的.xmind和·.png文件都已同步导入至资源，可供免费查阅

1. 基本特点

下图就是一棵经典的搜索二叉树：

在这里插入图片描述

我们规定，例如上图的搜索二叉树中，“48, 25”等这些数字称为每个节点的键值(key)，键值用于确定每个节点在搜索二叉树的位置

可以发现，搜索二叉树具有这样的特点：

  • 左子树每个节点的键值都比根小；右子树每个节点的键值都比根大
  • 如果对搜索二叉树进行中序遍历，那么得到的键值排列是一个升序序列。例如上图：10 25 34 48 61 73 81
  • 由于键值确定了每个节点在树中的位置，因此键值是唯一的，不能重复

2. 两种模式

搜索二叉树基于节点的存储方式可以分为两种不同的模式：**基于键（key）的搜索二叉树和基于键值对（key_value）**的搜索二叉树

2.1 基于键（key）的搜索二叉树

这种结构的搜索二叉树的节点只存储该节点的键值（key），而不存储与键值相关的值value。其结构大致如下：

template<class K>
struct BSTreeNode
{
    typedef BSTreeNode<K> Node;

    Node* _left;	//左孩子
    Node* _right;	//右孩子
    K _key;			//键值
	
    //构造
    BSTreeNode(const K& key)
        : _left(nullptr)
        , _right(nullptr)
        , _key(key)
    {}
};

由于该结构的节点只存储了用于确定位置的键值（key），因此通常用于搜索二叉树节点的查找、删除、插入，而不用于修改操作

现实生活中的应用：

居民小区的汽车门禁系统就可以使用基于键（key）的搜索二叉树

  • 小区内住户的汽车车牌号（key）会被录入小区的门禁系统
  • 当外来车辆要进入时，系统会查找该汽车的车牌号是否被录入了系统，如果没有，就不能放行
  • 同样，当车辆要驶出时，系统同样会查找该汽车的车牌号是否被录入了系统，如果没有，就不能放行

2.2 基于键值对（key_value）的搜索二叉树

这种结构的搜索二叉树的节点不仅存储了该节点的键值（key），也存储了与键值相关联的value值。其结构大致如下：

template<class K, class V>
struct BSTreeNode
{
    typedef BSTreeNode<K, V> Node;

    Node* _left;	//左孩子
    Node* _right;	//右孩子
    K _key;			//键值
    V _value;		//value值
	
    //构造
    BSTreeNode(const K& key, const V& value)
        : _left(nullptr)
        , _right(nullptr)
        , _key(key)
        , _value(value)
    {}
};

由于这种结构的节点存储了与键值（key）相关联的值，因此既可以进行节点的查找，插入，删除操作，也可以对键值（key）对应的value进行修改

现实生活中的应用：

商场的停车场就可以使用基于键值对（key_value）的搜索二叉树

  • 当汽车要驶入商场的停车场时，系统会记录汽车的车牌号（key）以及进入时间（value）
  • 当汽车要驶出商场的停车场时，系统会查找汽车的车牌号（key），通过key来找到进入的时间（value），从而计算出停车费

3. 基本操作

我们以基于键（key）的搜索二叉树为例，来学习搜索二叉树的查找节点、新增节点、删除节点的操作：

3.1 查

查找键值为key的节点

基于搜索二叉树“左子树每个节点的键值都比根小；右子树每个节点的键值都比根大”的特性我么可以很容易的对一个节点进行查找：

  • 如果查找到节点的键值比根的键值大，那么就去跟得右子树找
  • 如果查找到节点的键值比根的键值小，那么就去跟得左子树找

例如：

在这里插入图片描述

非递归版本：

//找到了就返回真true
//没找到就返回假false
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 _findR(Node* root, const K& key)
{
    if (root == nullptr)
        return false;

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

/*
也可以写成：
bool _findR(Node* root, const K& key)
{
	if (root == nullptr)
		return false;

	return root->_key == key || _findR(root->_left, key) || _findR(root->_right, key);
}
*/

3.2 增

新增节点，该节点的键值为key

3.2.1 非递归

要新增节点，首先就要找到新增节点的位置。这和查找节点的步骤类似:

  • 当走到空nullptr时，该位置就是新增节点的位置
  • 但需要注意，如果在查找的过程中碰到已有节点的键值等于key的情况，就不能继续插入了（键值唯一）
Node* cur = _root;
while (cur)
{
    parent = cur;
    if (cur->_key > key)
        cur = cur->_left;
    else if (cur->_key < key)
        cur = cur->_right;
    else
        return false;
}

在这里插入图片描述

但是，这只是找到了新增节点插入的位置，我们还需要建立父亲和孩子的连接因此在找插入位置cur的同时也需要保存cur的父亲parent。完整的代码为：

bool insert(const K& key)
{
    Node* newNode = new Node(key);

    if (_root == nullptr)
    {
        _root = newNode;
        return true;
    }

    Node* parent = _root;	//保存插入位置的父亲
    Node* cur = _root;		//寻找插入位置
    while (cur)
    {
        parent = cur;
        if (cur->_key > key)
            cur = cur->_left;
        else if (cur->_key < key)
            cur = cur->_right;
        else
            return false;
    }
	
    //如果key大于父亲，就插在父亲的右边
    //否则插在父亲的左边
    if (key > parent->_key)
        parent->_right = newNode;
    else
        parent->_left = newNode;

    return true;
}

3.2.2 递归

递归版本同样也面临着新增节点和父亲的连接问题。

解决办法之一就是向函数的形参中加一个参数，用于保存父节点，但其实还有另一种更巧妙的方法：

我们可以利用引用，将待插入的nullptr直接变为新增的节点，这样就可以省去连接的步骤了：

在这里插入图片描述

bool _insertR(Node*& root, const K& key)
{
    if (root == nullptr)
    {
        Node* newNode = new Node(key);
        root = newNode;

        return true;
    }

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

3.3 删

删除键值为key的节点

3.3.1 非递归

第一步肯定是要先找到要被删除的节点，同时为了保证删除后搜索二叉树结构的正确性和完整性，肯定需要保存该节点的父亲来连接这个节点的左右孩子

Node* parent = _root;
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
    {
        //开始插入
    }
}

根据被删除节点的左右孩子可以分为三种情况：

情况一——被删除的节点没有左右孩子：

在这里插入图片描述

则，如果被删除的节点为父亲的左孩子，则让父亲的左孩子连接到被删除节点的任意一个nullptr即可；被删除节点为父亲的右孩子同理

在这里插入图片描述

情况二——被删除的节点有一个孩子：

在这里插入图片描述

此时，我们可以将被删除节点的孩子托管给父亲。具体分析如下：

如果被删除节点为父亲的右孩子，那么：

  • 如果被删除节点的左孩子不为空，就将被删除节点的左孩子连接到父亲的右孩子
  • 如果被删除节点的右孩子不为空，就将被删除节点的右孩子连接到父亲的右孩子

如果被删除节点为父亲的左孩子，那么：

  • 如果被删除节点的左孩子不为空，就将被删除节点的左孩子连接到父亲的左孩子
  • 如果被删除节点的右孩子不为空，就将被删除节点的右孩子连接到父亲的左孩子

在这里插入图片描述

情况三——被删除的节点左右孩子都有：

在这里插入图片描述

此时就不能将左右孩子托管给父亲了，因为父亲可能连接了其他节点

因此，我们需要采取一种新方法——替换法：

我们需要在被删除节点的左子树或右子树找到一个节点，并替换被删除的节点。

该节点满足的条件是：键值大于左子树的所有节点，小于右子树的所有节点。

因此，有两个满足该条件的节点：左子树最右边的节点（即左子树的最大节点）；右子树最左边的节点（即右子树的最小节点）

在这里插入图片描述

实现代码：

bool erase(const K& key)
{
    assert(_root);

    Node* parent = _root;
    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
        {
            //如果被删除节点的左子树为空
            //这里也包含了被删除节点左右子树都为空的情况
            if (cur->_left == nullptr)
            {
                if (cur == parent)
                    _root = cur->_right;
                else if (cur == parent->_left)
                    parent->_left = cur->_right;
                else
                    parent->_right = cur->_right;

                delete cur;
                return true;
            }
            //如果被删除节点的右子树为空
            else if (cur->_right == nullptr)
            {
                if (cur == parent)
                    _root = cur->_left;
                else if (cur == parent->_left)
                    parent->_left = cur->_left;
                else
                    parent->_right = cur->_left;

                delete cur;
                return true;
            }
            //如果被删除的节点左右子树都存在
            else
            {
                //找到右子树的最小节点和最小节点的父亲
                Node* rightMin = cur->_right;
                Node* rightParent = cur;
                while (rightMin->_left)
                {
                    rightParent = rightMin;
                    rightMin = rightMin->_left;
                }
				
                //将被删除节点的键值key替换为右子树的最小节点的键值
                cur->_key = rightMin->_key;
				
                //保持右子树的最小节点的子树的连接
                if (rightMin == rightParent->_right)
                    rightParent->_right = rightMin->_right;
                else
                    rightParent->_left = rightMin->_right;

                delete rightMin;
                return true;
            }
        }
    }

    return false;
}

3.3.2 递归

这里为了处理好被删除节点的子树和被删除节点的父亲的连接关系，同样需要用到引用：

bool _eraseR(Node*& root, const K& key)
{
    if (root == nullptr)
        return false;

    if (root->_key > key)
        return _eraseR(root->_left, key);
    else if (root->_key < key)
        return _eraseR(root->_right, key);
    else
    {
        //记录要被删除的节点
        Node* del = root;

        if (root->_left == nullptr)
            root = root->_right;
        else if (root->_right == nullptr)
            root = root->_left;
        else
        {
            //找到右子树的最小节点
            Node* rightMin = root->_right;
            while (rightMin->_left)
                rightMin = rightMin->_left;
			
            //交换被删除节点和右子树最小节点的键值
            swap(root->_key, rightMin->_key);
			
            //执行到这一步，要被删除的键值为key的节点一定不会有两棵子树
            //继续递归到右子树即可
            return _eraseR(root->_right, key);
        }

        delete del;
        return true;
    }
}

4. 基于键（key）的搜索二叉树的实现代码

namespace key
{
	template<class K>
	struct BSTreeNode
	{
		typedef BSTreeNode<K> Node;

		Node* _left;
		Node* _right;
		K _key;

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

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

		BSTree() = default;	//强制生成构造

		BSTree(const BSTree<K>& tree)
		{
			_root = copy(tree._root);
		}

		BSTree<K>& operator= (BSTree<K> tree)
		{
			swap(_root, tree._root);

			return *this;
		}

		~BSTree()
		{
			destory(_root);
		}

		void inorder()
		{
			_inorder(_root);
			cout << endl;
		}

		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 insert(const K& key)
		{
			Node* newNode = new Node(key);

			if (_root == nullptr)
			{
				_root = newNode;
				return true;
			}

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

			if (key > parent->_key)
				parent->_right = newNode;
			else
				parent->_left = newNode;

			return true;
		}

		bool erase(const K& key)
		{
			assert(_root);

			Node* parent = _root;
			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
				{
					if (cur->_left == nullptr)
					{
						if (cur == parent)
							_root = cur->_right;
						else if (cur == parent->_left)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;

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

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

						cur->_key = rightMin->_key;

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

						delete rightMin;
						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:
        Node* _root = nullptr;
        
		Node* copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;

			Node* newNode = new Node(root->_key);
			newNode->_left = copy(root->_left);
			newNode->_right = copy(root->_right);

			return newNode;
		}

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

			destory(root->_left);
			destory(root->_right);
			delete root;
		}

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

			_inorder(root->_left);
			cout << root->_key << ' ';
			_inorder(root->_right);
		}

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

			return root->_key == key || _findR(root->_left, key) || _findR(root->_right, key);
		}

		bool _insertR(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				Node* newNode = new Node(key);
				root = newNode;

				return true;
			}

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

		bool _eraseR(Node*& root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key > key)
				return _eraseR(root->_left, key);
			else if (root->_key < key)
				return _eraseR(root->_right, key);
			else
			{
				Node* del = root;

				if (root->_left == nullptr)
					root = root->_right;
				else if (root->_right == nullptr)
					root = root->_left;
				else
				{
					Node* rightMin = root->_right;
					while (rightMin->_left)
						rightMin = rightMin->_left;

					swap(root->_key, rightMin->_key);

					return _eraseR(root->_right, key);
				}

				delete del;
				return true;
			}
		}
	};
}

5. 基于键值对（key_value）的搜索二叉树

key_value搜索二叉树的实现和key搜索二叉树的实现基本相同，只有查找结点和新增节点这两个操作有所不同，故下面只展示这两部分：

namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		typedef BSTreeNode<K, V> Node;

		Node* _left;
		Node* _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
	{
	public:
		typedef BSTreeNode<K, V> Node;

		BSTree() = default;

		BSTree(const BSTree<K, V>& tree)
		{
			_root = copy(tree._root);
		}

		BSTree<K, V>& operator= (BSTree<K, V> tree)
		{
			swap(_root, tree._root);

			return *this;
		}

		~BSTree()
		{
			destory(_root);
		}

		void inorder()
		{
			_inorder(_root);
			cout << endl;
		}

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

		bool insert(const K& key, const V& value)
		{
			Node* newNode = new Node(key, value);

			if (_root == nullptr)
			{
				_root = newNode;
				return true;
			}

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

			if (key > parent->_key)
				parent->_right = newNode;
			else
				parent->_left = newNode;

			return true;
		}

		bool erase(const K& key)
		{
			assert(_root);

			Node* parent = _root;
			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
				{
					if (cur->_left == nullptr)
					{
						if (cur == parent)
							_root = cur->_right;
						else if (cur == parent->_left)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;

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

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

						cur->_key = rightMin->_key;

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

						delete rightMin;
						return true;
					}
				}
			}

			return false;
		}

		Node* findR(const K& key)
		{
			return _findR(_root, key);
		}

	private:
		Node* _root = nullptr;

		Node* _findR(Node* root, const K& key)
		{
			if (root == nullptr)
				return nullptr;

			Node* ret = nullptr;
			if (root->_key > key)
				ret = _findR(root->_left, key);
			else if (ret == nullptr && root->_key < key)
				ret = _findR(root->_right, key);
			else
				ret = root;

			return ret;
		}

		Node* copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;

			Node* newNode = new Node(root->_key);
			newNode->_left = copy(root->_left);
			newNode->_right = copy(root->_right);

			return newNode;
		}

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

			destory(root->_left);
			destory(root->_right);
			delete root;
		}

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

			_inorder(root->_left);
			cout << root->_key << ' ';
			_inorder(root->_right);
		}
	};
}
数据结构（C++）上课笔记——线索二叉树的概念与C++实现(2020-5-12).doc
05-21
数据结构（C++）上课笔记——线索二叉树的概念与C++实现 线索二叉树是一种特殊的二叉树结构，它在二叉树的基础上添加了线索的概念，使得每个结点除了有左右孩子外，还有指向前驱和后继的指针。这种结构可以提高...
【C++】————搜索二叉树
bhbcdxb123的博客
07-22 2127
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。正所谓：君子可内敛不可懦弱，面不公可起而论之。3.成年人的世界，只筛选，不教育。
C++——搜索二叉树及其模拟实现
fsbwb的博客
10-02 89
情况d:在它的右子树中寻找中序下的第一个节点（关键值最小），用它的值填补到被删除节点中，再来处理该节点的删除问题——替换法删除。情况b:删除该节点且使被删除节点的双亲节点指向被删除节点的左孩子节点——直接删除。情况c:删除该节点且使被删除节点的双亲节点指向被删除节点的右孩子节点——直接删除。2、KV模型：每一个关键码key，都有与之对应的值value，构建一颗搜索二叉树。·若它的左子树不为空，则左子树上的所有节点的值都小于根节点的值。·若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。
数据结构C++——二叉树和树
qq_60987997的博客
07-23 1304
设完全二叉树中一元素的序号为i, 1≤i≤n。，存在两个不同的二叉树，经过中序遍历都能得到这个结果。但实际上，这两颗二叉树想要实际表达的算式并不相同。与我们希望得到的最为接近。(复制、删除、输出等)。：按照树的层级，从上到下、从左到右依次遍历。：可以看作是缺少了部分元素的完全二叉树。设二叉树中元素数目为n。（前缀和后缀表达式中不会存在歧义）的次序访问树中元素，在同一层中，比如：家庭关系、公司组织……在二叉树的遍历中，每个元素。得到的表达式分别称为其的。树(tree)t是一个。实现，层次遍历通常借助。
C++——二叉树（进阶）
2301_80342122的博客
11-02 3377
二叉搜索树又称，它或是，又或是具有的二叉树:若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树可以观察到，对这棵树进行的话，可以得到一串升序的数据如果左子树放大的数据，右子树放小的数据，那么中序遍历就是降序了。
C++——平衡二叉树的判断
Vincent的博客
04-21 2165
给定一个二叉树，编程判断其是否是一个二叉平衡树。我们以Leetcode 110题为例来看。 平衡二叉树 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 ...
C++——二叉树
m0_74515566的博客
02-10 745
先铺垫二叉搜索树，而二叉搜索树也是一种树形结构。
C++笔记——平衡二叉树
永不秃头的三三的博客
02-08 1005
通过C++手撕一个平衡二叉树，实现插入、删除、查找、打印功能，以巩固自己的基础以及方便日后复习。
【C++详解】——搜索二叉树
weixin_69519040的博客
04-22 737
本文介绍了搜索二叉树的原理，并且模拟实现了一个搜索二叉树，其中插入、删除、查找功能分别使用了递归和非递归两种实现方式。本文还介绍了两种搜索二叉树的应用场景，根据相应的应用场景将搜索二叉树改造成了KV结构。 本文详细代码链接：https://gitee.com/hrimkn
数据结构C++——二叉树的实现
m0_63064861的博客
10-27 1688
二叉树的实现 计算二叉树深度方法 计算二叉树结点个数方法：（R+L+D=结点个数） 计算叶子结点的个数方法
【数据结构】C++——平衡二叉树的插入及删除代码
m0_62272738的博客
10-05 147
【代码】【数据结构】C++——平衡二叉树的插入及删除代码。
OpenCV 图形API（9）用于执行矩阵与标量之间的逐元素除法操作函数divC()
jndingxin的专栏
04-02 467
矩阵除以标量。
STL剖析
qq_56913257的博客
04-05 709
是一个封装了动态大小数组的顺序容器；数组内容器严格按照线性顺序排序，支持随机访问，因此提供随机访问指针，例如vector::iterator ivite;并且为了降低空间配置得速度成本，vector实际分配大小要比需求大一点。size()表示目前实际存储的大小，capacity()表示分配的空间大小，是要大于size的，start表示起始地址，finish表示最后一个数据地址，end_of_storage表示分配的最后地址。如果容量不足，容量会扩充至二倍，如果依旧不足，那就直接扩充到足够大的容量。构造函数。
剑指Offer（数据结构与算法面试题精讲）C++版——day4
weixin_46560512的博客
04-03 655
剑指Offer（数据结构与算法面试题精讲）C++版——day4 题目一：和为k的子数组 题目二：0和1个数相同的子数组 题目三：左右两边子数组的和相等
C/C++归纳2
weixin_68746494的博客
04-02 1150
C/C++归纳
C++蓝桥杯实训篇（二）
最新发布
qq_74336191的博客
04-05 1157
嗨咯~小伙伴们！今天我们来一起学习算法和贪心思维，准备好了吗？咱们开始咯！
基于kotlin native的C与kotlin互相调用
lc999102的专栏
04-02 975
本文测试环境为ubunut，没有使用IDE；从基本层面了解kotlin native环境中，C和kotlin的编译，互相调用。
循环练习题 c语言
m0_65413802的博客
04-02 197
例如：12321是对称数，输出Yes；124不是对称数，输出No。
C++数据结构——中序遍历二叉树
05-23
中序遍历是二叉树遍历的一种，遍历顺序为左子树、根节点、右子树。以下是C++代码实现： ```c++ #include <iostream> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; void inorderTraversal(TreeNode* root) { if(root == NULL) return; inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } int main() { TreeNode* root = new TreeNode(1); root->right = new TreeNode(2); root->right->left = new TreeNode(3); inorderTraversal(root); return 0; } ``` 输出结果为：1 3 2 这里我们只是简单地输出了遍历的结果，实际应用中可以对遍历到的节点进行其他操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Forward♞

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

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

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

打赏作者

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

抵扣说明：

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

余额充值