977.有序数组的平方（各种排序） 0.2.1

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量308 收藏
点赞数
文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42199845/article/details/122479642
版权

在这里插入图片描述

在这里插入图片描述

算法入门第二天 第一题！

977.有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

借着这题好好复习一下 各种排序

一、复习一下各种排序

1、直接插入排序

int* sortedSquares(int* a, int n, int* returnSize){
	*returnSize=n;
	if(n==0) return a;
	a[0]=a[0]*a[0];
	int j;
	for(int i=1;i<n;i++){
		int temp=a[i]*a[i];
		for(j=i-1;j>=0;j--){
			if(temp<a[j]) a[j+1]=a[j];
			else break;
		}
		a[j+1]=temp;
	}
	return a;
}

2、折半插入排序

int* sortedSquares(int* a, int n, int* returnSize){
	*returnSize=n;
	if(n==0) return a;
	a[0]=a[0]*a[0];
	int j;
	for(int i=1;i<n;i++){
		int temp=a[i]*a[i];
		int low=0,high=i-1;
		while(low<=high){
			int mid=(low+high)/2;
			if(temp>a[mid]) low=mid+1;
			else high=mi-1;
		}
		for(j=i-1;j>high;j--){
			a[j+1]=a[j];
		}
		a[j+1]=temp;
	}
	return a;
}

3、选择排序

int* sortedSquares(int* a, int n, int* returnSize){
	*returnSize=n;
	if(n==0) return a;
	int k=0;
	for(int i=0;i<n;i++){
		a[k++]=a[i]*a[i];
	} 
	for(int i=0;i<n-1;i++){
		for(int j=i+1;j<n;j++){
			if(a[j]<a[i]){
				int temp=a[i];
				a[i]=a[j];
				a[j]=temp;
			}
		}
	}
	return a;
}

4、冒泡排序

int* sortedSquares(int* a, int n, int* returnSize){
	*returnSize=n;
	if(n==0) return a;
	int k=0;
	for(int i=0;i<n;i++){
		a[k++]=a[i]*a[i];
	} 
	for(int i=0;i<n;i++){
		for(int j=0;j<n-i-1;j++){
			if(a[j+1]<a[j]){
				int temp=a[j+1];
				a[j+1]=a[j];
				a[j]=temp;
			}
		}
	}
	return a;
}

5、带判断条件的冒泡排序

int* sortedSquares(int* a, int n, int* returnSize){
	*returnSize=n;
	if(n==0) return a;
	int k=0;
	for(int i=0;i<n;i++){
		a[k++]=a[i]*a[i];
	} 
	int flag=1;
	while(n>1&&flag==1){
		flag=0;
		for(int j=0;j<n-1;j++){
			if(a[j+1]<a[j]){
				flag=1;
				int temp=a[j+1];
				a[j+1]=a[j];
				a[j]=temp;
			}
		}
	}
	return a;
}

选择排序 和冒泡排序会时间超限

6、快排

int Pattion(int *a,int low,int high){
	int temp=a[low],pivoty=a[low];
	while(low<high){
		while(a[high]>=pivoty&&low<high) high--;
		a[low]=a[high];
		while(a[low]<=pivoty&&low<high) low++;
		a[high]=a[low];
	}
	a[low]=temp;
	return low;
}
void QuickSort(int *a,int low,int high){
	int p;
	if(low<high){
		p=Pattion(a,low,high);
		QuickSort(a,low,p-1);
		QuickSort(a,p+1,high);
	}
}

int* sortedSquares(int* a, int n, int* returnSize){
	*returnSize=n;
	if(n==0) return a;
    int k=0;
	for(int i=0;i<n;i++){
		a[k++]=a[i]*a[i];
	}
	QuickSort(a,0,n-1); 
	return a;
}

这个有点猛哦 一下超过百分之七十多

7、归并排序

可能我写的问题 内存超限了

void MergeSort(int *a,int low,int mid,int high){
	

	int *b=(int *)malloc(sizeof(int)*(high+1));
	for(int i=low;i<=high;i++){
		b[i]=a[i];
	}
	int i=low,j=mid+1,temp=low;
	while(i<=mid&&j<=high){
		if(b[i]<b[j]){
			a[temp++]=b[i++];
		}
		else a[temp++]=b[j++];
	}
	while(i<=mid) a[temp++]=b[i++];
	while(j<=high) a[temp++]=b[j++];

}
void Merge(int *a,int low,int high){
	int mid;
	if(low==high)return ;
	else{
		mid=(low+high)/2;
		Merge(a,low,mid);
		Merge(a,mid+1,high);
		MergeSort(a,low,mid,high);
		

	}

} 
int* sortedSquares(int* a, int n, int* returnSize){
	*returnSize=n;
	if(n==0) return a;
    int k=0;
	for(int i=0;i<n;i++){
		a[k++]=a[i]*a[i];
	}
	Merge(a,0,n-1); 
	return a;
}

8、双指针

int* sortedSquares(int* a, int n, int* returnSize){
	*returnSize=n;
	if(n==0) return a;
	int p=0,q=-1;
	for(int i=0;i<n;i++){
		if(a[i]>=0) {
			p=i;
			q=i-1;
			break;
		}
	} 
	int k=0;
	int *res=(int *)malloc(sizeof(int)*n);
	while(p<n&&q>=0){
		if(a[p]*a[p]<a[q]*a[q]){
			res[k++]=a[p]*a[p];
			p++;
		}
		else{
			res[k++]=a[q]*a[q];
			q--;
		} 
	} 
	while(p<n) {
		res[k++]=a[p]*a[p];
		p++;
	}
	while(q>=0){
		res[k++]=a[q]*a[q];
		q--;
	}
	return res;

力扣官方给出：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        int negative = -1;
        for (int i = 0; i < n; ++i) {
            if (nums[i] < 0) {
                negative = i;
            } else {
                break;
            }
        }

        vector<int> ans;
        int i = negative, j = negative + 1;
        while (i >= 0 || j < n) {
            if (i < 0) {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
            else if (j == n) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else if (nums[i] * nums[i] < nums[j] * nums[j]) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
        }

        return ans;
    }
};

以上来自力扣977题的评论区大佬，转载仅供本人学习使用。

双指针风骚起来，也是无敌

二、代码随想录讲解

第二部分全部来自代码随想录的讲解，转载仅供学习使用，在此附上网站网址：https://programmercarl.com/other/kstar.html

力扣题目链接

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

思路

暴力排序

最直观的想法，莫过于：每个数平方之后，排个序，美滋滋，代码如下：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        for (int i = 0; i < A.size(); i++) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序
        return A;
    }
};

这个时间复杂度是 O ( n + n log ⁡ n ) O(n + n\log n) O(n+nlogn)， 可以说是 O ( n log ⁡ n ) O(n\log n) O(nlogn)的时间复杂度，但为了和下面双指针法算法时间复杂度有鲜明对比，我记为 O ( n + n log ⁡ n ) O(n + n\log n) O(n+nlogn)。

双指针法

数组其实是有序的， 只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法了，i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

如动画所示：

不难写出如下代码：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};

此时的时间复杂度为 O ( n ) O(n) O(n)，相对于暴力排序的解法 O ( n + n log ⁡ n ) O(n + n\log n) O(n+nlogn)还是提升不少的。

这里还是说一下，大家不必太在意leetcode上执行用时，打败多少多少用户，这个就是一个玩具，非常不准确。

做题的时候自己能分析出来时间复杂度就可以了，至于leetcode上执行用时，大概看一下就行，只要达到最优的时间复杂度就可以了，

一样的代码多提交几次可能就击败百分之百了…

其他语言版本

Java：
class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                result[index--] = nums[left] * nums[left];
                ++left;
            } else {
                result[index--] = nums[right] * nums[right];
                --right;
            }
        }
        return result;
    }
}

class Solution {
    public int[] sortedSquares(int[] nums) {
        int l = 0;
        int r = nums.length - 1;
        int[] res = new int[nums.length];
        int j = nums.length - 1;
        while(l <= r){
            if(nums[l] * nums[l] > nums[r] * nums[r]){
                res[j--] = nums[l] * nums[l++];
            }else{
                res[j--] = nums[r] * nums[r--];
            }
        }
        return res;
    }
}
Python：
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        n = len(nums)
        i,j,k = 0,n - 1,n - 1
        ans = [-1] * n
        while i <= j:
            lm = nums[i] ** 2
            rm = nums[j] ** 2
            if lm > rm:
                ans[k] = lm
                i += 1
            else:
                ans[k] = rm
                j -= 1
            k -= 1
        return ans

Go：

func sortedSquares(nums []int) []int {
	n := len(nums)
	i, j, k := 0, n-1, n-1
	ans := make([]int, n)
	for i <= j {
		lm, rm := nums[i]*nums[i], nums[j]*nums[j]
		if lm > rm {
			ans[k] = lm
			i++
		} else {
			ans[k] = rm
			j--
		}
		k--
	}
	return ans
}

Rust

impl Solution {
    pub fn sorted_squares(nums: Vec<i32>) -> Vec<i32> {
        let n = nums.len();
        let (mut i,mut j,mut k) = (0,n - 1,n- 1);
        let mut ans = vec![0;n];
        while i <= j{
            if nums[i] * nums[i] < nums[j] * nums[j] {
                ans[k] = nums[j] * nums[j];
                j -= 1;
            }else{
                ans[k] = nums[i] * nums[i];
                i += 1;
            }
            k -= 1;
        }
        ans
    }
}

Javascript：

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function(nums) {
    let n = nums.length;
    let res = new Array(n).fill(0);
    let i = 0, j = n - 1, k = n - 1;
    while (i <= j) {
        let left = nums[i] * nums[i],
            right = nums[j] * nums[j];
        if (left < right) {
            res[k--] = right;
            j--;
        } else {
            res[k--] = left;
            i++;
        }
    }
    return res;
};
Typescript：

双指针法：

function sortedSquares(nums: number[]): number[] {
    let left: number = 0, right: number = nums.length - 1;
    let resArr: number[] = new Array(nums.length);
    let resArrIndex: number = resArr.length - 1;
    while (left <= right) {
        if (Math.abs(nums[left]) < Math.abs(nums[right])) {
            resArr[resArrIndex] = nums[right--] ** 2;
        } else {
            resArr[resArrIndex] = nums[left++] ** 2;
        }
        resArrIndex--;
    }
    return resArr;
};

骚操作法（暴力思路）：

function sortedSquares(nums: number[]): number[] {
    return nums.map(i => i * i).sort((a, b) => a - b);
};

Swift:

func sortedSquares(_ nums: [Int]) -> [Int] {
    // 指向新数组最后一个元素
    var k = nums.count - 1
    // 指向原数组第一个元素
    var i = 0
    // 指向原数组最后一个元素
    var j = nums.count - 1
    // 初始化新数组(用-1填充)
    var result = Array<Int>(repeating: -1, count: nums.count)

    for _ in 0..<nums.count {
        if nums[i] * nums[i] < nums[j] * nums[j] {
            result[k] = nums[j] * nums[j]
            j -= 1
        } else {
            result[k] = nums[i] * nums[i]
            i += 1
        }
        k -= 1
    }

    return result
}

Ruby:

def sorted_squares(nums)
  left, right, result = 0, nums.size - 1, []
  while left <= right
    if nums[left]**2 > nums[right]**2
      result << nums[left]**2
      left += 1
    else
      result << nums[right]**2
      right -= 1
    end
  end
  result.reverse
end

C:

int* sortedSquares(int* nums, int numsSize, int* returnSize){
    //返回的数组大小就是原数组大小
    *returnSize = numsSize;
    //创建两个指针，right指向数组最后一位元素，left指向数组第一位元素
    int right = numsSize - 1;
    int left = 0;

    //最后要返回的结果数组
    int* ans = (int*)malloc(sizeof(int) * numsSize);
    int index;
    for(index = numsSize - 1; index >= 0; index--) {
        //左指针指向元素的平方
        int lSquare = nums[left] * nums[left];
        //右指针指向元素的平方
        int rSquare = nums[right] * nums[right];
        //若左指针指向元素平方比右指针指向元素平方大，将左指针指向元素平方放入结果数组。左指针右移一位
        if(lSquare > rSquare) {
            ans[index] = lSquare;
            left++;
        } 
        //若右指针指向元素平方比左指针指向元素平方大，将右指针指向元素平方放入结果数组。右指针左移一位
        else {
            ans[index] = rSquare;
            right--;
        }
    }
    //返回结果数组
    return ans;
}

PHP:

class Solution {
    /**
     * @param Integer[] $nums
     * @return Integer[]
     */
    function sortedSquares($nums) {
        // 双指针法
        $res = [];
        for ($i = 0; $i < count($nums); $i++) {
            $res[$i] = 0;
        }
        $k = count($nums) - 1;
        for ($i = 0, $j = count($nums) - 1; $i <= $j; ) {
            if ($nums[$i] ** 2 < $nums[$j] ** 2) {
                $res[$k--] = $nums[$j] ** 2;
                $j--;
            }
            else {
                $res[$k--] = $nums[$i] ** 2;
                $i++;
            }
        } 
        return $res;
    }
}

三、我的方法&官方解析

1.sort函数

直接开辟一个ans数组，存放原数组的平方值。之后利用sort函数暴力排序。

class Solution {
public:
  vector<int> sortedSquares(vector<int>& nums) {
      vector<int> ans;
      
      for(int i:nums){
          ans.push_back(i*i);
       }
       sort(ans.begin(), ans.end());
       
       return ans;
  }
};

2.官方方法：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        int negative = -1;
        for (int i = 0; i < n; ++i) {
            if (nums[i] < 0) {
                negative = i;
            } else {
                break;
            }
        }

        vector<int> ans;
        int i = negative, j = negative + 1;
        while (i >= 0 || j < n) {
            if (i < 0) {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
            else if (j == n) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else if (nums[i] * nums[i] < nums[j] * nums[j]) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
        }

        return ans;
    }

3.官方更简洁的方式

其实这种方式和代码随想录给出的方法一致！

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n);
        for (int i = 0, j = n - 1, pos = n - 1; i <= j;) {
            if (nums[i] * nums[i] > nums[j] * nums[j]) {
                ans[pos] = nums[i] * nums[i];
                ++i;
            }
            else {
                ans[pos] = nums[j] * nums[j];
                --j;
            }
            --pos;
        }
        return ans;
    }
};
     return ans;
    }
1Q84.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jquery.jqGrid.groupHeader-0.2.1.js
10-15
jqGrid没有setComplexGroupHeaders方法，使用此插件实现三级分组表头功能
pyltp-0.2.1-cp37-cp37m-win_amd64.zip
07-18
《Python环境下的pyltp-0.2.1库详解》 在Python的自然语言处理领域，pyltp是一款非常重要的工具，它是由哈工大社会计算与信息检索研究中心（SCIR）开发的Python接口，用于LTP（Language Technology Platform，语言...
数组平方排序
某猿蚊常叮的博客
12-24 277
这个问题我卡了很久，我一直想的是从中间拆分数组，但是遇到那种不对称的数组，就无法执行， 下面是别人的代码 class Solution { public int[] sortedSquares(int[] nums) { int left = 0 ; int right = nums.length-1; int[] result = new int[nums.length]; int idx = nums.length - 1;
代码随想录之有序数组平方排序
Ivan_wjt的博客
09-30 175
此文为阅读’代码随想录‘的leetcode刷题所写笔记。代码参考作者’程序员Carl‘（代码随想录） 参考链接：代码随想录 力扣题目链接 已知一个非递减数组, 要求返回该数组平方后的非递减数列. 分析 该数组的长度已知, 我们可以设置两个指针分别指向首和尾, 并向中间移动. 由于数组是有序的, 因此平方后最大的只会在两侧的其中一个, 因此可以每次在两端比较选择. 代码实现 Java class Solution{ public int[] Result(int[] nums){ ...
对数组中的元素进行平方然后排序
ldbite的博客
01-14 647
#include #include #include<math.h> #include using namespace std; class Solution { public: vectorsortedSquares(vector& A) { int tmp = 0; int len = A.size(); for (int i = 0;i < len;i++) { A...
有序数组的平方&&快速排序(记录向)
qq_39333742的博客
03-03 450
题目：给你一个按排序的整数数组nums，返回组成的新数组，要求也按排序。
java数据结构--有序数组的平方排序
weixin_45350120的博客
09-16 445
题目描述 给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。 代码说明 package hlzcc.demo; //力扣997 有序数组的平方 class Soution{ public void sortedSquares(int[] A){ int N = A.length; // 数组的长度说明 int j = 0; //首先定义指针j的位置 //找出正数和负数的分界位置
PyPI 官网下载 | collective.portlet.relateditems-0.2.1.tar.gz
02-10
《PyPI官网下载 | collective.portlet.relateditems-0.2.1.tar.gz》 在Python的世界里，PyPI（Python Package Index）是Python开发者的重要资源库，它为全球的Python项目提供了一个集中的分发平台。PyPI上的资源包...
PyPI 官网下载 | inquant.recipe.textfile-0.2.1dev-r1958.tar.gz
01-12
标题中的“PyPI 官网下载 | inquant.recipe.textfile-0.2.1dev-r1958.tar.gz”表明这是一个在Python Package Index（PyPI）上发布的软件包，名为`inquant.recipe.textfile`，版本号为`0.2.1dev-r1958`，且文件格式为...
pyltp-0.2.1-cp36-cp36m-win_amd64.whl
02-09
安装完成后，你就可以在Python环境中导入pyltp库，开始使用它的各种功能。例如，导入模型并进行分词操作： ```python from pyltp import Segmentor # 初始化分词器 segmentor = Segmentor() # 加载模型 segmentor....
有序数组的二分查找、冒泡排序案例、简单递归案例、快速排序的两种实现方法、Arrays操作数组的常用方法
罪域之骨终成王
05-27 257
二分查找、冒泡排序、递归、快排、Arrays
LeeCode 977题(java实现):有序数组的平方
qq_36798272的博客
07-01 288
杂话:         笨笨的我只想到了平方后进行排序,也了解到冒泡排序是一种低效的排序法,用jdk自带的Arrays.sort()好太多,了解到1.8版本用的是双轴排序,听着就很屌屌的感觉.最后看了其他人对此题的解法,也就是本博客贴出的解法,可以利用了双指针的方法得出此题优解. 贴码: public int[] so...
977.有序数组的平方
zhouyinuo1998的博客
10-30 125
代码 class Solution { public: vector<int> sortedSquares(vector<int>& nums) { //先平方再排序 //平方 for(int i=0;i<nums.size();++i) nums[i]=nums[i]*nums[i];//平方 /*//冒泡排序：升序，双指针 int te
有序数组的平方(力扣)（冒泡排序）
txwhmeng的博客
07-27 375
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。 示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100] 排序后，数组变为 [0,1,9,16,100] 示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121] 提示： 1 <= nums.length <= 104 -104 &.
七大排序-冒泡排序，插入排序，希尔排序（一）
的博客
07-06 957
1.先说冒泡排序，冒泡最好是直接有序，但是基本上不可能，如果数字是随机数的话，冒泡基本上都是最坏的情况，冒一趟，其中一个大的数冒到后面了，但是中间可能还有其他大的数，那么基本上就是O(N^2)了。，有n个数，将第n-1下标的数，插入到区间[0,n-2]中，这样会比较n-1次，假设每次都比较最后一次的情况是n-1次，最外层的趟数是n-1，那么时间复杂度是O(N*N)：外层循环是比较的趟数N-1次，假设j 一直等于0，内层循环就每次走N次，那么时间复杂度是O(N*N)第二次排序的消耗 (1+2+…
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 710
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 689
后缀表示法。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 281
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
select file: chunked-coding-converter.0.2.1.jar
08-22
"select file: chunked-coding-converter.0.2.1.jar" 翻译成中文的意思是“选择文件：chunked-coding-converter.0.2.1.jar”。 在计算机领域中，“选择文件”是指从多个文件中选择一个特定的文件。在给出的指令中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值