【数据结构】二叉搜索树

已于 2023-08-16 20:29:36 修改
阅读量508 收藏 5
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 二叉树 二叉搜索树
于 2023-08-16 20:29:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53943591/article/details/132327182
版权

🚀 作者简介：一名在后端领域学习，并渴望能够学有所成的追梦人。
🐌 个人主页：蜗牛牛啊
🔥 系列专栏：🛹数据结构、🛴C++
📕 学习格言：博观而约取，厚积而薄发
🌹 欢迎进来的小伙伴，如果小伙伴们在学习的过程中，发现有需要纠正的地方，烦请指正，希望能够与诸君一同成长！ 🌹

文章目录

二叉搜索树的概念

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

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

  • 它的左右子树也分别为二叉搜索树

image-20230724112755992

二叉搜索树还有一个特征：按照中序走的话是一个升序的状态。所以二叉树搜索树可以叫做二叉排序树或二叉查找树。

二叉搜索树的操作及实现

二叉搜索树的结构

首先实现一个结点类，结点类当中包含三个成员变量：结点值、左指针、右指针，同时结点类当中要对成员变量进行初始化，需要实现一个构造函数，用于将结点的左右指针置空和初始化指定结点值。

结点类的代码实现：

//二叉树搜索树结点类
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;
private:
	Node* _root = nullptr; //可以给一个构造函数，也可以直接写一个缺省值
};

二叉搜索树的构造函数

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

我们也可以这样写：

//default:默认情况下不会生成，让其强制生成构造函数
BSTree() = default;//指定强制生成默认构造

二叉搜索树的接口（非递归实现）

二叉搜索树的插入

通过插入函数在二叉搜索树中插入一个值，如果成功返回true，失败返回false。

当我们想进行插入数据时，要和树的根结点及各个子树的根结点进行比较，如果待插入结点值比当前结点小就插入到该结点的左子树；如果待插入结点值比当前节点值大就插入到该结点的右子树。

默认的搜索二叉树是不允许冗余的，有相同的值会插入失败。

根的值是怎么来的？插入的第一个值就是根。所以如果是同样的值，插入的顺序不同二叉搜索树的形状就不同。

在实现时我们要定义一个parent指针，方便新增节点和父结点链接。同时在链接的时候还要判断一下是和父亲的左边链接还是右边链接。

image-20230724163746453

代码实现：

bool Insert(const K& key)
{
    //确定插入的是否是第一个值,如果是第一个值插入的值就是根结点
    if (_root == nullptr)
    {
        _root = new Node(key);//申请一个新节点
        return true;
    }
    //当根不是空时找对应的位置
    Node* cur = _root;//从根结点开始向后找
    Node* parent = nullptr;//父结点
    while (cur)
    {
        if (cur->_key > key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else if (cur->_key < key)
        {
            parent = cur;
            cur = cur->_right;
        }
        //当相等时返回false，搜索二叉树中不能有相等的
        else
        {
            return false;
        }
    }
    cur = new Node(key);
    //将其链接到父结点上
    if (parent->_key > key)
    {
        parent->_left = cur;
    }
    else if (parent->_key < key)
    {
        parent->_right = cur;
    }
    return true;
}

二叉搜索树的中序遍历

二叉搜索树中序遍历出来的顺序是升序的，我们可以实现一个中序遍历来验证。

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

但是我们发现这个函数调用时候不好处理，因为要传根结点，但是并没有根结点，如果参数没有根，又没办法递归。

所以我们可以套上一层函数：调用无参的函数，当我们调用时调用无参的函数就可以实现中序遍历了。

//套用一层函数
void InOrder()
{
    _InOrder(_root);
}
//实现中序遍历，中序遍历打印出来是升序的
void _InOrder(Node* root)
{
    if (root == nullptr)
    {
        return;
    }
    _InOrder(root->_left);
    cout << root->_key << " ";
    _InOrder(root->_right);
}

测试一下：

void Test_BSTree()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> t1;
	for (auto e : a)
	{
        //插入
		t1.Insert(e);
	}
    //中序遍历
	t1.InOrder();
}
int main()
{
	Test_BSTree();
	return 0;
}

打印结果：

image-20230724164737575

二叉搜索树的查找

在二叉搜索树中也可以通和根结点和左右子树的根结点比较查找指定节点值，如果找到返回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;
}

二叉搜索树的删除

首先查找要删除的元素是否存在，如果不存在，则返回；否则要删除的结点可能分下面三种情况：

a.要删除的结点只有左孩子结点(包含要删除的结点无孩子结点)

b.要删除的结点只有右孩子结点

c.要删除的结点有左、右孩子结点

所以我们针对上面三种情况进行分析：

情况a：要删除的结点只有左孩子结点(包含要删除的结点无孩子结点)

此时删除要删除的结点之后，使被删除节点的父结点指向被删除节点的左孩子结点（直接删除法）

image-20230724171954648

情况b.要删除的结点只有右孩子结点

此时删除要删除的结点之后，使被删除节点的父结点指向被删除节点的右孩子结点（直接删除法）

image-20230724172146756

情况c.要删除的结点有左、右孩子结点

若待删除结点有左、右孩子结点，可以使用替换法进行删除。
可以找到待删除结点左子树中结点值最大的结点，或者是待删除结点右子树中结点值最小的结点来代替待删除结点被删除。代替待删除结点被删除的结点，在左右子树当中至少有一个为空树，那删除该结点之后可以利用上面两种情况来处理。

必须是待删除结点左子树中结点值最大的结点，或者是待删除结点右子树中结点值最小的结点代替待删除结点被删除，只有这样才能保证删除后的二叉树仍保持二叉搜索树的特性。

image-20230724174830726

删除的时候也要用parent记录父结点，保证当被删除结点还有孩子时能够被接管。

代码实现：

bool Erase(const K& key)
{
    Node* parent = nullptr;//父结点
    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->_right == nullptr)
            {
                //当只有一边时，需要更新_root
                if (cur == _root)
                {
                    //左孩子为空，让_root等于右孩子
                    _root = cur->_left;
                }
                else
                {
                    //判断是哪边的，让其接管
                    if (parent->_left == cur)
                    {
                        parent->_left = cur->_left;
                    }
                    else
                    {
                        parent->_right = cur->_left;
                    }
                }
                //删除该结点
                delete cur;
            }
            //该节点只有右孩子
            else if (cur->_left == nullptr)
            {
                //当只有右边时，需要更新_root
                if (cur == _root)
                {
                    _root = cur->_right;
                }
                else {
                    if (parent->_right == cur)
                    {
                        parent->_right = cur->_right;
                    }
                    else
                    {
                        parent->_left = cur->_left;
                    }
                }
                //删除结点
                delete cur;
            }
            //该节点有左右孩子
            else
            {
                //找右树的最小结点替代
                //这里不能等于空
                //Node* pminRight = nullptr;
                Node* pminRight = cur;
                Node* minRight = cur->_right;
                while (minRight->_left)
                {
                    pminRight = minRight;
                    minRight = minRight->_left;
                }
                //找到右树的最小结点之后再把key传过去
                cur->_key = minRight->_key;
                if (pminRight->_left == minRight)
                {
                    pminRight->_left = minRight->_right;
                }
                else
                {
                    pminRight->_right = minRight->_right;
                }
                delete minRight;
            }
            return true;
        }
    }
    return false;
}

image-20230724193645593

同时我们在实现时应该注意当其为如下特殊情况时，更新_root：

image-20230724192934049

二叉搜索树的接口（递归实现）

一般在类里面写递归都要套上一层。

二叉搜索树的插入

要在搜索树里面进行一个插入：比根结点大的值和右子树根结点比较插入；比根结点小的值和左子树根结点比较插入，需要注意插入要和父结点链接起来。我们可以传入父结点，但是这里使用引用是最优的，root是_root->left或者_root->right的别名（上一层的别名），就能够链接上。要注意C++的引用不能改变指向，循环里面不能用引用。

递归实现插入代码：

bool _InSertR(Node*& root, const K& key)
{
    if (root == nullptr)
    {
        root = new Node(key);
        return true;
    }
    if (root->_key > key)
    {
        _InSertR(root->_left, key);
    }
    if (root->_key < key)
    {
        _InSertR(root->_right, key);
    }
    else
        return false;
}
bool InSertR(const K& key)
{
    return _InSertR(_root, key);
}

二叉搜索树的查找

查找，如果在二叉树中返回true，否则返回false。

递归实现查找代码：

//套用一层函数
bool _FindR(Node* root,const K& key) 
{
    if (root == nullptr)
    {
        return false;
    }
    if (root->_key == key)
    {
        return true;
    }
    if (root->_key > key)
    {
        return _FindR(root->_left, key);
    }
    else
    {
        return _FindR(root->_right, key);
    }
}
bool FindR(const K& key)
{
    return _FindR(_root,key);
}

二叉搜索树的删除

删除的思路和非递归方式一样，当要删除的结点有左右孩子的时候使用替换法，找左子树的最大值或者右子树的最小值（下面的递归实现采用的是找左子树的最大值），但是注意递归这里不能使用root->_key = maxLeft->_key，如果这样两个值相同了，不能找到要删除的结点。

递归删除函数子函数中必须使用引用接收参数，保证能够链接起来。

root是指针，直接让指针指向其指定结点就可以了，不用找到父节点。要保存一下要删除的结点Node* del = root，不然改变root指针后没办法删除要删除的结点。

bool _EarseR(Node*& root,const K& key)
{
    if (root == nullptr)
    {
        return false;
    }
    if (root->_key > key)
    {
        return _EarseR(root->_left, key);
    }
    else if (root->_key < key)
    {
        return _EarseR(root->_right, key);
    }
    else {
        Node* del = root;//保存一下要删除的结点
        if (root->_left == nullptr)
            //root是指针，直接让指针指向其指定结点，这时就链接成功了
            root = root->_right;
        else if (root->_right == nullptr)
            root = root->_left;
        else
        {
            //去找左树的最大值
            Node* maxLeft = root->_left;
            while (maxLeft->_right)
            {
                maxLeft = maxLeft->_right;
            }
            //找到进行替代,直接交换
            swap(root->_key, maxLeft->_key);
            //交换值的时候不能使用root->_key = maxLeft->_key,如果这样两个值相同了，不能找到要删除的结点。
            return _EarseR(root->_left,key);//转换成在子树去删除
        }
        delete del;
    }
}
bool EarseR(const K& key)
{
    return _EarseR(_root, key);
}

return _EraseR(root->_left, key);这里不能使用maxLeft，因为要使用引用，maxLeft只是一个局部变量，会出问题的，引用在递归里面又变成别名。

二叉搜索树的拷贝构造

当我们没有实现拷贝构造时候，使用的都是默认拷贝构造函数，属于浅拷贝。

当我们在没有实现析构函数时使用以下代码时并不会出问题：

void Test_BSTree() {

	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> t1;
	for (auto e : a)
	{
		t1.Insert(e);
	}
	t1.InOrder();
	cout << endl;
	BSTree<int> t2(t1);
	t2.InOrder();
}

监视窗口如下：

image-20230724203331219

但是当我们实现析构函数之后就会报错：

image-20230724204001640

所以拷贝构造我们要写成深拷贝（推荐使用递归去实现）：

主要思想就是先去创建结点，在返回的时候才开始将各个节点链接起来。

从根结点开始，不能使用插入函数，因为插入顺序不一样，形状不一样：

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& operator=(const BSTree<K> t)
{
    swap(_root, t._root);
    return *this;//支持连续赋值
}

二叉搜索树的析构函数

二叉树搜索树的析构函数我们采用一个后序的递归删除完成：

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

也可以在Destroy那里使用引用传参，从而可以不在析构函数那里写_root = nullptr;，直接在Destroy函数实现，因为root就是_root的别名。

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

二叉搜索树的应用

K模型

K模型，即只有key作为关键码，结构中只需存储key即可，关键码即为需要搜索到的值。

我们在本篇中讲到的构建、查找、插入就属于K模型。

KV模型

KV模型，对于每一个关键码key，都有与之对应的值value，即<key, value>的键值对。

通过一个值查找另一个值：如中英文互译字典、电话号码查询快递信息等。

我们可以通过改一下本篇中的二叉树搜索树来认识一下key-value模型，之前的二叉树搜索树是key模型。

将代码修改，主要修改模板参数，增加一个参数：

namespace kv {
	template<class K,class V>
	struct BSTreeNode {
		BSTreeNode<K,V>* _left;
		BSTreeNode<K,V>* _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 {
		//喜欢在类里进行类型重定义，因为受到类域的限制
		typedef BSTreeNode<K,V> Node;
	public:
		//插入成功返回true，插入失败返回false
		bool Insert(const K& key,const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key,value);
				return true;
			}
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					return false;
				}
			}
			cur = new Node(key,value);
			if (parent->_key > key)
			{
				parent->_left = cur;
			}
			else {
				parent->_right = cur;
			}
			return true;
		}
		bool Erase(const K& key)
		{
			Node* parent = nullptr;//父结点
			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->_right == nullptr)
					{
						//当只有一边时，需要更新_root
						if (cur == _root)
						{
							//左孩子为空，让_root等于右孩子
							_root = cur->_left;
						}
						else
						{
							//判断是哪边的，让其接管
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						//删除该结点
						delete cur;
					}
					//该节点只有右孩子
					else if (cur->_left == nullptr)
					{
						//当只有右边时，需要更新_root
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else {
							if (parent->_right == cur)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}
						//删除结点
						delete cur;
					}
					//该节点有左右孩子
					else
					{
						//找右树的最小结点替代
						//这里不能等于空
						//Node* pminRight = nullptr;
						Node* pminRight = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							pminRight = minRight;
							minRight = minRight->_left;
						}
						//找到右树的最小结点之后再把key传过去
						cur->_key = minRight->_key;
						if (pminRight->_left == minRight)
						{
							pminRight->_left = minRight->_right;
						}
						else
						{
							pminRight->_right = minRight->_right;
						}
						delete minRight;
					}
					return true;
				}
			}
			return false;
		}

		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()
		{
			_InOrder(_root);
		}
		//实现中序遍历
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
}

实现之后我们通过实现一个单词翻译来测试一下：

//测试
void Test_BSTree()
{
    kv::BSTree<string, string> dict;

    dict.Insert("sort", "排序");
    dict.Insert("left", "左边");
    dict.Insert("right", "右边");
    dict.Insert("string", "字符串");
    dict.Insert("insert", "插入");
    dict.Insert("erase", "删除");
    string str;
    while (cin >> str)
    {
        //kv::BSTreeNode<std::string,std::string>* ret = dict.Find(str);
        auto ret = dict.Find(str);
        if (ret)
        {
            cout << ":" << ret->_value << endl;
        }
        else
        {
            cout << "无此单词" << endl;
        }
    }
}
int main()
{
    Test_BSTree();
    return 0;
}

测试结果：

image-20230724212828292

这种程序怎么结束呢？while (cin >> str)按ctrl+c是发送终止信号，也可以使用ctrl+z+换行来结束。

我们还可以使用修改后的代码用来测试统计水果出现的次数：

void Test_BSTree()
{
    string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
                    "苹果", "香蕉", "苹果", "香蕉" };
    kv::BSTree<string, int> countTree;
    for (auto str : arr)
    {
        //kv::BSTreeNode<string, int>* ret = countTree.Find(str);
        auto ret = countTree.Find(str);
        if (ret == nullptr)
        {
            countTree.Insert(str, 1);
        }
        else
        {
            ret->_value++;
        }
    }
    countTree.InOrder();
}
int main()
{
    Test_BSTree();
    return 0;
}

测试结果（这里的顺序是按照string数组中出现的先后顺序来排序的）：

image-20230724213300066

二叉搜索树性能分析

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

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

image-20230724205939957

对于有N个结点的二叉搜索树，最优的情况下，二叉搜索树为完全二叉树，其平均比较次数为：logN；最差的情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2。

而时间复杂度描述的是最坏情况下算法的效率，因此普通二叉搜索树各个操作的时间复杂度都是O(N)。

不 良
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
PTA 数据结构 二叉搜索树的结构
weixin_42606045的博客
11-11 1670
7-2 二叉搜索树的结构 （30 分） 二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科） 给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树，然后对结果树的结构进行描述。你需要能判断给定的描述是否正确...
数据结构 二叉搜索树
08-06
大二《数据结构》课程设计 二叉搜索树实现算法
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 6857
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
数据结构 二叉搜索树的删除
小手挥墨
04-30 4265
文章目录概述待删除的结点没有子树待删除的结点仅有一颗子树待删除的结点有两颗子树C代码实现 概述 这是一篇短文，专门考究一下二叉搜索树的删除。 二叉搜索树的建立非常简单，如果不熟悉的见此文 树与二叉树。 而删除则有数种情况： 待删除的结点没有子树。 待删除的结点仅有一颗子树。 待删除的结点有两颗子树。 下面逐一分析。 待删除的结点没有子树 如需删除下图中结点9： 这是最简单的一种情况，它没有子...
数据结构-二叉搜索树
m0_61433144的博客
08-07 1596
二叉搜索树也称二叉排序树或者二叉查找树，它是在普通二叉树上加入一些特性所形成的： 1，若左子树非空，则左子树上所有结点的值均小于根结点的值。 2，若右子树非空，则右子树上所有结点的值均大于根结点的值。 3，其左右子树也分别是一棵二叉搜索树。......
【数据结构】二叉查找树/二叉搜索树BST（附相关C++代码）
weixin_50941083的博客
05-14 840
本文内容将主要介绍二叉查找树的相关概念，与关于二叉查找树的重要操作，如添加节点、删除节点等。
Java数据结构——二叉搜索树
chenchenchencl的博客
10-19 1240
Java数据结构——二叉搜索树
数据结构二叉搜索树02
vfjcgg的博客
12-06 410
二叉搜素树, BST, binary search tree。二叉查找树、二叉排序树。 二叉搜索树其实就是普通的二叉树上加了—些限制 二叉树对于结点是没有任何的限制，但是在二叉搜索树中在插入子结点的有一些特殊的要求: 1、非空左子树的所有的键值都小于其根结点的键值 2、非空右子树的所有键值都大于其根结点的键值3、左右子树本身也都是二叉搜索树 二叉搜索树的特点:相对较小的值总是保存在左子结点上，相对较大的值总是保存在右子结点上 二叉搜索树 // 结点类 class Node{ constructor(va
『数据结构』二叉搜索树
叄拾叄画生
07-11 4605
什么是二叉搜索树？二叉搜索树的基本操作。二叉搜索树的查找、插入、删除等。二叉搜索树的性能分析。二叉搜索树的模拟实现（C++和Java）。模拟实现中遇到的问题。
数据结构——二叉搜索树 Python实现
2301_80278591的博客
04-18 627
基于二叉搜索树每个节点中的数值大小均满足：左子节点的值 < 根节点的值 < 右子节点的值的特点，二叉搜索树在搜索值时是依照二分来进行查找的，即先将待查找的值与每棵子树的根节点的值进行比较，当待查找的值小于每棵子树的根节点的值时，到该根节点的左子树递归查找；二叉树的许多相关操作是和递归密不可分的。所谓二叉搜索树，其实本质上就是一个树状的数据结构，也是有一个根节点和若干个子树所组成的，其基于二叉树的结构，而在其数据的填充位置上所进行优化而得到的数据结构，并运用二叉搜索树数据的分布特点来实现在搜索功能。
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
陈越、何钦铭-数据结构作业8：二叉搜索树的操作集
03-28
函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针； 函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针； 函数Find在二叉搜索树...
javascript数据结构之二叉搜索树实现方法
10-23
主要介绍了javascript数据结构之二叉搜索树实现方法,较为详细的分析了二叉搜索树的概念、原理与JavaScript实现二叉搜索树的方法,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下
【数据结构】链式二叉树详解
最新发布
s_little_monster的博客
06-03 2659
链式二叉树的实现
线性数据结构-数组
passworddddddd的博客
05-31 230
因为数组定长，当想往长度为8的数组中添加第九个元素时，操作系统会开辟一段长度为16的新的空间（操作系统会开辟一些提前量，多划一些空间），然后将旧数组的八个元素复制到新的数组中，并将新添加的元素，添加到新数组的第九个位置上，并且销毁就数组。1、因为空间必须是连续的，如果数组比较大，当系统的空间碎片较多时，容易存不下。在长度8的数组中删除第5个元素，不改变数组长度，从第六个元素开始向左移动一个单元，即数组删除。2、因为数组长度是固定，所以数组的内容难以被添加和删除。3、数组的变量指向了数组第一个元素的位置。
C语言.数据结构.单链表
Joseit的博客
05-31 778
C语言数据结构单链表技术博客文章摘要 本文深入探讨了C语言中的数据结构——单链表。首先，文章介绍了链表的概念及结构，强调了链表作为一种物理存储结构上非连续、非顺序的存储结构，其数据元素的逻辑顺序是通过链表中的指针链接次序实现的。通过将链表与火车车厢的类比，形象地展示了链表节点之间的独立性和链接关系。 接着，文章详细阐述了单链表的实现方法，包括定义链表节点结构体、实现基本的链表操作（如头部插入、删除、尾部插入、删除、查找、在指定位置插入/删除节点等），以及链表的销毁等功能。
软设之希尔排序
2301_81968528的博客
05-30 286
假设有n个元素，先取一个小于n的整数d1作为一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组中进行直接插入排序;然后，取第二个增量d2
【排序】冒泡排序
2302_80220453的博客
05-31 504
在我们的生活中，到处都离不开排序的作用，考试分数要排序，商场购物要排序，可以说排序对我们来说处处存在，那么从本章开始，我将要依次分享一些排序方法，从易到难，包括冒泡，插入，快速，希尔，选择等排序方法，希望大家能够支持。
数据结构二叉搜索树avl树
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左子树所有节点的关键值（键值）小于根节点的关键值，而右子树所有节点的关键值大于根节点的关键值。AVL树则是一种自平衡的二叉搜索树，它保证...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不 良

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

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

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

打赏作者

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

抵扣说明：

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

余额充值