平衡二叉树——AVl树

最新推荐文章于 2024-10-08 06:04:53 发布
最新推荐文章于 2024-10-08 06:04:53 发布
阅读量624 收藏 10
点赞数 30
文章标签： c++ 开发语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34434522/article/details/142693195
版权

AVL树

AVl树的概念

AVL树是一种自平衡的二叉搜索树（Binary Search Tree, BST），由两位苏联数学家 Georgy Adelson-Velsky 和 Evgenii Landis 于 1962 年提出。其主要特点是通过保持树的平衡来保证基本操作（插入、删除和查找）的时间复杂度在 O(log n) 范围内。

概念

二叉搜索树：

AVL树是一种二叉搜索树，意味着每个节点都有一个键值，左子树的所有节点值小于该节点的值，右子树的所有节点值大于该节点的值。

平衡因子：

AVL树的每个节点都有一个平衡因子（Balance Factor），定义为该节点左子树的高度减去右子树的高度。
平衡因子可以取值为 -1、0 或 1。具体定义如下：
BF(node) = height(left subtree) - height(right subtree)
只有当平衡因子的绝对值不超过 1 时，树才是平衡的。

性质

自平衡：

AVL树在插入或删除节点时，通过旋转操作来保持树的平衡，以确保所有基本操作的时间复杂度为 O(log n)。

高度限制：

AVL树的高度 h 和节点数 n 之间存在关系：h ≤ 1.44 * log2(n + 2)。
这表明 AVL树相较于普通二叉搜索树，在最坏情况下也能保持较低的高度。

旋转操作：

当树失去平衡时，可以通过以下四种旋转操作来恢复平衡：

  • 单右旋（Right Rotation）
  • 单左旋（Left Rotation）
  • 左右旋（Left-Right Rotation）
  • 右左旋（Right-Left Rotation）

查找、插入与删除操作：

查找操作的时间复杂度为 O(log n)，因为 AVL树保持了平衡性。
插入和删除节点后，需要检查每个祖先节点的平衡因子，并可能进行旋转以恢复树的平衡。

应用
AVL树适合用于需要频繁插入和删除操作的场景，例如数据库管理系统和内存管理等，因为它能够提供快速的查找、插入和删除操作。由于AVL树总是保持平衡，因此在处理大量数据时，性能表现优越。

AVL树的实现

AVL树的结构

template<class T>
struct AVLTreeNode  //节点模板
{
	AVLTreeNode(const T& data = T())
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _bf(0)
	{}

	AVLTreeNode<T>* _pLeft;  //左孩子
	AVLTreeNode<T>* _pRight;  //右孩子
	AVLTreeNode<T>* _pParent;  //父节点
	T _data;   //数据
	int _bf;   // 节点的平衡因子
};

template<class K, class V>
class AVLTree  //AVL树模板
{
typedef AVLTreeNode<K, V> Node;   //减少繁琐的写法
public:
//...函数操作——插入，左旋等
private:
Node* _pRoot = nullptr;
};

以模板类实现AVl树，可以自由套用各种类型的数据，父节点指针方便向上查找，检查平衡因子，方便旋转。

AVl树的插入

AVL树的插入流程包括以下几个步骤：

  1. 插入节点
    首先，按照普通二叉搜索树（BST）的规则将新节点插入到树中。这意味着：
    如果新节点的值小于当前节点的值，则继续向左子树插入。
    如果新节点的值大于当前节点的值，则继续向右子树插入。

  2. 更新高度
    在插入新节点后，更新每个节点的高度。节点的高度是其左子树和右子树高度的最大值加一。

  3. 计算平衡因子
    从插入节点的父节点开始，逐级向上检查每个祖先节点的平衡因子（Balance Factor, BF），即左子树高度减去右子树高度（BF = height(left) - height(right)），或者相反。

4.检查平衡
如果某个节点的平衡因子的绝对值超过 1（即 BF < -1 或 BF > 1），则该节点失去了平衡，需要进行旋转操作来恢复平衡。

更新原则：

  • 平衡因⼦ = 右⼦树⾼度 - 左⼦树⾼度
  • 只有⼦树⾼度变化才会影响当前结点平衡因⼦。
  • 插⼊结点，会增加⾼度，所以新增结点在parent的右⼦树，parent的平衡因⼦++，新增结点在parent的左⼦树，parent平衡因⼦–
  • parent所在⼦树的⾼度是否变化决定了是否会继续往上更新

更新停⽌条件：

  • 更新后parent的平衡因⼦等于0，更新中parent的平衡因⼦变化为-1->0或者1->0，说明更新前
    parent⼦树⼀边⾼⼀边低，新增的结点插⼊在低的那边，插⼊后parent所在的⼦树⾼度不变，不会
    影响parent的⽗亲结点的平衡因⼦，更新结束。
  • 更新后parent的平衡因⼦等于1或-1，更新前更新中parent的平衡因⼦变化为0->1或者0->-1，说明更新前parent⼦树两边⼀样⾼，新增的插⼊结点后，parent所在的⼦树⼀边⾼⼀边低，parent所在的⼦树符合平衡要求，但是⾼度增加了1，会影响arent的⽗亲结点的平衡因⼦，所以要继续向上更新。
  • 更新后parent的平衡因⼦等于2或-2，更新前更新中parent的平衡因⼦变化为1->2或者-1->-2，说明更新前parent⼦树⼀边⾼⼀边低，新增的插⼊结点在⾼的那边，parent所在的⼦树⾼的那边更⾼了，破坏了平衡，parent所在的⼦树不符合平衡要求，需要旋转处理，旋转的⽬标有两个：
  • 1、把parent⼦树旋转平衡。
  • 2、降低parent⼦树的⾼度，恢复到插⼊结点以前的⾼度。所以旋转后也不需要继续往上更新，插⼊结束。
  1. 选择旋转方式
    根据失衡节点的子树结构，选择适当的旋转方式：

左左情况（Left-Left Case）：

当新节点被插入到左子树的左侧时，执行单右旋。
右右情况（Right-Right Case）：

当新节点被插入到右子树的右侧时，执行单左旋。
左右情况（Left-Right Case）：

当新节点被插入到左子树的右侧时，先对左子树进行左旋，然后对当前节点进行右旋。
右左情况（Right-Left Case）：

当新节点被插入到右子树的左侧时，先对右子树进行右旋，然后对当前节点进行左旋。

  1. 旋转操作
    进行相应的旋转操作来恢复树的平衡。旋转操作的基本步骤如下：
    在旋转过程中调整节点的指针，以确保树的结构保持正确。

  2. 完成插入
    完成上述步骤后，AVL树就会保持自平衡状态，所有基本操作的时间复杂度仍然是 O(log n)。

代码实现：

bool Insert(const T& data)
{
	Node* node = new Node(data);

	if (_pRoot == nullptr)
	{
		_pRoot = node;
		return true;
	}

	Node* cur = _pRoot;
	Node* par = nullptr;
	while (cur)
	{
		par = cur;
		if (cur->_data > data)
		{
			cur = cur->_pLeft;
		}
		else if(cur->_data < data)
		{
			cur = cur->_pRight;
		}
		else
		{
			delete node;
			return false;
		}
	}

	//平衡因子 = 右 - 左
	if (par->_data > data)
	{
		par->_pLeft = node;
	}
	else
	{
		par->_pRight = node;
	}
	cur = node;
	cur->_pParent = par;

	while (par)
	{
		if (par->_pLeft == cur)
		{
			par->_bf--;
		}
		else
		{
			par->_bf++;
		}

		if (par->_bf == 0) break;

		if (par->_bf == 1 || par->_bf == -1)
		{
			cur = par;
			par = par->_pParent;
		}
		else if (par->_bf == 2 && cur->_bf == 1)
		{
			//左单旋
			RotateL(par);
			break;
		}
		else if (par->_bf == 2 && cur->_bf == -1)
		{
			//左右双旋
			RotateLR(par);
			break;
		}
		else if (par->_bf == -2 && cur->_bf == -1)
		{
			//右单旋
			RotateR(par);
			break;
		}
		else if(par->_bf == -2 && cur->_bf == 1)
		{
			//右左双旋
			RotateRL(par);
			break;
		}
		else
		{
			assert(false);
		}


	}

	return true;
}

AVL树的旋转

平衡因子：右子树高度 - 左子树高度

左单旋

如下是最简单的一种左单旋的情况，
在这里插入图片描述

左单旋之后如图：

在这里插入图片描述

代码实现：

void LeftRotate(Node* par)
{
	//右孩子
	Node* rchild = par->_pRight;
	//父节点的父亲
	Node* ppar = par->_pParent;

	//旋转操作
	//右孩子的左孩子改成父节点
	rchild->_pLeft = par;
	
	//父节点的父亲改为左孩子
	par->_pParent = rchild;
	//右孩子的父亲改为父节点的父亲
	rchild->_pParent = ppar;

	//改变平衡因子
	par->_bf = 0;
	rchild->_bf = 0;

}

有子节点的复杂左单旋的情况：

在这里插入图片描述

左单旋之后：

在这里插入图片描述

这种情况下需要多处理一个右孩子的左节点，将其接到父节点的右孩子上，保持二叉搜索树的性质。

实现代码：

void LeftRotate(Node* par)
{
	//右孩子
	Node* rchild = par->_pRight;
	//父节点的父亲
	Node* ppar = par->_pParent;

	//**右孩子的左孩子**
	Node* rlchild = rchild->_pLeft;

	//旋转操作
	//右孩子的左孩子改成父节点
	rchild->_pLeft = par;

	//**父节点的右孩子变成原本右孩子的左孩子**
	par->_pRight = rlchild;
	
	//父节点的父亲改为右孩子
	par->_pParent = rchild;
	//左孩子的父亲改为父节点的父亲
	rchild->_pParent = ppar;

	//**如果右左孩子存在，其父节点需要改变为原本的父节点**
	if (rlchild)
		rlchild->_pParent = par;

	//改变平衡因子
	par->_bf = 0;
	rchild->_bf = 0;

}

除此之外，还要考虑父节点为根节点的情况下，需要改变根节点的指针。如果不是，要判断父节点的父亲的情况，将父节点的父亲的孩子指针指向更改后的新的子树父节点

在这里插入图片描述

最终代码：

void LeftRotate(Node* par)
{
	//右孩子
	Node* rchild = par->_pRight;
	//父节点的父亲
	Node* ppar = par->_pParent;

	//**右孩子的左孩子**
	Node* rlchild = rchild->_pLeft;

	//旋转操作
	//右孩子的左孩子改成父节点
	rchild->_pLeft = par;

	//**父节点的右孩子变成原本右孩子的左孩子**
	par->_pRight = rlchild;
	
	//父节点的父亲改为右孩子
	par->_pParent = rchild;
	//左孩子的父亲改为父节点的父亲
	rchild->_pParent = ppar;

	//**如果右左孩子存在，其父节点需要改变为原本的父节点**
	if (rlchild)
		rlchild->_pParent = par;

	//改变平衡因子
	par->_bf = 0;
	rchild->_bf = 0;

	if (par == _pRoot)
	{
		//如果父节点为根节点，更改根节点的指向
		_pRoot = rchild;
	}
	else
	{
		//判断原本的父节点是父节点父亲的左孩子还是右孩子
		if (ppar->_pLeft == par)
		{
			ppar->_pLeft = rchild;
		}
		else
		{
			ppar->_pRight = rchild;
		}
	}
}

右单旋

右单旋的情况和左单旋基本一致，只是反向了，是镜像操作，不多赘述了。

简单的右单旋的情况：

在这里插入图片描述

右单旋的情况后：

在这里插入图片描述

最终代码：

void RightRotate(Node* par)
{
	//左孩子
	Node* lchild = par->_pLeft;
	//父节点的父亲
	Node* ppar = par->_pParent;

	//**左孩子的右孩子**
	Node* lrchild = lchild->_pRight;

	//旋转操作
	//左孩子的右孩子改成父节点
	lchild->_pRight = par;

	//**父节点的左孩子变成原本左孩子的右孩子**
	par->_pLeft = lrchild;

	//父节点的父亲改为右孩子
	par->_pParent = rchild;
	//左孩子的父亲改为父节点的父亲
	lchild->_pParent = ppar;

	//**如果左右孩子存在，其父节点需要改变为原本的父节点**
	if (lrchild)
		lrchild->_pParent = par;

	//改变平衡因子
	par->_bf = 0;
	lchild->_bf = 0;

	if (par == _pRoot)
	{
		//如果父节点为根节点，更改根节点的指向
		_pRoot = rchild;
	}
	else
	{
		//判断原本的父节点是父节点父亲的左孩子还是右孩子
		if (ppar->_pLeft == par)
		{
			ppar->_pLeft = lchild;
		}
		else
		{
			ppar->_pRight = lchild;
		}
	}
}

左右双旋

左右双旋的情况如下：

在这里插入图片描述

这种情况下就不能只进行右旋了，单纯右旋会变成这样：

在这里插入图片描述

情况并没有改变，只是变了个方向，所以需要先对左孩子进行左旋，然后对整体右旋：

左孩子左旋：

在这里插入图片描述

整体右旋：

在这里插入图片描述
旋转之后改变平衡因子，根据是否有孩子分类讨论平衡因子的改变，下面会进行分类：

实现代码：

void LeftRightRotate(Node* par)
{
	//左孩子
	Node* lchild = par->_pLeft;
	//左孩子的右孩子
	Node* lrchild = lchild->_pRight;
	//父节点的父亲
	Node* ppar = par->_pParent;

	LeftRotate(lchild);
	RightRotate(par);

	//平衡因子改变...........

}

情况一：

在这里插入图片描述

当前情况下，lrchild的bf平衡因子为0，结果为三个节点的平衡因子都为0，代码为：

void LeftRightRotate(Node* par)
{
	//左孩子
	Node* lchild = par->_pLeft;
	//左孩子的右孩子
	Node* lrchild = lchild->_pRight;
	//父节点的父亲
	Node* ppar = par->_pParent;

	LeftRotate(lchild);
	RightRotate(par);

	if (lrchild->_bf == 0)
	{
		par->_bf = 0;
		lchild->_bf = 0;
		lrchild->_bf = 0;
	}
	else if (lrchild->_bf == -1)
	{
	
	}
	else if (lrchild->_bf == 1)
	{
	
	}
	else
	{
		assert(flase);
	}

}

情况二：

在这里插入图片描述

此情况下lrchild的BF = -1， 旋转后结果如图，代码如下：

void LeftRightRotate(Node* par)
{
	//左孩子
	Node* lchild = par->_pLeft;
	//左孩子的右孩子
	Node* lrchild = lchild->_pRight;
	//父节点的父亲
	Node* ppar = par->_pParent;

	LeftRotate(lchild);
	RightRotate(par);

	if (lrchild->_bf == 0)
	{
		par->_bf = 0;
		lchild->_bf = 0;
		lrchild->_bf = 0;
	}
	else if (lrchild->_bf == -1)
	{
		par->_bf = 1;
		lchild->_bf = 0;
		lrchild->_bf = 0;
	}
	else if (lrchild->_bf == 1)
	{

	}
	else
	{
		assert(flase);
	}

}

情况三：

在这里插入图片描述
此情况下lrchild的BF = 1， 旋转后结果如图，代码如下：

void LeftRightRotate(Node* par)
{
	//左孩子
	Node* lchild = par->_pLeft;
	//左孩子的右孩子
	Node* lrchild = lchild->_pRight;
	//父节点的父亲
	Node* ppar = par->_pParent;

	LeftRotate(lchild);
	RightRotate(par);

	if (lrchild->_bf == 0)
	{
		par->_bf = 0;
		lchild->_bf = 0;
		lrchild->_bf = 0;
	}
	else if (lrchild->_bf == -1)
	{
		par->_bf = 1;
		lchild->_bf = 0;
		lrchild->_bf = 0;
	}
	else if (lrchild->_bf == 1)
	{
		par->_bf = 0;
		lchild->_bf = -1;
		lrchild->_bf = 0;
	}
	else
	{
		assert(flase);
	}

}

右左双旋

右左双旋类似与上，最终代码如下：

void RightLeftRotate(Node* par)
{
	Node* ppar = par->_pParent;
	Node* rchild = par->_pRight;
	Node* rlchile = rchild->_pLeft;
	
	RotateR(par->_pRight);
	RotateL(par);
	
	int bf = rlchile->_bf;
	
	if (bf == 0)
	{
		par->_bf = 0;
		rchild->_bf = 0;
		rlchile->_bf = 0;
	}
	else if (bf == -1)
	{
		par->_bf = 0;
		rchild->_bf = 1;
		rlchile->_bf = 0;
	}
	else if (bf == 1)
	{
		par->_bf = -1;
		rchild->_bf = 0;
		rlchile->_bf = 0;
	}
	else
	{
		assert(false);
	}

}

余下的查找查找，删除等雷同与二叉搜索树，只是在此基础上加入旋转操作，不在赘述。

AVl树以高度递归实现完整代码

typedef struct Treenode
{
	int data;
	struct Treenode* left;
	struct Treenode* right;
	int height;
}node;



node* BuyNode(int x)
{
    Treenode* newnode = new node;
    if (newnode == nullptr)
    {
        perror("New node:");
        exit(-1);
    }
       
    newnode->data = x;
    newnode->height = 1;
    newnode->left = nullptr;
    newnode->right = nullptr;
    return newnode;
}

int GetAVLheight(node* n)
{
    if(n == nullptr)
        return 0;

    return n->height;
}

int GetBalance(node* root)
{
    if(root == nullptr)
        return 0;

    return GetAVLheight(root->left) - GetAVLheight(root->right);
}

void updataHeight(node* root)
{
    root->height = max(GetAVLheight(root->left), GetAVLheight(root->right)) + 1;
}

void PreOrder(node* root)
{
    if (root == nullptr)
    {
        cout << " null";
        return;
    }

    cout << " " << root->data;
    PreOrder(root->left);
    PreOrder(root->right);
}

void DestroyAVLTree(node* root)
{
    if (root == nullptr)
    {
        return;
    }

    DestroyAVLTree(root->left);
    DestroyAVLTree(root->right);

    free(root);
}

node* DeleteNode(node* cur, int val)
{
    if (cur == nullptr) return cur;

    if (cur->data > val)
    {
        cur->left = DeleteNode(cur->left, val);
    }
    else if (cur->data < val)
    {
        cur->right = DeleteNode(cur->right, val);
    }
    else
    {
        if (cur->right == nullptr && cur->left == nullptr)
        {
            free(cur);
            cur = nullptr;
        }
        else if (!(cur->right && cur->left) && (cur->left || cur->right))
        {
            node* tem = nullptr;
            if (cur->left)
                tem = cur->left;
            else
                tem = cur->right;

            cur->data = tem->data;
            cur->left = cur->right = nullptr;
            delete tem;
        }
        else
        {
            node* tem = cur->right;

            while (tem->left != nullptr)
                tem = tem->left;

            cur->data = tem->data;
            cur->right = DeleteNode(cur->right, tem->data);
        }
    }

    if (cur == nullptr) return cur;

    updataHeight(cur);

    int br = GetBalance(cur);
    int bl = GetBalance(cur->left);
    int brr = GetBalance(cur->right);

    //LL
    if (br > 1 && bl >= 0)
    {
        return RightRotate(cur);
    }

    //LR
    if (br > 1 && bl < 0)
    {
        cur->left = LeftRotate(cur->left);
        return RightRotate(cur);
    }

    //RR
    if (br < -1 && brr <= 0)
    {
        return LeftRotate(cur);
    }

    //RL
    if (br < -1 && brr > 0)
    {
        cur->right = RightRotate(cur->right);
        return LeftRotate(cur);
    }

    return cur;
}

node* LeftRotate(node* root)
{
    if (root == nullptr)
        return root;

    node* newroot = root->right;
    node* tem = newroot->left;

    newroot->left = root;
    root->right = tem;

    updataHeight(root);
    updataHeight(newroot);

    return newroot;
}

node* RightRotate(node* root)
{
    if (root == nullptr)
        return root;

    node* newroot = root->left;
    node* tem = newroot->right;

    newroot->right = root;
    root->left = tem;

    updataHeight(root);
    updataHeight(newroot);

    return newroot;
}

node* InsertAVLTree(node* root, int val)
{
    if (root == nullptr)
    {
        return BuyNode(val);
    }

    if (root->data < val)
    {
        root->right = InsertAVLTree(root->right, val);
    }
    else if (root->data > val)
    {
        root->left = InsertAVLTree(root->left, val);
    }

    updataHeight(root);

    int br = GetBalance(root);
    int bl = GetBalance(root->left);
    int brr = GetBalance(root->right);

    //LL
    if (br > 1 && bl > 0)
    {
        return RightRotate(root);
    }

    //LR
    if (br > 1 && bl < 0)
    {
        root->left = LeftRotate(root->left);
        return RightRotate(root);
    }

    //RR
    if (br < -1 && brr < 0)
    {
        return LeftRotate(root);
    }

    //RL
    if(br < -1 && brr > 0)
    {
        root->right = RightRotate(root->right);
        return LeftRotate(root);
    }

    return root;

}
深思慎考
关注
平衡搜索二叉树——AVL树
h1091068389的博客
06-03 391
正常的搜索二叉树中，一般而言查找一个数的时间复杂度几乎可以等价于log2N，但是正常的搜索二叉树可能会遇到一些极端情况，例如按照1，2，3，4插入数组，此时的搜索二叉树便会变为如下的情况： 这种数据有序或者接近有序的插入数据此时的搜索二叉树会退化为一个单分支，此时查找效率就变成了O(n)，并不能体现搜索二叉树的优势。此时，有两位数学家提出了一种方法来解决这种问题：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜
平衡二叉树——AVL树的实现
子同的专栏
09-05 2107
AVL树是最先发明的自平衡二叉查找算法，是平衡二叉树的一种。在AVL中任何节点的两个儿子子树的高度最大差别为1，所以它又被成为高度平衡树。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来平衡这棵树。 假设把AVL树构造过程中需要重新平衡的节点叫做α。由于任意节点最多有两个儿子，因此高度不平衡时，α点的两颗子树的高度差2。这种不平衡可能出现在下面这四
平衡二叉树——AVL树
sun_0228的博客
12-08 216
AVL树的构建，插入，旋转
【C语言】平衡二叉树——AVL树
weixin_44348253的博客
11-27 587
在构建二叉排序树的过程中，每当插入一个结点时，先检查是否因插入而破坏了树的平衡性，若是，则找出最小不平衡子树。在保持二叉排序树特性的前提下，调整最小不平衡子树中各结点之间的连接关系，进行相应选转，使之成为新的平衡子树。
平衡二叉树——AVL树（Java实现）
qq_40401156的博客
10-22 460
平衡二叉树——AVL树 文章目录平衡二叉树——AVL树1、二叉搜索树的缺点2、AVL树的性质3、为何能保持平衡3.1、判断失衡的方式——平衡因子3.2、四种失衡的情况3.3、解决失衡的方法——旋转3.4、四种情况对应的旋转方式4、平衡二叉树实现4.1、节点结构4.2、AVL树完整代码4.3、测试 1、二叉搜索树的缺点 平衡二叉树是二叉搜索树的改进版，二叉搜索树用来快速的对数据进行查找，可以将原先O(n)的复杂度降低到O(logn)，但这是在理想情况下的结果，若在原序列是有序的情况下，构建出的二叉搜索树就是线
【进阶数据结构】平衡搜索二叉树 —— AVL树
East-sunrise的博客
03-21 1124
平衡的AVL树真的很美
Java数据结构——平衡二叉树(AVL树)
m0_62969222的博客
05-31 3367
AVL树的引入 搜索二叉树有着极高的搜索效率，但是搜索二叉树会出现以下极端情况： 这样的二叉树搜索效率甚至比链表还低。在搜索二叉树基础上出现的平衡二叉树(AVL树)就解决了这样的问题。当平衡二叉树(AVL树)的某个节点左右子树高度差的绝对值大于1时，就会通过旋转操作减小它们的高度差。 基本概念 AVL树本质上还是一棵二叉搜索树，它的特点是： 本身首先是一棵二叉搜索树。 每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）
C/C++数据结构（十一）—— 平衡二叉树（AVL树）
热门推荐
Edison's 小宇宙
01-19 2万+
平衡二叉树又称为 AVL 树，其实就是一颗 平衡的二叉搜索树，解决了二叉搜索树的不平衡问题。
平衡二叉树——AVL树的旋转操作：Java语言实现（这篇有误， 后续会重写订正，不要再学习这篇了！！！）
cqulun123的博客
05-21 3536
1 前言 最近在研读《数据结构与算法经典问题解析》和《数据结构与算法分析 c语言描述》两本书，记录一下学习AVL树的笔记。2 平衡二叉树——AVL树的旋转操作2.1 AVL树的特点AVL树本质上还是一棵二叉搜索树，它的特点是：1.本身首先是一棵二叉搜索树。2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。也就是说，AVL树，本质上是带了平衡功能的二叉查找树（...
平衡二叉树（AVL树）
Ronz 的博客
01-24 7434
一、平衡二叉树概述 1.1 什么是平衡二叉树 平衡二叉树也叫 AVL 树。平衡二叉树是具有以下特点的二叉查找树：它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1， 并且左右两个子树都是一棵平衡二叉树。 图一 平衡二叉树 图二 非平衡二叉树 1.2 为什么要有平衡二叉树 在上一篇文章 二叉排序树 中对二叉排序树做了介
数据结构与算法——平衡二叉树（AVL树）与红黑树（R-B树)
nswdiphone6的博客
03-12 388
二叉平衡树（AVL） **二叉排序树存在的问题：**假定给出数组{1，2，3，4，5，6} 问题分析： 左子树全部为空，从形式上看，更像一个单链表。 插入速度没有影响，但查询速度明显降低（需要依次比较）不能发挥BST的优势，因为每次还需要比较左子树，查询速度比单链表还慢。 解决方法：平衡二叉树（AVL） AVL树本质上是一颗二叉排序树，但是它又具有以下特点： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1。 并且左右两个子树都是一棵平衡二叉树。 平衡因子(bf)：结点的左子树的深度减去
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1223
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C语言系统编程】【第三部分：网络编程】3.2 数据传输和协议
10-03 1556
在进行网络编程时，有时需要设计并实现自定义协议，以满足特定应用的需求。自定义协议设计需要考虑到数据的传输、安全、效率等多方面因素。清晰性：协议应具有清晰的语法和语义，使开发者能快速理解和实现。扩展性：协议应允许未来的功能扩展，而不破坏现有功能。安全性：数据传输过程中应考虑加密和校验，以保证数据不被篡改。高效性：应尽可能减少网络带宽占用，提升数据传输效率。容错性：协议应能处理各种网络异常情况，如数据丢失、重复和延迟。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1731
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
windows C++-创建数据流代理(三)
苏洛的博客
10-08 293
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
C++访问权限
qq_51365682的博客
10-02 123
保护权限 protect 成员类内可以访问 类外不可以访问 子类可以访问父类中的保护内容。私有权限private 成员类内可以访问 类外不可以访问 子类不可以访问负类私有内容。公共权限 public 成员类内可以访问 类外可以访问。
C++ | Leetcode C++题解之第463题岛屿的周长
最新发布
Ddddddd_158的博客
10-08 462
C++ | Leetcode C++题解之第463题岛屿的周长
红黑树对比平衡二叉树
10-21
红黑树和平衡二叉树都是一种二叉查找树，但是红黑树相对于平衡二叉树来说更加灵活，因为它只要求保证没有一条路径会比其它路径长出两倍，而不是要求严格的整体平衡。这样就可以减少维护平衡所付出的代价，提高效率。相对于平衡二叉树，红黑树的旋转次数少，所以对于搜索、插入、删除操作较多的情况下，我们就用红黑树。而平衡二叉树则更适合对查找要求较高，插入删除不频繁的情况。另外，还有一种更加严格的平衡二叉树——AVL树，它使用平衡因子差值判断是否平衡，左右子树树高不超过1，并通过旋转来实现平衡。但是由于旋转操作是非常耗时的，因此AVL树适合用于插入与删除次数比较少，但查找多的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值