数据结构——“AVL树”的四种数据旋转的方法

已于 2024-09-29 01:00:25 修改
阅读量431 收藏 13
点赞数 4
文章标签： 数据结构
于 2024-09-28 17:58:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79972085/article/details/142605499
版权

        因为上次普通的二叉搜索树在极端情况下极容易造成我们的链式结构（这会导致我们查询的时间复杂度变为O(n)），然而AVL树就很好的解决了这一问题（归功于四种旋转的方法），它让我们的树的查询的时间复杂度变得接近于甚至等于O(logN)。它相比于普通的二叉搜索树，它增加了平衡因子来维持树的高度，增加了纸箱上一个节点的parent指针。另外，平衡因子的计算方法是右子树的高度减去左子树的高度，当当前节点的平衡因子的值为-1、0、1的时候，我们认为当前节点是平衡的，当为其他值的时候就不平衡，需要通过旋转来将树调整平衡。

        废话不多说，让我们了解一下四种旋转方式吧。

        一、右旋

        右旋的情况（最小）出现在一直向左子树插入数据，就像这样：

74ce36d1ae1f4d979c9a088dc67ff7e3.png

        最后插入的6让10的平衡因子变为-2，让本就不怎么平衡的数变得彻底不平衡，因此就需要右旋。它的规则是什么呢？

        当树满足右旋的条件的时候（当前节点的平衡因子为2或者-2），右旋的时候，平衡因子为-2，在这里满足条件的是10节点，我们把它的左子树的右子树给该节点的左子树，即：用节点10替换掉8的右子树，但是8的右子树是有东西的，而10的左子树刚好又不指向8，那么就进行互换一次。

bfadcfd6dd8c452e9768a90fd199efdd.png

        最后再次修改平衡因子：

9b934bd33f1349188b78e01a8e0b1f02.png

        下边可以看一个实例：

        这是一棵已经满足AVL树的树：

7538a8530da84cac9b16c9e95287f0a6.png

        在5的左子树插入数据：

96dc88a2bbb643ecbd06baafe1ae852c.png

     节点更新到6，不满足条件，需要旋转：

69f3fd583c5e4de4b93e21e5cf13772d.png

                更新平衡因子：

668e0d3c75a44053bf03d2cbde021f44.png

        用过重复的测试和观察可以发现，到最后，旋转的节点和他的左子树最后的平衡因子都是从-2、-1变到0、0.

        值得注意的是在插入节点后，需要向上更新平衡因子，倘若更新后遇到平衡因子为0，那就没有再次向上更新的必要了。

插入代码结构如下：

	//AVL树的插入
	bool Insert(K key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		//插入数据
		if (cur == nullptr)
		{
			_root = new Node(key);
		}
		else
		{
			//寻找插入的位置
			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 (key > parent->_key)//插入的值大于父亲节点，那么就需要在父亲节点的右边插入
			{
				parent->_right = cur;
				parent->_right->_parent = parent;
			}
			else if(key < parent->_key)//插入的值小于父亲节点，那么就需要在父亲节点的左边插入
			{
				parent->_left = cur;
				parent->_left->_parent = parent;
			}
			else
			{
				assert(false);
			}
		}
		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bl--;
			}
			else if (cur == parent->_right)
			{
				parent->_bl++;
			}
			//检查树是否平衡
			if (parent->_bl == 0)//平衡，退出函数
			{
				return true;
			}
			else if (parent->_bl == 1 || parent->_bl == -1)//半平衡，向上更新,直到为0或者更新到根
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bl == 2 || parent->_bl == -2)//不平衡，旋转
			{
                这里是四种旋转的区域

				return true;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

        那么知道原理后，就来用代码实现以下：

	//右旋
	void RotateR(Node* node)
	{
		Node* kidL = node->_left;
		Node* kidLR = node->_left->_right;
		Node* pparent = node->_parent;

		//先把该节点移动到kidl的右边
		node->_left = kidLR;
		if (kidLR)//只有在kidLR不为空的情况下才可以更新kidLR的父亲节点
		{
			kidLR->_parent = node;
		}
		kidL->_right = node;
		node->_parent = kidL;

		
		if (pparent == nullptr)//如果被旋转节点的父亲为空，则说明此节点为根节点
		{
			_root = kidL;
			kidL->_parent = nullptr;
		}
		else//不为根节点
		{
			if (node == pparent->_left)//判断被旋转的节点在父亲节点的左边还是右边
			{
				pparent->_left = kidL;
			}
			else
			{
				pparent->_right = kidL;
			}

			kidL->_parent = pparent;
		}
		
		kidL->_bl = node->_bl = 0;//更新平衡因子
	}

        在写代码的过程中，为了防止出错，建议把需要更改的节点的位置用指针记录下来，一方面是为了防止在写代码的过程中因为误操作修改了指针的指向，导致再次使用的时候因为指针的变化从而操作本不应该操作的节点，另一方面是优化代码可读性，毕竟连续的“->”会让人感觉头疼。

看看示例：

int main()
{
	AVLTree<int> tree;
	tree.Insert(10);
	tree.Insert(8);
	tree.Insert(7);
	tree.Insert(6);
	tree.Insert(5);
	tree.Insert(4);


	tree.InTraversal();


	return 0;
}

         运行结果（中序遍历）：

41eced73b97f4715a0811f5548124d69.png

二、左旋

        左旋和右旋一样，它的发生情况是这种的：

896a1d48783b432983479a923fae9791.png

        它和右旋一样，不过是方向相反的，我们需要把13的左边给10的右边，然后把10给13的左边，做后需要注意的细节和右旋一样，就是父亲节点的更新。这一点需要大家画图研究一下。

        另外，经过观察可以得到，左旋的条件是被旋转的节点平衡因子为2，它的右子树的平衡因子为1。

        由于和右旋相反，所以可以在右旋代码中做修改（几乎所有的被改数值都和右旋相反）：

//左旋
	void RotateL(Node* node)
	{
		Node* kidR = node->_right;
		Node* kidRL = node->_right->_left;
		Node* pparent = node->_parent;

		//先把该节点移动到kidl的左边
		node->_right = kidRL;

		if (kidRL)//只有在kidRL不为空的情况下才可以更新kidRL的父亲节点
		{
			kidRL->_parent = node;
		}
		kidR->_left = node;
		node->_parent = kidR;


		if (pparent == nullptr)//如果被旋转节点的父亲为空，则说明此节点为根节点
		{
			_root = kidR;
			kidR->_parent = nullptr;
		}
		else//不为根节点
		{
			if (node == pparent->_left)//判断被旋转的节点在父亲节点的左边还是右边
			{
				pparent->_left = kidR;
			}
			else
			{
				pparent->_right = kidR;
			}

			kidR->_parent = pparent;
		}

		kidR->_bl = node->_bl = 0;//更新平衡因子
	}

示例：

int main()
{
	AVLTree<int> tree;
	tree.Insert(1);
	tree.Insert(2);
	tree.Insert(3);
	tree.Insert(4);
	tree.Insert(5);
	tree.Insert(6);


	tree.InTraversal();


	return 0;
}

 运行结果：

3be2c82787664c05a876d18fa3419f27.png

三、左右双旋

        左右双旋的情况（最小）大致是这样：

f50f5d19c1f94745881020a13df09ce1.png

        这种情况比较复杂，但是解决方法就是先对5进行左旋，再对10进行右旋，对5左旋是为了把这棵树变为纯粹的左边高（旋转后满足右旋的条件），然后再进行右旋。

e34dc7bd998b4fa9b90fb46a4f7d1cb4.png

        在这里有一个值得注意的问题：被调整的节点的左子树的右子树的高度会影响被调整的节点的左子树或者被调整的节点的平衡因子，举个例子：

        1.上边的例子是8的平衡因子为0的情况，那么最后parent（10）和kid（5）的平衡因子为0。

        2.当8的平衡因子为1的时候（框里的代表能够满足左右双旋的情况）影响的是被调整的节点的左子树的平衡因子，即5的平衡因子

68a744aed5414d68adef53add42ca79d.png

       a.在8节点右边插入节点：

3c2310b752364f5081f351f854a2a80e.png

旋转：

dfddb5ac533046c3ab9dd709c2b641ab.png

        最后5的节点的平衡因子为-1，10的节点的平衡因子为0。

        b. a.在8节点左边插入节点：

5853e9174b1c43328a7dffb7b31ff205.png

最后5的节点的平衡因子为0，10的节点的平衡因子为1。

        另外通过观察可得被旋转的节点的平衡因子为-2，它的左子树平衡因子为1的时候，发生左右旋转。

代码如下：

	//左右双旋
	void RotateLR(Node* node)
	{
		Node* kidL = node->_left;
		Node* kidLR = node->_left->_right;
		int bl = kidLR->_bl;
		//先对左边的节点进行左旋
		RotateL(kidL);
		//再对该节点进行右旋
		RotateR(node);

		if (bl == 0)
		{
			node->_bl = kidL->_bl = kidLR->_bl = 0;
		}
		else if (bl == 1)
		{
			kidL->_bl = -1;
			node->_bl = kidLR->_bl = 0;
		}
		else if (bl == -1)
		{
			node->_bl = 1;
			kidL->_bl = kidLR->_bl = 0;
		}

	}

测试示例：

int main()
{
	AVLTree<int> tree;
	tree.Insert(10);
	tree.Insert(5);
	tree.Insert(11);
	tree.Insert(4);
	tree.Insert(8);
	tree.Insert(9);


	tree.InTraversal();


	return 0;
}

运行结果：

25100a08c10f464683045755ccb7b9e6.png

四、右左双旋

        同左旋和右旋的关系，他们只是方向相反，能更改的东西也应该相反，它的形成条件如下图：

57aed070786d4dfa8f1beb5697f54e4b.png

代码：

	//右左双旋
	void RotateRL(Node* node)
	{
		Node* kidR = node->_right;
		Node* kidRL = kidR->_left;
		int bl = kidRL->_bl;
		//先对右边的节点进行右旋
		RotateR(kidR);
		//再对该节点进行左旋
		RotateL(node);

		if (bl == 0)
		{
			node->_bl = kidR->_bl = kidRL->_bl = 0;
		}
		else if (bl == 1)
		{
			node->_bl = -1;
			kidR->_bl = kidRL->_bl = 0;
		}
		else if (bl == -1)
		{
			kidR->_bl = 1;
			node->_bl = kidRL->_bl = 0;
		}
		else
		{
			return assert(false);
		}
	}

示例：

int main()
{
	AVLTree<int> tree;
	tree.Insert(10);
	tree.Insert(9);
	tree.Insert(15);
	tree.Insert(11);
	tree.Insert(16);
	tree.Insert(12);
	tree.Insert(13);

	tree.InTraversal();

	return 0;
}

ee934faf8a2b4aef95665af1a79614cf.png

总代码：


#include<iostream>
#include<assert.h>

using namespace std;


template <class K>
struct AVLTreenode
{
	AVLTreenode(K key)
		:_key(key)
	{}
	K _key;
	AVLTreenode* _left = nullptr;
	AVLTreenode* _right = nullptr;
	AVLTreenode* _parent = nullptr;
	int _bl = 0;
};


template <class K>
class AVLTree
{
private:
	using Node = AVLTreenode<K>;
	Node* _root = nullptr;
public:

	void _InTraversal(Node* p)
	{
		if (p == nullptr)
			return;

		_InTraversal(p->_left);
		cout << p->_key << " ";
		_InTraversal(p->_right);
	}
	//搜索树的中序遍历
	void InTraversal()
	{
		_InTraversal(_root);
	}
	//搜索树的查找
	Node* Find(const K& key)
	{
		assert(_root);
		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;
	}

	//AVL树的插入
	bool Insert(K key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		//插入数据
		if (cur == nullptr)
		{
			_root = new Node(key);
		}
		else
		{
			//寻找插入的位置
			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 (key > parent->_key)//插入的值大于父亲节点，那么就需要在父亲节点的右边插入
			{
				parent->_right = cur;
				parent->_right->_parent = parent;
			}
			else if(key < parent->_key)//插入的值小于父亲节点，那么就需要在父亲节点的左边插入
			{
				parent->_left = cur;
				parent->_left->_parent = parent;
			}
			else
			{
				assert(false);
			}
		}
		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bl--;
			}
			else if (cur == parent->_right)
			{
				parent->_bl++;
			}
			//检查树是否平衡
			if (parent->_bl == 0)//平衡，退出函数
			{
				return true;
			}
			else if (parent->_bl == 1 || parent->_bl == -1)//半平衡，向上更新,直到为0或者更新到根
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bl == 2 || parent->_bl == -2)//不平衡，旋转
			{
				if (parent->_bl == -2 && parent->_left->_bl == -1)//右旋
				{
					RotateR(parent);
				}
				else if (parent->_bl == 2 && parent->_right->_bl == 1)//左旋
				{
					RotateL(parent);
				}
				else if (parent->_bl == -2 && parent->_left->_bl == 1)//左右双旋
				{
					RotateLR(parent);
				}
				else if (parent->_bl == 2 && parent->_right->_bl == -1)//右左双旋
				{
					RotateRL(parent);
				}

				return true;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}
	//右旋
	void RotateR(Node* node)
	{
		Node* kidL = node->_left;
		Node* kidLR = node->_left->_right;
		Node* pparent = node->_parent;

		//先把该节点移动到kidl的右边
		node->_left = kidLR;
		if (kidLR)//只有在kidLR不为空的情况下才可以更新kidLR的父亲节点
		{
			kidLR->_parent = node;
		}
		kidL->_right = node;
		node->_parent = kidL;

		
		if (pparent == nullptr)//如果被旋转节点的父亲为空，则说明此节点为根节点
		{
			_root = kidL;
			kidL->_parent = nullptr;
		}
		else//不为根节点
		{
			if (node == pparent->_left)//判断被旋转的节点在父亲节点的左边还是右边
			{
				pparent->_left = kidL;
			}
			else
			{
				pparent->_right = kidL;
			}

			kidL->_parent = pparent;
		}
		
		kidL->_bl = node->_bl = 0;//更新平衡因子
	}

//左旋
	void RotateL(Node* node)
	{
		Node* kidR = node->_right;
		Node* kidRL = node->_right->_left;
		Node* pparent = node->_parent;

		//先把该节点移动到kidl的左边
		node->_right = kidRL;

		if (kidRL)//只有在kidRL不为空的情况下才可以更新kidRL的父亲节点
		{
			kidRL->_parent = node;
		}
		kidR->_left = node;
		node->_parent = kidR;


		if (pparent == nullptr)//如果被旋转节点的父亲为空，则说明此节点为根节点
		{
			_root = kidR;
			kidR->_parent = nullptr;
		}
		else//不为根节点
		{
			if (node == pparent->_left)//判断被旋转的节点在父亲节点的左边还是右边
			{
				pparent->_left = kidR;
			}
			else
			{
				pparent->_right = kidR;
			}

			kidR->_parent = pparent;
		}
		kidR->_bl = node->_bl = 0;//更新平衡因子
	}
	//左右双旋
	void RotateLR(Node* node)
	{
		Node* kidL = node->_left;
		Node* kidLR = node->_left->_right;
		int bl = kidLR->_bl;
		//先对左边的节点进行左旋
		RotateL(kidL);
		//再对该节点进行右旋
		RotateR(node);

		if (bl == 0)
		{
			node->_bl = kidL->_bl = kidLR->_bl = 0;
		}
		else if (bl == 1)
		{
			kidL->_bl = -1;
			node->_bl = kidLR->_bl = 0;
		}
		else if (bl == -1)
		{
			node->_bl = 1;
			kidL->_bl = kidLR->_bl = 0;
		}
		else
		{
			return assert(false);
		}

	}
	//右左双旋
	void RotateRL(Node* node)
	{
		Node* kidR = node->_right;
		Node* kidRL = kidR->_left;
		int bl = kidRL->_bl;
		//先对右边的节点进行右旋
		RotateR(kidR);
		//再对该节点进行左旋
		RotateL(node);

		if (bl == 0)
		{
			node->_bl = kidR->_bl = kidRL->_bl = 0;
		}
		else if (bl == 1)
		{
			node->_bl = -1;
			kidR->_bl = kidRL->_bl = 0;
		}
		else if (bl == -1)
		{
			kidR->_bl = 1;
			node->_bl = kidRL->_bl = 0;
		}
		else
		{
			return assert(false);
		}
	}

};

 

 

超级码农ProMax
关注
数据结构—— AVL树
qq_63976098的博客
10-13 326
AVL大全
数据结构——AVL树
m0_57249790的博客
04-02 352
我们不同于普通的二叉搜索树的是，我们的AVL树的结点需要多一个父指针指向自己的父节点，还有一个记录平衡因子的变量，构成了特殊的三叉链结构。因为我们要保持AVL树的左右子树高度差的绝对值不超过1，所以要对树的结构进行旋转。所以通过看平衡因子的值就能知道是否左右子树高度不超过1。//需要存储的键值对//特殊的三叉链结构int _bf;//平衡因子（balance factor）//构造函数:_kv(kv), _bf(0){}关于AVL树，我们只是做一个了解。
18、python数据结构——AVL树
weixin_56504083的博客
03-25 413
AVL树是一颗自平衡的二叉搜索树。拥有如下特征：根的左右子树的高度之差的绝对值不能超过1；根的左右子树都是平衡二叉树。AVL树的删除、插入操作。代码如下：代码有误版本。
数据结构——AVL树旋转
MDeleter的博客
02-18 804
AVL树是一颗二叉查找树，需要逻辑规则来检查并修正可能出现的不平衡。 package TreePackage; public class AVLTree<T extends Comparable<? super T>> extends BinarySearchTree<T> implements SearchTreeInterface<T> { public AVLTree() { super();
高级数据结构——AVL树
weixin_52477733的博客
09-08 680
AVL树又被称为是高度平衡的二叉搜索树,一棵AVL树的任意左右子树的高度差不超过1,且任意一个节点大于该节点的左子节点的值,小于该节点的右子节点的值AVL树可以是专门为了查找数据而生,它适用于海量静态数据的查询的场景,而不适合频繁插入删除数据的场景.
C++数据结构 —— AVL树
weixin_59913110的博客
02-26 783
AVL树是map/set/multimap/multi/set等容器的一种底层结构，其本质就是一颗二叉搜索树。但因为二叉搜索树很容易退化成单支树，所以AVL树便是对二叉搜索树进行升级改造，使其平衡。向二叉搜索树插入节点，保证每个节点的左右子树高度差不超过1(可以包括1)，如果确实达不到这种要求，就需要通过特定的算法来达到这样的要求。一颗AVL树可以是空树，也可以是具有以下性质的二叉搜索树1.每个节点的左右子树都是AVL树2.每个节点的左右子树的高度差不超过1(可以包括1)
高阶数据结构 —— AVL树(平衡搜索树)
lyzzs222的博客
10-14 1048
AVL树的实现，画图+代码，逻辑明明白白的。
手撕，高级数据结构——AVL树的实现和插入方法
回水的博客
07-31 1295
AVL树的实现和插入方法
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 42万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构——二叉查找树（BST）静态查找表.zip
09-18
总结，"数据结构——二叉查找树（BST）静态查找表"的主题涵盖了如何使用数据结构实现BST，以及在静态查找表环境下BST的插入、删除、查找、遍历等操作及其效率。通过学习这部分内容，我们可以深入理解BST的原理，并能...
Python高级数据结构——AVL树
Echo_Wish的博客
12-06 741
AVL树是一种自平衡二叉搜索树，通过旋转操作保持树的平衡。在Python中，我们可以使用类似上述示例的。
数据结构篇——AVL树
SYLTXDY的博客
05-12 1022
AVL树 AVL树是一种带有平衡条件的二叉搜索树，它保证每个节点的左子树和右子树高度最多差1。 组成高度为h的AVL树，需要最少的节点数S(h) = S(h-1) + S(h-2) + 1，如下图，这个高度为4的AVL树由三部分组成，左子树，右子树和根节点，左子树是高度为2，右子树高度是3，两棵子树都要求节点树最小，分别是S(2)和S(3)，最后再加上根节点一个节点。所以高度为4的AVL树，需...
【数据结构】排序算法系列——归并排序（附源码+图解）
Skrrapper的博客
09-24 1065
它的特点在于并不是一开始就将整个数组进行归类和调整，而是以一定的间隔数分成多次小的排序，最后再逐渐将小的排序的范围变大，最后变大到整个数组时，已经完全有序。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。界定比较的数据个数：一般按照2的倍数增长：两个互相比较、四个互相比较、八个互相比较…总的来说，分治法也可以被称作一种算法，它是一种基于递归的、“分而治之”的算法思想。3.合并这些子问题的解成原问题的解。
【数据结构初阶】排序算法(中)快速排序专题
最新发布
fhvyxyci的博客
09-28 413
1. 快排主框架 2. 快排的不同实现 2. 1 hoare版本 2. 2 挖坑法 2. 3 lomuto前后指针法 2. 4 快排的非递归版本 3. 快排优化 3. 1 快排性能的关键点分析: 3. 1 三路划分 3. 2 introsort自省排序
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 738
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
哈希表(HashMap、HashSet)
wuweixiaoyue的博客
09-28 402
是个存储结构：可以让我们一次从表中直接拿到想要的元素，时间复杂度为O(1)为什么能实现O(1)：通过哈希(散列)方法，使元素的存储位置和它的关键码之间建立一一映射的关系如果想要存取元素，都是利用哈希(散列)方法 + 关键码，从而计算出index位置，然后进行操作（怎么放的就怎么给它取出来哈希函数示例：此时写着容量是1000，但实际上是2次幂数，容量为1024。
数据结构：树、森林
pranaa的博客
09-24 911
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
数据结构：串 及串的模式匹配（KMP）
pranaa的博客
09-23 1118
串（String）是由零个或多个字符组成的有限序列，又名叫字符串。在计算机科学中，串是一种重要的数据结构，用于表示文本数据。串中的元素称为字符，字符可以是字母、数字或其他符号，这些字符可以是任意字符集中的成员。串是许多编程语言中的基本数据类型，用于处理文本数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值