C++ 二叉搜索树

已于 2024-05-18 15:58:58 修改
阅读量46 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-05-29 22:17:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66409987/article/details/130921338
版权

目录

前言

二叉搜索树

概念

 二叉搜索树的应用

 K模型

KV模型

实现二叉搜索树

总的框架

插入函数

查找函数

中序遍历

删除函数（重点）

拷贝构造

赋值重载

析构函数

完整代码

性能分析

补充KV模型的部分实现

K模型递归实现

前言

        二叉搜索树为后序所学的 map 和 set 做准备

二叉搜索树

概念

二叉搜索树（BST，Binary Search Tree）又称二叉排序树，它可以是一棵空树

二叉树搜索树具有以下性质:

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

 下面就是一颗二叉搜索树

 二叉搜索树的应用

 K模型

K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。 比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

将每个单词作为key，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
这种实现方式通过上面的代码的Find就可以完成，只不过模板参数转化成了string类型。

KV模型

KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方
式在现实生活中非常常见：

如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
文单词与其对应的中文<word, chinese>就构成一种键值对；
再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
现次数就是<word, count>就构成一种键值对。

实现二叉搜索树

总的框架

                我们首先需要封装一个节点类，结点类当中包含三个成员变量：结点的值、左指针、右指针，结点类当中只需实现一个构造函数即可

二叉搜索树类（BSTree）里面的成员变量只要包含一个根节点 _root 即可

为了书写简单，对 BSTreeNode 进行 typedef 为 Node

template<class K>
// K 模型
struct BSTreeNode  // Binary Search Tree Node
{
    K _key;
    BSTreeNode<K>* _left;
    BSTreeNode<K>* _right;

    BSTreeNode(const K& key)
        :_key(key)
        , _left(nullptr)
        , _right(nullptr)
    {}
 
};
 
template<class K>
class BSTree  // Binary Search Tree 二叉搜索树
{
    typedef BSTreeNode<K> Node;
public:
    //构造函数 构造一个空树
    BSTree()
        :_root(nullptr)
    {}
    //拷贝构造
    BSTree(const BSTree<K>& t)
    {}
    //赋值重载
    BSTree<K>& operator=(BSTree<K> t)
    {}
    //析构
    ~BSTree()
    {}
 
    bool Insert(const K& key)
    {}
 
    bool Find(const K& key)
    {}
 
    bool Erase(const K& key)
    {}
    //中序遍历树
    void InOrder()
    {}
 
private:
    Node* _root;
};

插入函数

根据二叉搜索树的性质，其插入操作非常简单：

  1. 如果是空树，则直接将插入结点作为二叉搜索树的根结点
  2. 如果不是空树，则按照二叉搜索树的性质进行结点的插入

若不是空树，插入结点的具体操作如下：

  • 若待插入结点的值小于根结点的值，则需要将结点插入到左子树当中
  • 若待插入结点的值大于根结点的值，则需要将结点插入到右子树当中
  • 若待插入结点的值等于根结点的值，则插入结点失败（二叉搜索树）

插入成功返回 true，插入失败返回 false

    // 不可能存在在中间插数据，就是要插入在下面为空的位置
	// 一样的数据，不同的插入顺序会形状不一样
	bool insert(const K& key)  
	{
		if (nullptr == _root)
		{
			_root = new Node(key);
			return true;
		}

		Node* cur = _root;
		Node* parent = cur;
		while (cur)
		{
			parent = cur; // 记录上一个
			if (cur->_key > key)
				cur = cur->left;
			else if (cur->_key < key)
				cur = cur->right;
			else
				return false;
		}
		cur = new Node(key);
		if (parent->_key > key) // 与上一个连接起来
			parent->left = cur;
		else if (parent->_key < key)
			parent->right = cur;
		return true;

	}

查找函数

        找到返回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;
	}

中序遍历

        二叉搜索树进行中序遍历，遍历出来的结果是有序的（升序），二叉搜索树一般都是去重的，即没有相同的值

//遍历树
void InOrder()
{
    _InOrder(_root); // 因为_root是私有的,需要另写一个函数
    cout << endl;
}
 
private:
    // 中序遍历
    void _InOrder(Node* root)
    {
        if (root == nullptr)
        {
            return;
        }
        _InOrder(root->_left);
        cout << root->_key << " ";
        _InOrder(root->_right);
    }

删除函数（重点）

     两种情况
       1、如果要删除的Node的左为空，则他的父亲指向Node的右，
            如果要删除的Node的右为空，则他的父亲指向Node的左。
            最后删除自己
              叶子结点也适用

            特殊情况：删除根节点时(没有父亲)，将Node的左或Node的右设置为新的根。

        左为空删除的情况(右边是一样的)：

特殊情况

 ​​​​​​

 下面是代码实现：

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


          2、 如果要删除的Node的左右都不为空，不能直接删除，使用替代法
               可以找左子树的最大的结点(key)或者找右子树的最小的结点(key)去替代要删除的Node
                          (左子树最右边的节点 )                              (右子树最左边的结点)

 

示例   寻找右子树的最小的结点去替代要删除的Node(寻找左子树的最大的结点去替代要删除的Node是一样的)：

 特殊情况：

 代码实现：

				else//替换删除
				{
					
					Node* parent = cur;
					Node* minright = cur->right;
					while (minright->left)  // 找右子树最小的结点
					{
						parent = minright;
						minright = minright->left;
					}

					cur->_key = minright->_key;
					if (minright == parent->left)
					{
						parent->left = minright->right; // 连接上最小节点(最左边)的右边
					}
					else
					{
						parent->right = minright->right; // 当循环没有进去时(特殊情况)
					}

					delete minright;
				}
				return true;
			}

拷贝构造

//拷贝构造
BSTree(const BSTree<K>& t)
{
    _root = Copy(t._root);
}
 
private:
    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(_root, t._root);
    return *this;
}

析构函数

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

完整代码

#pragma once

namespace hek1{
// K 模型
template<class K>
struct BSTreeNode // Binary Search Tree Node
{
	BSTreeNode<K>* left;
	BSTreeNode<K>* right;
	K _key;
	BSTreeNode(const K& key)
		:_key(key)
		,left(nullptr)
		,right(nullptr)
	{}

};

template<class K>
class BSTree // Binary Search Tree 二叉搜索树
{
	typedef BSTreeNode<K> Node;
public:

	//构造函数
	BSTree()
		:_root(nullptr)
	{}

	//拷贝构造
	BSTree(const BSTree<K>& t)
	{
		_root = Copy(t._root);
	}


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

	//析构
	~BSTree()
	{
		Destroy(_root);
		_root = nullptr;
	}




	// 不可能存在在中间插数据，就是要插入在下面为空的位置
	// 一样的数据，不同的插入顺序会形状不一样
	bool insert(const K& key)  
	{
		if (nullptr == _root)
		{
			_root = new Node(key);
			return true;
		}

		Node* cur = _root;
		Node* parent = cur;
		while (cur)
		{
			parent = cur;  // 记录上一个
			if (cur->_key > key)
				cur = cur->left;
			else if (cur->_key < key)
				cur = cur->right;
			else
				return false;
		}
		cur = new Node(key);
		if (parent->_key > key) // 与上一个连接起来
			parent->left = cur;
		else if (parent->_key < key)
			parent->right = 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;
	}

	// 两种情况
	//   1、如果要删除的Node的左为空，则他的父亲指向Node的右，
	//		如果要删除的Node的右为空，则他的父亲指向Node的左。
	//		最后删除自己
			//  叶子结点也适用
	//	 2、 如果要删除的Node的左右都不为空，不能直接删除，使用替代法
	//		可以找左子树的最大的结点(key)或者找右子树的最小的结点(key)去替代要删除的Node
	//					最右边的节点				 最左边的结点				
	bool earse(const K& key)
	{

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{

			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->left;
			}
			else
			{
				//1.左为空
				//2.右为空
				//3.左右都不为空，替换删除
				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;
				}
				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* parent = cur;
					Node* minright = cur->right;
					while (minright->left)  // 找右子树最小的结点
					{
						parent = minright;
						minright = minright->left;
					}

					cur->_key = minright->_key;
					if (minright == parent->left)
					{
						parent->left = minright->right; // 连接上最小节点(最左边)的右边
					}
					else
					{
						parent->right = minright->right; // 当循环没有进去时
					}

					delete minright;
				}
				return true;
		 2
		//else
		//{
		//	Node* cur2 = cur->left; // 左子树
		//	Node* parent2 = cur;
		//	while (cur2->right)// 找左子树最大的结点
		//	{
		//		parent2 = cur2;
		//		cur2 = cur2->right;
		//	}

		//	// 替代删除
		//	cur->_key = cur2->_key;

		//	// 第一个结点的下一个
		//	if (parent2->right ==  cur2) { 
		//		parent2->right = cur2->left;
		//	}
		//	else { // 当循环没有进去时
		//		parent2->left = cur2->left;
		//	}
		//	delete cur2;
        // }
		//	return true;

			}


		}
		return false;
	}

	void _InOrder(Node* root) // 注意是Node* 类型的
	{
		if (root == nullptr) return;

		_InOrder(root->left);
		cout << root->_key <<" ";
		_InOrder(root->right);

	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:
	Node* _root = nullptr;

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

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

}

性能分析

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树

对于有n个结点的二叉搜索树：

1、最优的情况下，二叉搜索树为完全二叉树，其平均比较次数为：O(logN)

2、最差的情况下，二叉搜索树退化为单支树，其平均比较次数为：O(N / 2)

         所以实际上，，二叉搜索树在极端情况下是没办法保证效率的，因此由二叉搜索树又衍生出来了AVL树、红黑树，

补充KV模型的部分实现

#pragma once

template<class K,class V>
struct BSTreeNode // Binary Search Tree Node
{
	BSTreeNode<K,V>* left;
	BSTreeNode<K,V>* right;
	K _key;
	V _value;  //  添加value
	BSTreeNode(const K& key, const V& value)
		:_key(key)
		,_value(value)
		, left(nullptr)
		, right(nullptr)
	{}

};

// 
template<class K,class V>
class BSTree // Binary Search Tree 二叉搜索树
{
	typedef BSTreeNode<K,V> Node;
public:
	// 不可能存在在中间插数据，就是要插入在下面为空的位置
	// 一样的数据，不同的插入顺序会形状不一样
	bool insert(const K& key,const V& value)
	{
		if (nullptr == _root)
		{
			_root = new Node(key,value);
			return true;
		}

		Node* cur = _root;
		Node* parent = cur;
		while (cur)
		{
			parent = cur;
			if (cur->_key > key)
				cur = cur->left;
			else if (cur->_key < key)
				cur = cur->right;
			else
				return false;
		}
		cur = new Node(key,value);
		if (parent->_key > key)
			parent->left = cur;
		else if (parent->_key < key)
			parent->right = 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 nullptr;
	}


	void _InOrder(Node* root) // 注意是Node* 类型的
	{
		if (root == nullptr) return;

		_InOrder(root->left);
		cout << root->_key << ":" << root->_value<<endl;
		_InOrder(root->right);

	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:
	Node* _root = nullptr;

};


}

K模型递归实现

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()//构造
		:_root(nullptr)
	{}

	BSTree(const BSTree<K>& t)//不能直接insert，因为顺序不一样，形状不一样
	{
		_root = Copy(t._root);
	}

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

	~BSTree()//析构
	{
		Destory(_root);
		_root = nullptr;
	}

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

	// 递归版本实现插入、删除和查找
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}
	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

private:
	void Destory(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		Destory(root->_left);
		Destory(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;
	}

	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->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* minright = root->_right;
				while (minright->_left)
				{
					minright = minright->_left;
				}
				swap(root->_key, minright->_key);//交换之后，递归到子树删交换的值，当然直接赋值不删也行，不过递归删掉就不是key了
				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
	}
	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)
		{
			return true;
		}
		else if (root->_key > key)
		{
			_FindR(root->_left, key);
		}
		else
		{
			_FindR(root->_right, key);
		}
	}

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

插衣袖里
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 二叉搜索树(BST)的实现方法
08-30
主要介绍了C++ 二叉搜索树(BST)的实现方法，非常不错，具有参考借鉴价值，需要的的朋友参考下
C++二叉搜索树
默的博客
05-05 521
C++二叉搜索树1、概念2、操作2.1增加（插入）2.2删除2.3查找2.4修改3、 二叉搜索树的性能分析4、模拟实现代码 1、概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树。 2、操作 2.1增加（插入） 树为空，直接插入，返回true； 树不为空，判断根节点数据大小，根数据大往左边找，否则往右边找，找到返回true；
C++ 二叉搜索树BinarySearchTree
冰果滴的博客
07-30 950
二叉搜索树是为学习map和set做的铺垫，了解了二叉搜索树的特性，有助于更好的理解map和set。
c++ 二叉搜索树
Hedenghui777的博客
06-22 253
在这里为什么我们需要学习二叉搜索树呢？ map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构。 二叉搜索树的特性了解，有助于更好的理解map和set。 1.二叉搜索树 1.1 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int a [] = {5,3,4,1,7,8,2,6,0,9}; 1.
【C++】二叉搜索树
qq_62939852的博客
04-18 897
从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。 最多查找高度次，走到到空，还没找到，这个值不存在非空右子树的所有值大于根节点的值 左右子树都是二叉搜索树第一个不满足，因为值为5的节点在值为10的节点的右边，正常来说10的右边都应该比10大分为两种情况 若插入的值在二叉树中不存在，则通过比较进行插入若插入11，因为11比8大，所以跟10比较，而11比10大，所以走10的右子树14，14与11比较，因14>11，所以走14的左子树13，11与13比较，因13>11，故作为13的左子树，遇见NU
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现的二叉搜索树的查找算法，查找效率高，速度快，欢迎交流和谈论
C++二叉搜索树的插入和删除例子
05-29
很简单的一个例子！非常适合新手观看！！！！！！！！！！！！！！！！！！！！！
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
C语言.动态内存管理
Joseit的博客
05-16 587
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
c语言操作注意事项
dropLin的博客
05-20 112
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
C语言之函数指针（持续更新）
qq_47607743的博客
05-20 252
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 896
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
C语言自定义类型:结构体
最新发布
wer24_25的博客
05-20 850
本文详细讲解了结构体的创建和结构体的内存对齐,还涉及了结构体的传参和结构体实现位段,轻松易懂,小白可入.
【C语言深度解剖】(14)：结构体内存对齐（详细配图讲解）
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-20 411
一篇文章带你学会结构体的内存对齐！！超多精美配图！
C语言星号带括号的情形
bcbobo21cn的专栏
05-11 81
C语言星号，当星号右侧是一个指针变量，星号和指针变量可看作一个整体，表示的是指针变量所指的内容；
STL--set和multiset集合
m0_75266675的博客
05-20 635
STL--set和multiset集合
C++ 复习 -- 构造和析构
mx_jun的博客
05-14 889
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造的是什么呢？构造成员变量的初始化值，内存空间等构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
c++二叉搜索树详细代码
04-20
很高兴回答你的问题！以下是C语言实现的二叉搜索树详细代码： ``` #include <stdio.h> #include <stdlib.h> typedef struct TreeNode { int data; struct TreeNode *left; struct TreeNode *right; } TreeNode; /* 创建一个新的结点 */ TreeNode *createNode(int data) { TreeNode *newNode = (TreeNode *)malloc(sizeof(TreeNode)); newNode->data = data; newNode->left = NULL; newNode->right = NULL; return newNode; } /* 将新结点插入二叉搜索树中 */ TreeNode *insert(TreeNode *node, int data) { if (node == NULL) { return createNode(data); } else if (data < node->data) { node->left = insert(node->left, data); } else if (data > node->data) { node->right = insert(node->right, data); } return node; } /* 中序遍历二叉搜索树 */ void inorderTraversal(TreeNode *node) { if (node != NULL) { inorderTraversal(node->left); printf("%d ", node->data); inorderTraversal(node->right); } } int main() { TreeNode *root = NULL; int arr[] = { 5, 2, 9, 1, 5, 7, 10 }; int i, n = sizeof(arr) / sizeof(arr[0]); /* 插入结点 */ for (i = 0; i < n; ++i) { root = insert(root, arr[i]); } /* 中序遍历二叉搜索树 */ inorderTraversal(root); return 0; } ``` 希望能帮到你！如果你还有其他问题，欢迎继续提问！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值