二分插值斐波那契查找算法和哈希表

最新推荐文章于 2021-05-22 13:54:23 发布
最新推荐文章于 2021-05-22 13:54:23 发布
阅读量424 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lucylala007/article/details/107999419
版权

文章目录

查找算法介绍

在java中，我们常用的查找有四种😗*

1) 顺序(线性)查找

2) 二分查找/折半查找

3) 插值查找

4) 斐波那契查找

顺序(线性)查找

​ 有一个数列： {1,8, 10, 89, 1000, 1234} ，判断数列中是否包含此名称【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值。

二分查找/折半查找

二分查找的思路分析

  1. 首先确定该数组的中间的下标

mid = (left + right) / 2

  1. 然后让需要查找的数 findVal 和 arr[mid] 比较

  2. 1 findVal > arr[mid] , 说明你要查找的数在mid 的右边, 因此需要递归的向右查找

​ 2.2 findVal < arr[mid], 说明你要查找的数在mid 的左边, 因此需要递归的向左查找

​ 2.3 findVal == arr[mid] 说明找到，就返回 。

什么时候我们需要结束递归.

  1. 找到就结束递归

  2. 递归完整个数组，仍然没有找到findVal ，也需要结束递归 当 left > right 就需要退出

	// 二分查找算法  基本写法
	/**
	 * 
	 * @param arr
	 *            数组
	 * @param left
	 *            左边的索引
	 * @param right
	 *            右边的索引
	 * @param findVal
	 *            要查找的值
	 * @return 如果找到就返回下标，如果没有找到，就返回 -1
	 */
	public static int binarySearch(int[] arr, int left, int right, int findVal) {
		
		// 当 left > right 时，说明递归整个数组，但是没有找到
		if (left > right) {
			return -1;
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > midVal) { // 向 右递归
			return binarySearch(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 向左递归
			return binarySearch(arr, left, mid - 1, findVal);
		} else {
			
			return mid;
		}

	}

	//完成一个课后思考题:
	/*
	 * 课后思考题： {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，
	 * 有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000
	 * 
	 * 思路分析
	 * 1. 在找到mid 索引值，不要马上返回
	 * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
	 * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
	 * 4. 将Arraylist返回
	 */

	public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {

		System.out.println("hello~");
		// 当 left > right 时，说明递归整个数组，但是没有找到
		if (left > right) {
			return new ArrayList<Integer>();
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];
        
		if (findVal > midVal) { // 向 右递归
			return binarySearch2(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 向左递归
			return binarySearch2(arr, left, mid - 1, findVal);
		} else {
//			 * 思路分析
//			 * 1. 在找到mid 索引值，不要马上返回
//			 * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
//			 * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
//			 * 4. 将Arraylist返回
			
			List<Integer> resIndexlist = new ArrayList<Integer>();
			//向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
			int temp = mid - 1;
			while(true) {
				if (temp < 0 || arr[temp] != findVal) {//退出
					break;
				}
				//否则，就temp 放入到 resIndexlist
				resIndexlist.add(temp);
				temp -= 1; //temp左移
			}
			resIndexlist.add(mid);  //
			
			//向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
			temp = mid + 1;
			while(true) {
				if (temp > arr.length - 1 || arr[temp] != findVal) {//退出
					break;
				}
				//否则，就temp 放入到 resIndexlist
				resIndexlist.add(temp);
				temp += 1; //temp右移
			}
			
			return resIndexlist;
		}
	}

插值查找

1)插值查找算法类似于二分查找，不同的是插值查找每次从自适应****mid处开始查找。

2)将折半查找中的求mid 索引的公式 , low 表示左边索引left, high表示右边索引right.
key 就是前面我们讲的 findVal

3)int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]) ;/插值索引/
对应前面的代码公式：
int mid = left + (right – left) * (findVal – arr[left]) / (arr[right] – arr[left])

插值查找注意事项：

1)对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找,** 速度较快**

2)关键字分布不均匀的情况下，该方法不一定比折半查找要好

	//编写插值查找算法
	//说明：插值查找算法，也要求数组是有序的
	/**
	 * 
	 * @param arr 数组
	 * @param left 左边索引
	 * @param right 右边索引
	 * @param findVal 查找值
	 * @return 如果找到，就返回对应的下标，如果没有找到，返回-1
	 */
	public static int insertValueSearch(int[] arr, int left, int right, int findVal) { 

		System.out.println("插值查找次数~~");
		
		//注意：findVal < arr[0]  和  findVal > arr[arr.length - 1] 必须需要
		//否则我们得到的 mid 可能越界
		if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
			return -1;
		}
		// 求出mid, 自适应
		int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
		int midVal = arr[mid];
		if (findVal > midVal) { // 说明应该向右边递归
			return insertValueSearch(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 说明向左递归查找
			return insertValueSearch(arr, left, mid - 1, findVal);
		} else {
			return mid;
		}
	}

斐波那契(黄金分割法)查找算法

斐波那契查找基本介绍

1)黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意向不大的效果。

2)斐波那契数列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现斐波那契数列的两个相邻数 的比例，无限接近 黄金分割值0.618

斐波那契原理

斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，即mid=low+F(k-1)-1（F代表斐波那契数列），如下图所示

对F(k-1)-1的理解：
由斐波那契数列 F[k]=F[k-1]+F[k-2] 的性质，可以得到 （F[k]-1）=（F[k-1]-1）+（F[k-2]-1）+1 。该式说明：只要顺序表的长度为F[k]-1，则可以将该表分成长度为F[k-1]-1和F[k-2]-1的两段，即如上图所示。从而中间位置为mid=low+F(k-1)-1

类似的，每一子段也可以用相同的方式分割
但顺序表长度n不一定刚好等于F[k]-1，所以需要将原来的顺序表长度n增加至F[k]-1。这里的k值只要能使得F[k]-1恰好大于或等于n即可，由以下代码得到,顺序表长度增加后，新增的位置（从n+1到F[k]-1位置），都赋为n位置的值即可。

哈希表

哈希表基本介绍

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
在这里插入图片描述

哈希表(散列)-Google上机题

有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,名字,住址…),当输入该员工的id时,要求查找到该员工的 所有信息.

要求:
不使用数据库,速度越快越好=>哈希表(散列)
添加时，保证按照id从低到高插入 [课后思考：如果id不是从低到高插入，但要求各条链表仍是从低到高，怎么解决?]
使用链表来实现哈希表, 该链表不带表头[即: 链表的第一个结点就存放雇员信息]
思路分析并画出示意图
代码实现[增删改查(显示所有员工，按id查询)]
在这里插入图片描述

package com.atguigu.hashtab;

import java.util.Scanner;

public class HashTabDemo {

	public static void main(String[] args) {
		
		//创建哈希表
		HashTab hashTab = new HashTab(7);
		
		//写一个简单的菜单
		String key = "";
		Scanner scanner = new Scanner(System.in);
		while(true) {
			System.out.println("add:  添加雇员");
			System.out.println("list: 显示雇员");
			System.out.println("find: 查找雇员");
			System.out.println("dele: 删除雇员");
			System.out.println("exit: 退出系统");
			
			key = scanner.next();
			switch (key) {
			case "add":
				System.out.println("输入id");
				int id = scanner.nextInt();
				System.out.println("输入名字");
				String name = scanner.next();
				//创建 雇员
				Emp emp = new Emp(id, name);
				hashTab.add(emp);
				break;
			case "list":
				hashTab.list();
				break;
			case "find":
				System.out.println("请输入要查找的id");
				id = scanner.nextInt();
				hashTab.findEmpById(id);
				break;
			case "dele":
				System.out.println("请输入要删除的id");
				id = scanner.nextInt();
				hashTab.delEmpById(id);
				break;
			case "exit":
				scanner.close();
				System.exit(0);
			default:
				break;
			}
		}		
	}
}
//创建HashTab 管理多条链表
class HashTab {
	private EmpLinkedList[] empLinkedListArray;
	private int size; //表示有多少条链表
	
	//构造器
	public HashTab(int size) {
		this.size = size;
		//初始化empLinkedListArray
		empLinkedListArray = new EmpLinkedList[size];
		//？留一个坑, 这时不要忘了分别初始化每个链表，
		// 因为此时才初始化好数组  并没有对数组中每个链表初始化 所以每个链表都是null，因此添加数据就会报空指针异常错误
		for(int i = 0; i < size; i++) {
			empLinkedListArray[i] = new EmpLinkedList();
		}
	}	
	//添加雇员
	public void add(Emp emp) {
		//根据员工的id ,得到该员工应当添加到哪条链表
		int empLinkedListNO = hashFun(emp.id);
		//将emp 添加到对应的链表中
		empLinkedListArray[empLinkedListNO].add(emp);		
	}
	//遍历所有的链表,遍历hashtab
	public void list() {
		for(int i = 0; i < size; i++) {
			empLinkedListArray[i].list(i);
		}
	}	
	//根据输入的id,查找雇员
	public void findEmpById(int id) {
		//使用散列函数确定到哪条链表查找
		int empLinkedListNO = hashFun(id);
		Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
		if(emp != null) {//找到
			System.out.printf("在第%d条链表中找到 雇员 id = %d\n", (empLinkedListNO + 1), id);
		}else{
			System.out.println("在哈希表中，没有找到该雇员~");
		}
	}	
	//编写散列函数, 使用一个简单取模法
	public int hashFun(int id) {
		return id % size;
	}
	public void delEmpById(int id){
		int empLinkedListNo = hashFun(id);
		empLinkedListArray[empLinkedListNo].delEmpById(id);
	}	
}
//表示一个雇员
class Emp {
	public int id;
	public String name;
	public Emp next; //next 默认为 null
	public Emp(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
}
//创建EmpLinkedList ,表示链表
class EmpLinkedList {
	//头指针，执行第一个Emp,因此我们这个链表的head 是直接指向第一个Emp
	private Emp head; //默认null
	
	//添加雇员到链表
	//说明
	//1. 假定，当添加雇员时，id 是自增长，即id的分配总是从小到大
	//   因此我们将该雇员直接加入到本链表的最后即可
	public void add(Emp emp) {
		//如果是添加第一个雇员
		if(head == null) {
			head = emp;
			return;
		}
		//如果不是第一个雇员，则使用一个辅助的指针，帮助定位到最后
		Emp curEmp = head;
		while(true) {
			if(curEmp.next == null) {//说明到链表最后
				break;
			}
			curEmp = curEmp.next; //后移
		}
		//退出时直接将emp 加入链表
		curEmp.next = emp;
	}	
	//遍历链表的雇员信息
	public void list(int no) {
		if(head == null) { //说明链表为空
			System.out.println("第 "+(no+1)+" 链表为空");
			return;
		}
		System.out.print("第 "+(no+1)+" 链表的信息为");
		Emp curEmp = head; //辅助指针
		while(true) {
			System.out.printf(" => id=%d name=%s\t", curEmp.id, curEmp.name);
			if(curEmp.next == null) {//说明curEmp已经是最后结点
				break;
			}
			curEmp = curEmp.next; //后移，遍历
		}
		System.out.println();
	}
	
	//根据id查找雇员
	//如果查找到，就返回Emp, 如果没有找到，就返回null
	public Emp findEmpById(int id) {
		//判断链表是否为空
		if(head == null) {
			System.out.println("链表为空");
			return null;
		}
		//辅助指针
		Emp curEmp = head;
		while(true) {
			if(curEmp.id == id) {//找到
				break;//这时curEmp就指向要查找的雇员
			}
			//退出
			if(curEmp.next == null) {//说明遍历当前链表没有找到该雇员
				curEmp = null;
				break;
			}
			curEmp = curEmp.next;//以后
		}
		
		return curEmp;
	}
	public void delEmpById(int id){
		Emp curEmp = new Emp(0,"");
		curEmp.next = head;
		boolean flag = false;
		while(true){
			//这里要判定链表是否为空  因为有可能删除的是链表中的第一个
			//如果不判空 这里结束不了循环 就会报空指针异常
			if(head == null){
				break;
			}
			//这里删除一个链表中第一个节点和后面删除情况要分开写
			if(head.id == id){
				head = null;
				break;
			}
			if(curEmp.next.id == id){
				flag = true;
				break;
			}
			curEmp = curEmp.next;
		}
		if(flag){
			curEmp.next = curEmp.next.next;
		}else{
			System.out.println("要找的雇员不存在");
		}
	}	
}

oo于野
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单查找算法（线性、二分、插值）
Ronz 的博客
01-15 509
文章目录一、查找算法介绍二、顺序查找2.1 什么是顺序查找2.2 顺序查找的代码实现三、二分查找3.1 什么是二分查找3.2 二分查找的基本步骤3.3 二分查找的代码实现四、插值查找4.1 什么是插值查找4.2 插值查找与二分查找的区别4.2 插值查找的基本步骤4.3 插值查找的代码实现 一、查找算法介绍 在 java 中，我们常用的查找算法有以下四种： 顺序（线性）查找 二分（折半）查找 插值查找 斐波那契查找 本文将分别介绍顺序查找、二分查找、插值查找；如要访问斐波那契查找算法的文章请点击链接：斐波
【数据结构与算法】（Java）二分法查找，插值查找，斐波那契查找，哈希表应用场景：员工信息管理在内存中
m0_52586550的博客
05-23 221
查找算法 有序表查找 二分法查找 package dataStructure; import java.util.ArrayList; import java.util.List; public class BinarySearch { public static void main(String[] args) { int[] arr = {20,70,80,110,121,134}; int index = binarySearch1(arr,134); System.out.prin
二分查找算法（加法方式：斐波那契查找）
weixin_34347651的博客
05-30 285
二分查找算法比较熟悉的是折半查找，但是折半查找中计算mid时，有加法和除法。下面介绍仅有加法方式的二分查找算法 核心思想利用斐波那契表达式来实现加法方式的折半查找 技巧点:1)将数组中数的个数(f(n)-1)分成 f(n-1) -1和 f(n-2)2):f(n) - 1 = (f(n-1)-1 )+ (f(n-2)-1) 在数组中因为要用到一个mid数(中间位置的数)故总共要减掉1,故上述表...
数据结构之查找
xiaotai1234的博客
10-02 299
数据结构之查找 一、概述 二、线性查找算法 package com.atguigu.search; public class SeqSearch { public static void main(String[] args) { int arr[] = { 1, 9, 11, -1, 34, 89 };// 没有顺序的数组 int index = seqSearch(arr, -11); if(index == -1) { System.out.println("没有找到到")
斐波那契查找算法
weixin_43646100的博客
06-14 476
斐波那契查找算法 斐波那契查找与二分查找差不多，区别在于 二分查找的mid 使用除法算出来，而斐波那契查找的mid是用加减法算出来的，计算机对于 加减法的处理速度快于除法，尤其是在大数据量以及单个数值很大时尤其明显。 待排数组元素个数一定要是斐波那契数，如果不是我们就强行加长数组，多的空间用原待排数组的最后一个元素填充。 /* 使用fibonacci查找算法的目的： Fibonacci查找算法其实本质上就是二分查找算法 只不过二分查找算法求mid时,用的是除
二分查找算法，插值查找，斐波那契查找
Dichotomy_的博客
02-12 294
文章目录二分查找插值查找斐波那契查找 二分查找 原理：给定一个有序的数组，每次从中间开始查找，判断查找的val与中间值的比较，大于继续向后查找，小于向前查找。 步骤： 得到一个有序的数组。 计算中间索引，mid = （left + right）/ 2 与待查找的值进行比较，相等返回mid。 不相等，向左或向右重复2，3步。 JAVA代码实现： /** * 二分查找 * * @pa...
php实现的二分查找算法示例
12-19
4. **其他查找算法**：除了二分查找，还有哈希查找、线性查找、插值查找、斐波那契查找等多种查找算法，每种算法都有其适用的场景和优缺点。 理解并熟练掌握二分查找算法，有助于提升编程能力，特别是在处理大量...
常用查找算法（顺序、二分、插值、分块、斐波那契）
热门推荐
CoderHqf的博客
05-17 1万+
常用查找算法（顺序、二分、插值、分块、斐波那契）顺序查找基本思想代码实现分块查找基本思想二分查找基本思想代码实现插值查找基本思想代码实现斐波那契查找基本思想代码实现总结 顺序查找 基本思想 属于线性查找和无序查找，从一端开始顺序扫描，直到找到与目标值value相等的元素。 这是最基本的查找方法，也是时间复杂度最高的查找算法。 在数据过多时，这种方法并不适用。 代码实现 //第一种:顺序查找 public Type SequenceSearch(Type[] list,Type t) {
hash表的平均查找长度C语言,关于ASL(平均查找长度)的简单总结
weixin_32644565的博客
05-22 4647
ASL(Average Search Length)，即平均查找长度，在查找运算中，由于所费时间在关键字的比较上，所以把平均需要和待查找值比较的关键字次数成为平均查找长度。它的定义是这样的：其中n为查找表中元素个数，Pi为查找第i个元素的概率，通常假设每个元素查找概率相同，Pi=1/n，Ci是找到第i个元素的比较次数。当然，有查找成功，就有查找不成功，即要查找元素不在查找表中。针对不同查找方式的查...
查找算法总结---（附代码）
10-14
- 斐波那契查找也是对二分查找的改进，利用斐波那契数列的性质来确定分割点，理论上比插值查找更优，但实际应用中不如二分查找常见。 5. **树表查找**： - 树表查找通常指的是基于二叉搜索树或其他类型的查找树的...
二分查找之斐波那契查找
lfz_sau的博客
07-16 1016
1、什么是Fibonacci数列？       斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、····，在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）。 2、什么是Fibonacci查找？      Fibonacci
查找算法 -- 线性、二分、插值、斐波那契
JeremyIverson的博客
02-22 256
1.1 查找算法介绍 在 java 中，我们常用的查找有四种: 顺序(线性)查找 二分查找/折半查找 插值查找 斐波那契查找 1.2 线性查找算法 有一个数列： {1,8, 10, 89, 1000, 1234} ，判断数列中是否包含某个指定的数。 要求: 如果找到了，就提示找到，并给出下标值。 代码实现 public class SeqSearch { public static vo...
二分查找 插值查找
晨识草的博客
12-13 873
二分查找mid, min, max, 每次将target(即要查找的数)与中间位置进行比较,如果刚好等于直接找到,如果大于,往中间位置的右边找,如果小于,往中间位置的左边找 递归// attention: the array must be sort // 查找之前数组已经排好顺序 #include <iostream> #include <vector> using namespace std
查找算法(二分查找，插值查找，斐波那契查找)
RoySummy的博客
09-29 140
目录二分查找思路代码插值查找思路代码斐波那契查找(黄金分割法查找)思路代码 二分查找 思路 首先确定该数组中间的下标。 mid = (left + right) / 2 然后让需要查找的数 findVal 和 arr[mid] 进行比较， 如果findVal > arr[mid]，说明要查找的数在mid的右边，递归向右； 如果findVal < arr[mid]，说明要查找的数在mid的左边，递归向左； 如果findVal == arr[mid]，返回下标。 结束条件 left > ri
斐波那契数列和二分查找的算法（递归与非递归）
清城无雪的博客
11-27 446
#include using namespace std; long long fibonacci1(size_t n)//非递归算法 { long long* fiboarry = new long long[n + 1]; fiboarry[0] = 0; fiboarry[1] = 1; for (size_t i = 2; i { fiboarry[i] = fibo
二分查找和插值查找
weixin_42066314的博客
12-28 559
一、概述 在一堆数据里面找出自己需要的元素，这种需求可以说是最基础的需求之一，任何程序都会有所涉及。如果程序的查找算法设计的很精妙，那么整个程序的性能就会有显著的提升。今天就来分享两种常用的查找算法。 二、算法复杂度分析 关于查找最容易想到的一种实现方式就是将一组数据中的每个元素逐个取出来和目标值比较，如果取出来的元素和目标值相同那就说明找到了，这种查找算法叫做顺序查找法，其复杂度为O(N)。二分查找就是：在一组数据中取出中间的那个元素，将其和要找的元素对比，如果不是要找的元素，则以其为标记点，将这组
二分查找+插值查找
weixin_44899726的博客
07-26 149
二分查找 package com.atguigu.search; import java.util.ArrayList; import java.util.List; public class BinarySearch { public static void main(String[] args) { int arr[] = { 1, 8, 10, 89,1000,1000, 1234 }; //int arr[] = { 1, 2, 3, 4, 5, 6, 7
插值算法（二分查找兄弟算法）
theLuckyLong的博客
08-10 376
设想一下这个情景：有这样一个数组arr[]={1,2,3,4,5,6,7},如果要查找边界值1的话，利用二分查找的效率，似乎不是那么的高，原因在于，二分查找每次定位都是在数组中间，不够灵活，如果有一种算法，可以根据要查找的值，自适应定位，那么效率显然就快很多，因而就有了插值算法，它的公式为： location = left + k × L 其中，left代表数组最左边的下标，L是right - left，即数组最右下标与最左下标的差值，k是比例系数： k = (key - arr[left])/(arr[r
递归折半查找算法详解：有序表查找与查找表分类
章节内容还涉及动态查找表，如二叉排序树、平衡二叉树（如AVL树和红黑树）、B-树和B+树，以及散列表（哈希表）的查找，它们各自具有不同的特点和适用场景。在查找表上，平均查找长度（ASL）是评估算法性能的重要指标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值