C++: AVL树

于 2024-09-16 19:03:03 发布
阅读量1k 收藏 25
点赞数 39
分类专栏： C++ 文章标签： c++ 开发语言 算法 数据结构 b树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75644377/article/details/142302571
版权

你的时间有限, 所以不要为别人而活, 不要被教条所限, 不要活在别人的观念里, 不要让别人的意见左右自己内心的声音. -- 乔布斯

目录

正文开始

博客主页: 酷酷学!!!

1. AVL树的概念

二叉搜素树虽然可以缩短查找的效率, 但如果数据有序或接近有序二叉搜索树将退化为单支树, 查找元素相当于在顺序表中搜索元素, 效率低下, 因此, 两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法:
当向二叉搜索树中插入新节点后, 如果能保证每个节点的左右子树高度之差的绝对值不超过1(需要对树中的节点进行调整), 即可降低树的高度, 从而减少平均搜索长度.

一棵AVL树或者是空树, 或者是具有以下性质的二叉搜素树:

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

在这里插入图片描述
如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 O ( l o g 2 n ) O(log_2 n) O(log2​n)，搜索时间复杂度O( l o g 2 n log_2 n log2​n)。

2. AVL树节点的定义

template<class K,class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//balance factor

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _parent(nullptr)
		, _parent(nullptr)
		, _bf(0) 
	{}
};

3. AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

  1. 按照二叉搜索树的方式插入新节点
  2. 调整节点的平衡因子

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

    // 1. 先按照二叉搜索树的规则将节点插入到AVL树中
    // 2. 新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否破坏了AVL树的平衡性
 /*
 pCur插入后，pParent的平衡因子一定需要调整，在插入之前，pParent
 的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：
  1. 如果pCur插入到pParent的左侧，只需给pParent的平衡因子-1即可
  2. 如果pCur插入到pParent的右侧，只需给pParent的平衡因子+1即可
  
  此时：pParent的平衡因子可能有三种情况：0，正负1， 正负2
  1. 如果pParent的平衡因子为0，说明插入之前pParent的平衡因子为正负1，插入后被调整成0，此时满足AVL树的性质，插入成功
  2. 如果pParent的平衡因子为正负1，说明插入前pParent的平衡因子一定为0，插入后被更新成正负1，此时以pParent为根的树的高度增加，需要继续向上更新
  3. 如果pParent的平衡因子为正负2，则pParent的平衡因子违反平衡树的性质，需要对其进行旋转处理
 */

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_left)
				parent->_bf--;
			else
				parent->_bf++;

			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent == -1)
			{
				//祖先受到影响
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//不平衡了,旋转处理
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

4. AVL树的旋转

在这里插入图片描述

4.1 左单旋

上述过程可以抽象为 左单旋

在这里插入图片描述

假设h为大于等于0的AVL子树, 做单旋的情况如下

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
编写代码:

	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		subR->_left = parent;
	}

核心代码就是让subRL变成parent的左边, parent变成subR的右边. 但是不要忘了, 我们拥有了parent节点和平衡因子带给我们的遍历, 所以更不要忘了进行维护

	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		subR->_left = parent;

		if (subRL)
			subRL->_parent = parent;
		Node* parentParent = parent->_parent;
		parent->_parent = subR;
		if (parentParent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;
			subR->_parent = parentParent;
		}
		parent->_bf = subR->_bf = 0;
	}

4.2 右单旋

在这里插入图片描述
有了左单旋的理解, 不难写出右单旋

	//右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		subL->_right = parent;
		Node* parentParent = parent->_parent;
		parent->_parent = subL;
		if (parentParent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
				parentParent->_left = subL;
			else
				parentParent->_right = subL;
			subL->_parent = parentParent;
		}
		parent->_bf = subL->_bf = 0;
	}

4.3 右左单旋

对于这种情况, 左单旋使右边节点多, 把左边压下去, 这中可以解决.
在这里插入图片描述

对于这种情况, 单纯依靠左单旋是无法进行解决的了,因为左单旋会把新subRL给到parent的右边, 所以左右还是达不到平衡
在这里插入图片描述

对于h==1也是一样
在这里插入图片描述
如何解决呢? 先以subR作为旋转点进行右旋,然后再左旋.

在这里插入图片描述
抽象图如下:

在这里插入图片描述

进行一层一层的分析

在这里插入图片描述

但是插入之后我们还需要更改平衡因子,关键看subRL的平衡因子, 是在subRL的左边插入还是右边插入, 所以插入之前我们需要先保存subRL的平衡因子, 再以结果为导向进行直接的修改.

如果subRL为0, 说明使h==0的情况, 此时右左旋转之后三者平衡因子都为0, 其它节点不变, h>0时如下:

在c插入时, 插入时, subRL为1, 最后旋转之后, 平衡因子应更新为parent->_bf = -1.
在这里插入图片描述

在c插入时, 插入时, subRL为-1, 最后旋转之后, 平衡因子应更新为subR->_bf = 1.
在这里插入图片描述

编写代码:

	//右左旋转
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 0)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

4.4 左右单旋

在这里插入图片描述
编写代码:

	//左右单旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);
		if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

5. 完整代码

#pragma once

#include<assert.h>
#include<iostream>
using namespace std;

template<class K,class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//balance factor

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0) 
	{}
};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
		:_root(nullptr)
	{}


	AVLTree(const AVLTree<K, V>& t)
	{
		_root = Copy(t._root);
	}

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

	~AVLTree()
	{
		Destory(_root);
		_root = nullptr;
	}

	//插入
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_left)
				parent->_bf--;
			else
				parent->_bf++;

			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				//祖先受到影响
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//不平衡了,旋转处理
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					RotateLR(parent);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

	//查找
	Node* Find(const pair<K, V>& kv)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

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

	int Height()
	{
		return _Height(_root);
	}

	bool IsBalanceTree()
	{
		return _IsBalanceTree(_root);
	}


private:

	bool _IsBalanceTree(Node* pRoot)
	{
		// 空树也是AVL树
		if (nullptr == pRoot) return true;
		// 计算pRoot节点的平衡因子：即pRoot左右子树的高度差
		int leftHeight = _Height(pRoot->_left);
		int rightHeight = _Height(pRoot->_right);
		int diff = rightHeight - leftHeight;
		// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
	// pRoot平衡因子的绝对值超过1，则一定不是AVL树
		if (diff != pRoot->_bf || (diff > 1 || diff < -1))
			return false;
		// pRoot的左和右如果都是AVL树，则该树一定是AVL树
		return _IsBalanceTree(pRoot->_left) && _IsBalanceTree(pRoot->_right);
	}

	int _Height(Node* pRoot)
	{
		if (pRoot == nullptr) return 0;
		int heightl = _Height(pRoot->_left);
		int heightr = _Height(pRoot->_right);
		return  heightl > heightr ? heightl + 1 : heightr + 1;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		subR->_left = parent;

		if (subRL)
			subRL->_parent = parent;
		Node* parentParent = parent->_parent;
		parent->_parent = subR;
		if (parentParent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;
			subR->_parent = parentParent;
		}
		parent->_bf = subR->_bf = 0;
	}

	//右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		subL->_right = parent;
		Node* parentParent = parent->_parent;
		parent->_parent = subL;
		if (parentParent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
				parentParent->_left = subL;
			else
				parentParent->_right = subL;
			subL->_parent = parentParent;
		}
		parent->_bf = subL->_bf = 0;
	}

	//右左旋转
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 0)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	//左右单旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);
		if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}


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

	AVLTree* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* newnode = new Node(root->_kv);
		newnode->_left = Copy(root->_left);
		newnode->_right = Copy(root->_right);
		return newnode;
	}
	Node* _root;
};

测试

VL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

  1. 验证其为二叉搜索树
    如果中序遍历可得到一个有序的序列，就说明为二搜索树
  2. 验证其为平衡树
    每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)节点的平衡因子是否计算正确
	bool _IsBalanceTree(Node* pRoot)
	{
		// 空树也是AVL树
		if (nullptr == pRoot) return true;
		// 计算pRoot节点的平衡因子：即pRoot左右子树的高度差
		int leftHeight = _Height(pRoot->_left);
		int rightHeight = _Height(pRoot->_right);
		int diff = rightHeight - leftHeight;
		// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
	// pRoot平衡因子的绝对值超过1，则一定不是AVL树
		if (diff != pRoot->_bf || (diff > 1 || diff < -1))
			return false;
		// pRoot的左和右如果都是AVL树，则该树一定是AVL树
		return _IsBalanceTree(pRoot->_left) && _IsBalanceTree(pRoot->_right);
	}

	int _Height(Node* pRoot)
	{
		if (pRoot == nullptr) return 0;
		int heightl = _Height(pRoot->_left);
		int heightr = _Height(pRoot->_right);
		return  heightl > heightr ? heightl + 1 : heightr + 1;
	}

//avl.h

void TestAVLTree()
{
	AVLTree<int, int> t;
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14};
	for (auto e : a)
	{
		t.Insert({ e, e });
	}
	//cout << t.Height() << endl;
	
	t.InOrder();
	cout << t.IsBalanceTree() << endl;
}

//test.c

#include"avl.h"

int main()
{
	TestAVLTree();
	return 0;
}

在这里插入图片描述

6. AVL树的删除(了解)

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。(面试一般不考察)

在这里插入图片描述

具体实现可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

7. AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即 l o g 2 ( N ) log_2 (N) log2​(N)。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

总结

假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑

  1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
  • 当pSubR的平衡因子为1时，执行左单旋
  • 当pSubR的平衡因子为-1时，执行右左双旋
  1. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL
  • 当pSubL的平衡因子为-1是，执行右单旋
  • 当pSubL的平衡因子为1时，执行左右双旋

旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。

完

酷酷学!!!
关注
专栏目录
平衡二叉搜索树：AVL树的实现与分析 以及 统一重平衡算法 （C++）
amoscykl的博客
08-11 1454
平衡二叉搜索树 既然二叉搜索树的性能主要取决于高度,故在节点数目固定的前提下,应尽可能地降低高度。 相应地,应尽可能地使兄弟子树的高度彼此接近,即全树尽可能地平衡。   等价变换 等价二叉搜索树：若两棵二叉搜索树的中序遍历序列相同,则称它们彼此等价;反之亦然。   旋转调整 最基本的修复手段，通过围绕特定节点的旋转，实现等价前提下的局部拓扑调整。 zig和zag：    ...
C++平衡Avl树实现.zip
08-20
在这篇文章中，我们将深入探讨C++实现AVL树的关键知识点。 首先，我们需要理解AVL树的基本概念。AVL树是一种特殊的二叉搜索树，其特点是每个节点的两个子树的高度差不超过1，这确保了AVL树的高度平衡。这种平衡性...
C++：AVL树
zhang_si_hang的博客
08-19 987
二叉搜索树虽可以缩短查找的效率，但。
C++:AVL树
m0_61088872的博客
07-11 898
其不会影响自身的AVL结构，所以不用对自生做操作，但是由于其高度增加了，所以有可能会影响其父节点，那么此时我们就要去看看父节点是否平衡。一般的二叉搜索树在插入新节点以及删除节点时，都有可能会破坏树的平衡，所以AVL树需要对插入以及删除接口做修改，每次插入删除时，都要检测一下当前的树时候符合AVL树，如果不符合，要做出相应的调整措施。，称为平衡因子(balance factor)，其值为左右子树高度的差值，当这个差值的绝对值>=2，就说明这个节点的左右子树不平衡，那么我们就要使用相应的手段调整这棵树。
c++：AVL树简析
qq_62718027的博客
08-12 541
向树中插入新结点后，要能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整， 即可降低树的高度，从而减少平均搜索长度）一旦平衡因子达到了2或者-2，那么我们就需要进行旋转，来使结点所有平衡因子在-1到1的合理区间内。AVL其实是搜索二叉树的一种特殊模式。...
中级C++：AVL树
kimsaul的白给岁月
06-25 638
AVL树的特征；平衡因子，更新平衡因子代码；左左类型：右旋；右右类型：左旋；左右类型：先左旋，再右旋；右左类型：先右旋，再左旋；验证是否是AVL树。
数据结构/C++：AVL树
盒马的博客
03-10 1198
讲解以C++实现的数据结构AVL树，详细解释各种AVL旋转操作
AVLComparison:AVL 树的 C++ 和 Haskell 运行时效率比较
07-05
在本项目"AVLComparison:AVL 树的 C++ 和 Haskell 运行时效率比较"中，我们将探讨这两种编程语言实现AVL树的性能差异。 首先，让我们关注C++的实现。C++是一种静态类型的、编译式的、通用的、大小写敏感的、不仅...
AVL-Tree:AVL树C ++解决方案
04-01
在C++中实现AVL树，首先需要定义一个结构体或类来表示树的节点，通常包括以下部分： ```cpp struct TreeNode { int key; TreeNode* left; TreeNode* right; int height; }; ``` 这里的`key`是节点的值，`left`...
基于C++ AVL树的航空客运订票系统【100012693】
06-12
《基于C++ AVL树的航空客运订票系统详解》 航空客运订票系统是现代航空公司运营中的关键组成部分，它能够高效地处理航班信息、预订和退票等业务。本项目以C++编程语言为基础，利用AVL树这一自平衡二叉搜索树的数据...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 165
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 512
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
CF C. Nikita and LCM
qq_74190237的博客
09-13 258
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C和指针：标准函数库
暮色年华的博客
09-11 675
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 467
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 904
set、map仿STL模拟实现
【C++ && Qt day11】
wzj46的博客
09-11 273
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1059
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 450
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

酷酷学!!!

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

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

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

打赏作者

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

抵扣说明：

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

余额充值