【C++进阶】AVL树的实现

已于 2023-03-19 20:55:27 修改
阅读量330 收藏 2
点赞数 1
分类专栏： C++初阶和高阶 文章标签： c++ 数据结构 算法
于 2023-03-19 20:53:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67077469/article/details/129654614
版权
文章介绍了AVL树的概念，这是一种自平衡的二叉搜索树，确保左右子树高度差不超过1。在插入新节点后，通过更新平衡因子并根据情况进行四种类型的旋转（右单旋、左单旋、左右双旋、右左双旋）来保持树的平衡，从而保持高效的搜索性能。代码示例展示了插入节点和旋转处理的详细步骤。
摘要由CSDN通过智能技术生成

文章目录

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)。

AVL树节点的结构

实现的是KV模型
平衡因子的计算方法由第二种方法实现
在这里插入图片描述

AVL树的插入

分为三个步骤
1.按照二叉搜索树的方式插入新节点
2.更新整体节点的平衡因子
3.更新平衡因子的过程中判断是否需要旋转

插入新节点

bool Insert(const pair<K, V>& kv)
{
	Node* parent = nullptr;
	Node* cur = _root;

	//如果根为空
	if (_root == nullptr)
	{
		_root = new Node(kv);
		return true;
	}

	//寻找插入位置
	while (cur)
	{
				//如果要插入的值比cur的值小
		if (cur->_kv.first > kv.first)
		{
			//往左找
			parent = cur;
			cur = cur->_left;
		}
		//如果要插入的值比cur的值大
		else if (cur->_kv.first < kv.first)
		{
			//往右找
			parent = cur;
			cur = cur->_right;
		}
		//如果相等就不再插入
		else
		{
			return false;
		}
	}

	//插入
	Node* newnode = new Node(kv);
	cur = newnode;
	if (parent->_kv.first > kv.first)
	{
		parent->_left = newnode;
		newnode->_parent = parent;
		//父母节点更新平衡因子
		parent->_bf--;
	}
	else
	{
		parent->_right = newnode;
		newnode->_parent = parent;
		//父母节点更新平衡因子
		parent->_bf++;
	}
}

更新整体节点的平衡因子

更新整体节点的平衡因子过程中分三种情况：

1.首先在插入的过程中，更新插入节点的父母节点的平衡因子
在这里插入图片描述

2.更新以后判断父母节点的平衡因子
（1）更新后父母节点的平衡因子是0
停止更新，说明更新前父母节点的平衡因子是1或者-1，现在变成0也表明了父母节点的左右子树中高度矮的子树插入了新节点
在这里插入图片描述

if (parent->_bf == 0)
	{
		break;
	}

（2）更新后父母节点的平衡因子是1或者-1
继续向上更新， 说明更新前父母节点的平衡因子是0，现在是1或者-1，也表明父母节点的左右子树中的一颗树的高度变高了。父母节点所在的子树高度也变高了。
在这里插入图片描述
在这里插入图片描述

else if (parent->_bf == 1 || parent->_bf == -1)
	{
		cur = parent;
		//继续向上更新
		parent = parent->_parent;
		if (parent)
		{
			if (parent->_left == cur)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
		}
					
	}

（3）更新后父母节点的平衡因子是2或者-2
说明父母节点所在的子树已经不平衡了需要旋转处理

在这里插入图片描述

else if (parent->_bf == 2 || parent->_bf == -2)
	{
					
		if (parent->_bf == -2 && cur->_bf == -1)
		{
			//右单旋
			RotateR(parent);
		}
		else if (parent->_bf == 2 && cur->_bf == 1)
		{
			//左单旋
			RotateL(parent);
		}
		else if (parent->_bf == -2 && cur->_bf == 1)
		{
			//左右双旋
			RotateLR(parent);

		}
		else if (parent->_bf == 2 && cur->_bf == -1)
		{
			//右左双旋
			RotateRL(parent);
						
		}
		else
		{
			//不可能的情况
			assert(false);
		}
					
		break;
	}

整体的插入代码

//更新整体平衡因子
while (parent)
{
	if (parent->_bf == 0)
	{
		break;
	}
	else if (parent->_bf == 1 || parent->_bf == -1)
	{
		cur = parent;
		//继续向上更新
		parent = parent->_parent;
		if (parent)
		{
			if (parent->_left == cur)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
		}
					
	}
	else if (parent->_bf == 2 || parent->_bf == -2)
	{
					
		if (parent->_bf == -2 && cur->_bf == -1)
		{
			//右单旋
			RotateR(parent);
		}
		else if (parent->_bf == 2 && cur->_bf == 1)
		{
			//左单旋
			RotateL(parent);
		}
		else if (parent->_bf == -2 && cur->_bf == 1)
		{
			//左右双旋
			RotateLR(parent);

		}
		else if (parent->_bf == 2 && cur->_bf == -1)
		{
			//右左双旋
			RotateRL(parent);
						
		}
		else
		{
			//不可能的情况
			assert(false);
		}
					
		break;
	}
	else
	{
		//不可能的情况
		assert(false);
	}
}

旋转处理

旋转处理是为了处理保证二叉搜索树处于平衡状态，每当二叉搜索树不平衡时就会触发旋转。
旋转又分4种分别处理4种不平衡的情况。

右单旋

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

void RotateR(Node* parent)
{
	//要调整的节点
	Node* sub = parent;
	//要调整的节点的左孩子
	Node* subL = parent->_left;
	//要调整的节点的左孩子的右孩子
	Node* subLR = subL->_right;

	//要调整的节点的父母
	Node* subparent = sub->_parent;

	//重新链接关系
	if (subLR)
		subLR->_parent = sub;
	sub->_left = subLR;

	sub->_parent = subL;
	subL->_right = sub;

	subL->_parent = subparent;

	if (_root == sub)
	{
		_root = subL;
	}
	else
	{
		if (subparent->_left == sub)
		{
			subparent->_left = subL;
		}
		else
		{
			subparent->_right = subL;
		}
	}

	subL->_bf = sub->_bf = 0;
}

左单旋

在这里插入图片描述

void RotateL(Node* parent)
{
	//要调整的节点
	Node* sub = parent;
	//要调整的节点的右孩子
	Node* subR = parent->_right;
	//要调整的节点的有孩子的左孩子
	Node* subRL = subR->_left;

	//要调整的节点的父母
	Node* subparent = sub->_parent;

	//重新链接关系
	if (subRL)
		subRL->_parent = sub;
	sub->_right = subRL;

	sub->_parent = subR;
	subR->_left = sub;

	subR->_parent = subparent;

	if (_root == sub)
	{
		_root = subR;
	}
	else
	{
		if (subparent->_left == sub)
		{
			subparent->_left = subR;
		}
		else
		{
			subparent->_right = subR;
		}
	}
	subR->_bf = sub->_bf = 0;
}

左右双旋

在这里插入图片描述

void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf;
	RotateL(parent->_left);
	RotateR(parent);
	if (bf == -1)
	{
		parent->_bf = 1;
		subL->_bf = 0;
		subLR->_bf = 0;
	}
	else if (bf == 1)
	{
		parent->_bf = 0;
		subLR->_bf = 0;
		subL->_bf = -1;
	}
	else if (bf == 0)
	{
		parent->_bf = 0;
		subLR->_bf = 0;
		subL->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

右左双旋

在这里插入图片描述

void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;
	RotateR(parent->_right);
	RotateL(parent);
	if (bf == -1)
	{
		parent->_bf = 0;
		subR->_bf = 1;
		subRL->_bf = 0;
	}
	else if (bf == 1)
	{
		parent->_bf = -1;
		subRL->_bf = 0;
		subR->_bf = 0;
	}
	else if (bf == 0)
	{
		parent->_bf = 0;
		subRL->_bf = 0;
		subR->_bf = 0;
	}
	else
	{
		assert(false);
	}
			

}

AVL树的整体代码

AVL.h

#pragma once
#include<assert.h>
namespace lzf
{
	template<class K, class V>
	struct AVLTreeNode
	{
		AVLTreeNode<K, V>* _left;//该节点的左孩子
		AVLTreeNode<K, V>* _right;//该节点的右孩子
		AVLTreeNode<K, V>* _parent;//该节点的双亲节点
		pair<K, V> _kv;//该节点的kv

		int _bf;//该节点的平衡因子
		
		//构造函数
		AVLTreeNode(const pair<K, V>& kv)
			:_left(nullptr)
			,_right(nullptr)
			,_parent(nullptr)
			,_bf(0)
			,_kv(kv)
		{}
	};

	template<class K,class V>
	class AVLTree
	{
		typedef AVLTreeNode<K, V> Node;
	public:
		AVLTree()
			:_root(nullptr)
		{}
		bool Insert(const pair<K, V>& kv)
		{
			Node* parent = nullptr;
			Node* cur = _root;

			//如果根为空
			if (_root == nullptr)
			{
				_root = new Node(kv);
				return true;
			}

			//寻找插入位置
			while (cur)
			{
				//如果要插入的值比cur的值小
				if (cur->_kv.first > kv.first)
				{
					//往左找
					parent = cur;
					cur = cur->_left;
				}
				//如果要插入的值比cur的值大
				else if (cur->_kv.first < kv.first)
				{
					//往右找
					parent = cur;
					cur = cur->_right;
				}
				//如果相等就不再插入
				else
				{
					return false;
				}
			}

			//插入
			Node* newnode = new Node(kv);
			cur = newnode;
			if (parent->_kv.first > kv.first)
			{
				parent->_left = newnode;
				newnode->_parent = parent;
				//父母节点更新平衡因子
				parent->_bf--;
			}
			else
			{
				parent->_right = newnode;
				newnode->_parent = parent;
				//父母节点更新平衡因子
				parent->_bf++;
			}

			
			//更新整体平衡因子
			while (parent)
			{
				if (parent->_bf == 0)
				{
					break;
				}
				else if (parent->_bf == 1 || parent->_bf == -1)
				{
					cur = parent;
					//继续向上更新
					parent = parent->_parent;
					if (parent)
					{
						if (parent->_left == cur)
						{
							parent->_bf--;
						}
						else
						{
							parent->_bf++;
						}
					}
					
				}
				else if (parent->_bf == 2 || parent->_bf == -2)
				{
					
					if (parent->_bf == -2 && cur->_bf == -1)
					{
						//右单旋
						RotateR(parent);
					}
					else if (parent->_bf == 2 && cur->_bf == 1)
					{
						//左单旋
						RotateL(parent);
					}
					else if (parent->_bf == -2 && cur->_bf == 1)
					{
						//左右双旋
						RotateLR(parent);

					}
					else if (parent->_bf == 2 && cur->_bf == -1)
					{
						//右左双旋
						RotateRL(parent);
						
					}
					else
					{
						//不可能的情况
						assert(false);
					}
					
					break;
				}
				else
				{
					//不可能的情况
					assert(false);
				}
			}
			return true;

		}

		void InOrder()
		{
			_InOrder(_root);
		}
		bool IsbalanceTree()
		{
			return _IsbalanceTree(_root);
		}
	private:
		void RotateR(Node* parent)
		{
			//要调整的节点
			Node* sub = parent;
			//要调整的节点的左孩子
			Node* subL = parent->_left;
			//要调整的节点的左孩子的右孩子
			Node* subLR = subL->_right;

			//要调整的节点的父母
			Node* subparent = sub->_parent;

			//重新链接关系
			if (subLR)
				subLR->_parent = sub;
			sub->_left = subLR;

			sub->_parent = subL;
			subL->_right = sub;

			subL->_parent = subparent;

			if (_root == sub)
			{
				_root = subL;
			}
			else
			{
				if (subparent->_left == sub)
				{
					subparent->_left = subL;
				}
				else
				{
					subparent->_right = subL;
				}
			}

			subL->_bf = sub->_bf = 0;
		}
		void RotateL(Node* parent)
		{
			//要调整的节点
			Node* sub = parent;
			//要调整的节点的右孩子
			Node* subR = parent->_right;
			//要调整的节点的有孩子的左孩子
			Node* subRL = subR->_left;

			//要调整的节点的父母
			Node* subparent = sub->_parent;

			//重新链接关系
			if (subRL)
				subRL->_parent = sub;
			sub->_right = subRL;

			sub->_parent = subR;
			subR->_left = sub;

			subR->_parent = subparent;

			if (_root == sub)
			{
				_root = subR;
			}
			else
			{
				if (subparent->_left == sub)
				{
					subparent->_left = subR;
				}
				else
				{
					subparent->_right = subR;
				}
			}
			subR->_bf = sub->_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 == -1)
			{
				parent->_bf = 0;
				subR->_bf = 1;
				subRL->_bf = 0;
			}
			else if (bf == 1)
			{
				parent->_bf = -1;
				subRL->_bf = 0;
				subR->_bf = 0;
			}
			else if (bf == 0)
			{
				parent->_bf = 0;
				subRL->_bf = 0;
				subR->_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 == -1)
			{
				parent->_bf = 1;
				subL->_bf = 0;
				subLR->_bf = 0;
			}
			else if (bf == 1)
			{
				parent->_bf = 0;
				subLR->_bf = 0;
				subL->_bf = -1;
			}
			else if (bf == 0)
			{
				parent->_bf = 0;
				subLR->_bf = 0;
				subL->_bf = 0;
			}
			else
			{
				assert(false);
			}
		}

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

		int Hegiht(Node* root)
		{
			if (root == nullptr)
			{
				return 0;
			}

			return Hegiht(root->_left) > Hegiht(root->_right) ? Hegiht(root->_left) + 1 : Hegiht(root->_right) + 1;
		}
		bool _IsbalanceTree(Node* root)
		{
			if (root == nullptr)
			{
				return true;
			}

			int leftHeight = Hegiht(root->_left);
			int rightHeight = Hegiht(root->_right);

			if ((rightHeight - leftHeight) != root->_bf)
			{
				cout << root->_kv.first << "现在bf是:" << root->_bf <<" ";
				cout << "应该是:" << (rightHeight - leftHeight) << endl;
				return false;
			}

			return abs(rightHeight - leftHeight) < 2
				&& _IsbalanceTree(root->_left)
				&& _IsbalanceTree(root->_right);
		}
		
	private:
		Node* _root;
	};


	void Test_AVLTree1()
	{
		AVLTree<int, int> tree;
		tree.Insert(make_pair(5, 5));
		tree.Insert(make_pair(3, 3));
		tree.Insert(make_pair(8, 8));
		tree.Insert(make_pair(4, 4));
		tree.Insert(make_pair(6, 6));
		tree.Insert(make_pair(2, 2));
		tree.Insert(make_pair(7, 7));

		tree.InOrder();
		cout << tree.IsbalanceTree();

	}
	void Test_AVLTree2()
	{
		AVLTree<int, int> t;
		//int a[] = {5,4,3,2,1,0};
		//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(make_pair(e, e));
			cout << "Insert" << e << ":" << t.IsbalanceTree() << endl;
		}
		t.InOrder();
		cout << t.IsbalanceTree() << endl;
	}

}
(unstoppable)
关注
专栏目录
C语言的C++数据结构进阶课程
03-30
在"C语言的C++数据结构进阶课程"中，学员将深入学习这两种编程语言的核心概念，特别是关于数据结构的部分。传智播客作为知名的IT培训机构，以其深入浅出的教学方式著称，使得复杂的编程概念变得易于理解。在这个课程...
二叉查找树完整C++代码
12-05
C++实现二叉查找树时，通常会定义一个结构体或类来表示树的节点，包括键值、左右子节点的指针。例如： ```cpp struct TreeNode { int key; TreeNode* left; TreeNode* right; }; ``` 在C++中，二叉查找树的基本...
基于C++模板实现的数据结构代码（C++）
08-20
AVL树 （AVLTree） 二叉排序树(BSTree) 哈夫曼树（Huffman） 循环队列（LoopQueue） 链队列（LinkQueue） 大顶堆（MaxHeap） 小顶堆（MinHeap） 含完整的工程文件。运行环境：vs2010 适用人群：学习不同技术...
数据结构-C++实现.zip
06-17
下面将逐一介绍这些基础和进阶数据结构及其C++实现的关键点： 1. **数组**：是最基本的数据结构，提供了通过索引访问元素的能力。在C++中，可以使用`std::array`或原始的动态数组（如`int* arr = new int[n]`）来...
C++面试问题.zip
01-20
- 树结构：二叉树、AVL树、红黑树等高级数据结构的原理和操作。 - 图论：图的基本概念，如邻接矩阵和邻接表，以及Dijkstra、Floyd等算法。 8. **操作系统**： - 进程与线程：理解进程间的通信机制和线程同步的...
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1124
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
qq_74190237的博客
09-13 289
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++_map_set详解
2302_77644537的博客
09-16 857
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
【C++11 —— 异常】
jokr_的博客
09-17 856
实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。在软件开发中，尤其是复杂系统的开发中，使用自定义异常体系可以帮助团队规范化异常管理。通过定义一套继承体系，所有抛出的异常都是特定基类的派生类，这样外层调用者可以通过捕获基类来处理所有相关的异常。使用自定义异常可以提供更具体的错误信息，使得代码的可读性和可维护性得到提升。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 595
继续学习头文件的数学函数。
C++ 中 vector 的常用功能介绍
2202_75569688的博客
09-12 439
在 C++ 中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是 C++ 标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了。
CCF201903_1
m0_67663419的博客
09-14 219
【代码】CCF201903_1。
C++入门基础
2301_76564849的博客
09-12 896
•定义命名空间，需要使⽤到namespace关键字，后⾯跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。//命名空间里可以定义变量/函数/类型int Add(int x, int y)//整数相加的函数struct Node//定义一个结构体int val;//其中::叫做域作用限定符•namespace本质是定义出⼀个域，这个域跟全局域各⾃独⽴，不同的域可以定义同名变量，所以上。
在typescript浏览器端中调用C++编写的函数，WebAssembly传递指针类型的参数，以及处理指针类型的返回值。
Xeon_CC的博客
09-17 300
最后是返回一个C++结构体指针，在TypeScript中通过DataView来获取内存中的地址偏移量来取得结构体中的数据，因为em++编译器是以32位来编译.cpp文件的，所以指针占4个字节。DataResult结构体第一个属性dArr是一个指针，那么就是地址偏移量0，然后以32位无符号整型取得dArr指针，通过这个指针去读取wasm中memoryBuffer中的数据，就可以得到dArr属性对应的值了。同理，通过地址偏移量+4来得到propCount属性，以32位整数读取数据即可。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 456
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
C++笔记---模板进阶
2302_80372340的博客
09-13 915
【优点】1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生2. 增强了代码的灵活性【缺陷】1. 模板会导致代码膨胀问题，也会导致编译时间变长2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++·io流
atlanteep的博客
09-11 1043
本节内容简单，主要讲述了3种io流的用法
C语言：刷题日志(1)
zm3rttqs9f的博客
09-07 1524
阶乘计算升级版 然后是几点 求整数段和 爬动的蠕虫 龟兔赛跑
C++核心编程和桌面应用开发 第四天（构造/析构函数）
最新发布
m0_53349772的博客
09-17 92
函数名（const 函数名 &）①用已创建好的对象初始化新对象。②值传递的方式给函数参数传值。③以值的方式，返回局部对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值