leecode-C语言实现-4. 寻找两个正序数组的中位数

已于 2022-03-03 09:28:35 修改
阅读量656 收藏
点赞数 3
分类专栏： # leecode练习-c语言实现 文章标签： leetcode c语言 c算法 算法 开发语言
于 2022-03-02 15:36:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45111959/article/details/123229970
版权

一、题目
在这里插入图片描述
在这里插入图片描述
二、解题思路
（1）思路一
由于两个数组是有序的，所以可以用插入排序或qsort方法进行数组排序合并，排完序之后，如果元素总个数n为奇数，中位数为第（n-1）/2+1个元素（不是索引位）。如果元素总个数n为偶数，中位数为第n/2+1个和第n/2个的和除以二，再根据中位数的位置在排好序的数组中遍历找出。
此思路没有用代码进行实现，由于此思路的算法复杂度为O(n^2),并且需要重新定义一个长度为m+n的数组，占用的内存会比较多。

（2）思路二
先找出中位数的位置，如果元素总个数n为奇数，中位数为第（n-1）/2+1个元素（不是索引位）。如果元素总个数n为偶数，中位数为第n/2+1个和第n/2个的和除以二。我们其实不需要用额外的数组来记录元素，只需要按照情况来划分，建议看到下面提供的代码，再对着思路二一起看，对理解有帮助。

这里需要用到一些变量来协助
int flg;
1表示元素个数为偶数
0表示元素个数为奇数

int cnt;
记录遍历了多少个元素

int ResIndex[2];
记录中位数的位置，不是记录索引号

int NumExsits(int num, int *arr)
判断num是否在数组arr中，在的话返回索引位，不在返回-1

int tmp = -1;
将NumExsits的结果赋予tmp

int twoflg = 0;
表示中位数已经取几个

情况一：两个数组同时遍历，得到了中位数：

1、数组A中的元素a大于数组B中的元素a，是否到中位数记录的位置，在的话，再判断总元素个数是奇数，直接返回中位数，如果是偶数，表示中位数是两个数的和，再判断twoflg为几，如果为1，表示之前已经取了一个，将此元素加到结果中并返回。如果为0，将此元素加到结果中继续循环。

2、数组A中的元素a小于数组B中的元素a，逻辑同上。

3、数组A中的元素a等于数组B中的元素a，是否到中位数记录的位置，在的话，再判断总元素个数是奇数，直接返回中位数，如果是偶数，表示中位数是两个数的和，再判断twoflg为几，如果为1，且结果值中为0，表示这两个元素为所求的中位数。如果res结果不为0，表示之前已经存储了一个元素，最多存储两个元素，所以直接把元素加到结果中返回。再者就是结果值为0，但中位数需要两个数才能确认的情况，把元素加到结果中继续循环。

情况二：两个数组同时遍历，没有得到中位数：
这种情况表示其中一个数组已经完全遍历完毕，只需遍历其中一个数组即可，我这里两个都写是因为其中有一个循环必然不会进入，这样不用多加判断，代码简洁一些。

1、元素个数为奇数，中位数为一个的时候，上面的情况没有过滤到元素，在数组中遍历，遍历到直接返回结果。

2、元素个数为偶数，中位数为两个的时候，上面的情况没有过滤到元素，在数组中遍历，遍历到两次，直接将结果相加再除以二返回结果即可。

3、元素个数为偶数，中位数为两个的时候，上面的情况过滤到一个元素，在数组中遍历，遍历到一次，直接将结果相加再除以二返回结果即可。

三、虚机测试代码

#include <stdio.h>
#include <stdlib.h>

void main()
{
    void PrintfArr(void *arr, int size ,int elementsize);
    double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size);

    //int nums1[] = {1,2,4,5,6};
    //int nums2[] = {3,5,6,7,8,9,10,11,12,13};
    //int nums2[] = {3,5,6,7,8,9,10,11,12,13,14,15};
    //int nums2[] = {3,5,6,7,8,9,10,11,12,13,14,15,16};

    int nums1[] = {2,2,4,4};
    int nums2[] = {2,2,4,4};
    int nums1Size = sizeof(nums1) / sizeof(int);
    int nums2Size = sizeof(nums2) / sizeof(int);

    PrintfArr(nums1, nums1Size ,sizeof(int));
    PrintfArr(nums2, nums2Size ,sizeof(int));
    findMedianSortedArrays(nums1,  nums1Size, nums2, nums2Size);
}

double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size)
{
    void PrintfArr(void *arr, int size ,int elementsize);
    int NumExsits(int num, int *arr);
    int ResIndex[2];
    int flg;

    if((nums1Size + nums2Size) % 2 == 0)
    {
        ResIndex[0] = (nums1Size + nums2Size) / 2;
        ResIndex[1] = (nums1Size + nums2Size) / 2 + 1;
        flg = 1;
    }
    else
    {
        ResIndex[0] = ((nums1Size + nums2Size) - 1) / 2 + 1;
        ResIndex[1] = -1;    
        flg = 0;
    }
    PrintfArr(ResIndex,2,sizeof(int));

    int x,y,cnt;
    double res = 0;
    int tmp = -1;
    int twoflg = 0;
    for(x=0,y=0,cnt=0; x<nums1Size && y<nums2Size;)
    {
        cnt++;
        if(nums1[x] < nums2[y] && x<nums1Size && y<nums2Size)
        {
            tmp = NumExsits(cnt, ResIndex);
            printf("cnt : %d, tmp : %2d, flg : %d, nums1[%d] : %d, nums2[%d] : %d, twoflg : %d\n",cnt,tmp,flg,x,nums1[x],y,nums2[y],twoflg);
            printf("nums1[x] < nums2[y]\n");
            if(tmp != -1)
            {
                if(!flg)
                {
                    res = res + nums1[x];
                    printf("res : %f\n",res);
                    return res;
                }
                else if(twoflg == 1)
                {
                    res = (res + nums1[x]) / 2;
                    printf("res : %f\n",res);
                    return res;
                }
                else
                {   
                    res = res + nums1[x];
                    printf("res : %f\n",res);
                    twoflg++;
                }
            }
            x++;
        }
        else if(nums1[x] > nums2[y] && x<nums1Size && y<nums2Size)
        {
            tmp = NumExsits(cnt, ResIndex);
            printf("cnt : %d, tmp : %2d, flg : %d, nums1[%d] : %d, nums2[%d] : %d, twoflg : %d\n",cnt,tmp,flg,x,nums1[x],y,nums2[y],twoflg);
            printf("nums1[x] > nums2[y]\n");   
            if(tmp != -1)
            {   
                if(!flg)
                {
                    res = res + nums2[y];
                    printf("res : %f\n",res);
                    return res;   
                }
                else if(twoflg == 1)
                {   
                    res = (res + nums2[y]) / 2;
                    printf("res : %f\n",res);
                    return res;
                }
                else
                {
                    res = res + nums2[y];
                    printf("res : %f\n",res);
                    twoflg++;
                }
            }
            y++;
        }
        else if(nums1[x] == nums2[y] && x<nums1Size && y<nums2Size)
        {
            tmp = NumExsits(cnt, ResIndex);
            if(tmp > -1)
            {
                twoflg++;
            }
            cnt++;
            tmp = NumExsits(cnt, ResIndex);
            if(tmp > -1)
            {
                twoflg++;
            }
            printf("cnt : %d, tmp : %2d, flg : %d, nums1[%d] : %d, nums2[%d] : %d, twoflg : %d\n",cnt,tmp,flg,x,nums1[x],y,nums2[y],twoflg);
            printf("nums1[x] == nums2[y]\n");   
            if(twoflg > 0)
            {   
                if(flg == 0)
                {
                    res = res + nums1[x];
                    printf("res : %f\n",res);
                    return res;   
                }
                else if(flg && twoflg == 2 && res == 0)
                {   
                    res = (res + nums1[x] + nums2[y]) / 2;
                    printf("res : %f\n",res);
                    return res;
                }
                else if(res != 0)
                {
                    res = (res + nums1[x]) / 2;
                    printf("res : %f\n",res);    
                    return res;
                }
                else
                {
                    res = res + nums1[x];
                    printf("res : %f\n",res);
                }
            }
            x++;
            y++;
            if(twoflg == 2)
            {
                twoflg = 0;
            }
        }
        printf("++++++++++++++++++++\n");
    }

    for(; x<nums1Size; x++)
    {
        cnt++;
        tmp = NumExsits(cnt, ResIndex);
        if(tmp > -1 && !flg)
        {
            res = res + nums1[x];
            printf("res : %f\n",res);
            return res;
        }
        else if(tmp > -1 && flg && twoflg == 1)
        {
            res = (res + nums1[x]) / 2;
            printf("res : %f\n",res);
            return res;
        }
        else if(tmp > -1 && flg && twoflg == 0)
        {
            res = res + nums1[x];
            printf("res : %f\n",res);
            twoflg++;
        }        
    }
    for(; y<nums2Size; y++)
    {
        cnt++;
        tmp = NumExsits(cnt, ResIndex);
        if(tmp > -1 && !flg)
        {   
            res = res + nums2[y];
            printf("res : %f\n",res);
            return res;
        }
        else if(tmp > -1 && flg && twoflg == 1)
        {   
            res = (res + nums2[y]) / 2;
            printf("res : %f\n",res);
            return res;
        }
        else if(tmp > -1 && flg && twoflg == 0)
        {   
            res = res + nums2[y];
            printf("res : %f\n",res);
            twoflg++;
        }    
    }
}

int NumExsits(int num, int *arr)
{
    int i;
    for(i=0; i<2; i++)
    {
        if(arr[i] == num)
        {
            return i;
        }
    }
    return -1;
}

void PrintfArr(void *arr, int size ,int elementsize)
{
    if(elementsize == sizeof(int))
    {
        int *tmparr = (int*)arr;
        int i;
        for(i=0; i<size; i++)
        {
            printf("%d ",tmparr[i]);
        }
    }
    else if(elementsize == sizeof(char))
    {
        char *tmparr = (char*)arr;
        int i;
        for(i=0; i<size; i++)
        {
            printf("%c ",tmparr[i]);
        }
    }
    printf("\n");
}

四、虚机测试截图

在这里插入图片描述

五、leecode提交代码

double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size)
{
    //void printfArr(void *arr, int size ,int elementsize);
    int NumExsits(int num, int *arr);
    int ResIndex[2];
    int flg;

    if((nums1Size + nums2Size) % 2 == 0)
    {
        ResIndex[0] = (nums1Size + nums2Size) / 2;
        ResIndex[1] = (nums1Size + nums2Size) / 2 + 1;
        flg = 1;
    }
    else
    {
        ResIndex[0] = ((nums1Size + nums2Size) - 1) / 2 + 1;
        ResIndex[1] = -1;    
        flg = 0;
    }
    //printfArr(ResIndex,2,sizeof(int));

    int x,y,cnt;
    double res = 0;
    int tmp = -1;
    int twoflg = 0;
    for(x=0,y=0,cnt=0; x<nums1Size && y<nums2Size;)
    {
        cnt++;
        if(nums1[x] < nums2[y] && x<nums1Size && y<nums2Size)
        {
            tmp = NumExsits(cnt, ResIndex);
            //printf("cnt : %d, tmp : %2d, flg : %d, nums1[%d] : %d, nums2[%d] : %d, twoflg : %d\n",cnt,tmp,flg,x,nums1[x],y,nums2[y],twoflg);
            //printf("nums1[x] < nums2[y]\n");
            if(tmp != -1)
            {
                if(!flg)
                {
                    res = res + nums1[x];
                    //printf("res : %f\n",res);
                    return res;
                }
                else if(twoflg == 1)
                {
                    res = (res + nums1[x]) / 2;
                    //printf("res : %f\n",res);
                    return res;
                }
                else
                {   
                    res = res + nums1[x];
                    //printf("res : %f\n",res);
                    twoflg++;
                }
            }
            x++;
        }
        else if(nums1[x] > nums2[y] && x<nums1Size && y<nums2Size)
        {
            tmp = NumExsits(cnt, ResIndex);
            //printf("cnt : %d, tmp : %2d, flg : %d, nums1[%d] : %d, nums2[%d] : %d, twoflg : %d\n",cnt,tmp,flg,x,nums1[x],y,nums2[y],twoflg);
            //printf("nums1[x] > nums2[y]\n");   
            if(tmp != -1)
            {   
                if(!flg)
                {
                    res = res + nums2[y];
                    //printf("res : %f\n",res);
                    return res;   
                }
                else if(twoflg == 1)
                {   
                    res = (res + nums2[y]) / 2;
                    //printf("res : %f\n",res);
                    return res;
                }
                else
                {
                    res = res + nums2[y];
                    //printf("res : %f\n",res);
                    twoflg++;
                }
            }
            y++;
        }
        else if(nums1[x] == nums2[y] && x<nums1Size && y<nums2Size)
        {
            tmp = NumExsits(cnt, ResIndex);
            if(tmp > -1)
            {
                twoflg++;
            }
            cnt++;
            tmp = NumExsits(cnt, ResIndex);
            if(tmp > -1)
            {
                twoflg++;
            }
            //printf("cnt : %d, tmp : %2d, flg : %d, nums1[%d] : %d, nums2[%d] : %d, twoflg : %d\n",cnt,tmp,flg,x,nums1[x],y,nums2[y],twoflg);
            //printf("nums1[x] == nums2[y]\n");   
            if(twoflg > 0)
            {   
                if(flg == 0)
                {
                    res = res + nums1[x];
                    //printf("res : %f\n",res);
                    return res;   
                }
                else if(flg && twoflg == 2 && res == 0)
                {   
                    res = (res + nums1[x] + nums2[y]) / 2;
                    //printf("res : %f\n",res);
                    return res;
                }
                else if(res != 0)
                {
                    res = (res + nums1[x]) / 2;
                    //printf("res : %f\n",res);    
                    return res;
                }
                else
                {
                    res = res + nums1[x];
                    //printf("res : %f\n",res);
                }
            }
            x++;
            y++;
            if(twoflg == 2)
            {
                twoflg = 0;
            }
        }
        //printf("++++++++++++++++++++\n");
    }

    for(; x<nums1Size; x++)
    {
        cnt++;
        tmp = NumExsits(cnt, ResIndex);
        if(tmp > -1 && !flg)
        {
            res = res + nums1[x];
            //printf("res : %f\n",res);
            return res;
        }
        else if(tmp > -1 && flg && twoflg == 1)
        {
            res = (res + nums1[x]) / 2;
            //printf("res : %f\n",res);
            return res;
        }
        else if(tmp > -1 && flg && twoflg == 0)
        {
            res = res + nums1[x];
            //printf("res : %f\n",res);
			twoflg++;
        }        
    }
    for(; y<nums2Size; y++)
    {
        cnt++;
        tmp = NumExsits(cnt, ResIndex);
        if(tmp > -1 && !flg)
        {   
            res = res + nums2[y];
            //printf("res : %f\n",res);
            return res;
        }
        else if(tmp > -1 && flg && twoflg == 1)
        {   
            res = (res + nums2[y]) / 2;
            //printf("res : %f\n",res);
            return res;
        }
        else if(tmp > -1 && flg && twoflg == 0)
        {   
            res = res + nums2[y];
            //printf("res : %f\n",res);
			twoflg++;
        }    
    }
	return -1;
}

int NumExsits(int num, int *arr)
{
    int i;
    for(i=0; i<2; i++)
    {
        if(arr[i] == num)
        {
            return i;
        }
    }
    return -1;
}

六、leecode代码提交截图
在这里插入图片描述

阳光九叶草LXGZXJ
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言-C语言编程基础之leetcode题解第4题寻找两个正序数组的中位数.zip
04-09
在本压缩包文件中，我们聚焦于C语言编程的基础知识，特别是通过解决LeetCode上的第四题——寻找两个正序数组的中位数。这是一道经典的算法问题，它要求我们理解数组的操作，以及如何在复杂的数据结构中找到关键的...
c语言基础-c语言编程基础之数组操作示例-两个数组的交集.zip
最新发布
03-17
本教程将深入探讨C语言中的数组操作，特别是如何找出两个数组的交集。首先，让我们理解数组的基本概念。 数组是由相同类型的数据元素构成的集合，这些元素在内存中是连续存储的。每个元素都有一个唯一的索引，从0...
寻找两个正序数组的中位数c语言
Wzq66623335的博客
05-29 405
给定两个大小分别为m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的中位数。 关键点有： 1：使用2个指针来索引两个数组： num1Index、num2Index 2：找到数组的中间值为1/2的值 和 1/2 -1位置处的值： middleValue1、middleValue1 3：根据数组的长度之后，来计算中值为1/2处值，还是1/2和1/2-1处的值和除以2： 数组长度：nums1Size+nums2Size 数组长度%2==1，则数...
寻找两个正序数组的中位数
candtao的博客
09-19 176
力扣-寻找两个正序数组的中位数
寻找两个正序数组的中位数c语言,leetcode-4. 寻找两个正序数组的中位数，
weixin_34766991的博客
05-23 370
leetcode-4. 寻找两个正序数组的中位数，leetcode-4. 寻找两个正序数组的中位数。给定两个大小为 m 和 n 的正序(从小到大)数组nums1 和nums2。请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为O(log(m + n))。你可以假设nums1和nums2不会同时为空。示例 1:nums1 = [1, 3]nums2 = [2]则中位数是 2.0...
二分法——寻找两个正序数组的中位数
weixin_44859096的博客
05-04 1101
二分法——寻找两个正序数组的中位数 二分法又称折半查找，应用于有序数组查找，时间复杂度为log(n) 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，
4. 寻找两个正序数组的中位数
chenchenchenchenying的博客
10-12 116
给定两个大小分别为m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的中位数。 class Solution { public double findMedianSortedArrays(int[] nums1, int[] nums2) { int len1 = nums1.length; int len2 = nums2.length; double res = 0; int i=0,j=0; List...
C语言数组-C语言实现使用静态数组实现循环队列.zip
03-02
在本主题中，我们将深入探讨如何使用C语言中的静态数组来实现一个循环队列。循环队列是一种线性数据结构，它巧妙地利用了数组的特性，克服了普通队列在满时无法插入元素、空时无法删除元素的问题。 首先，了解数组...
商业源码-编程源码-C语言课程设计案例精编.zip
06-14
3. **数组与字符串处理**：C语言中的数组和字符串处理是重要的知识点，案例可能包括动态数组、多维数组、字符数组（字符串）的操作，如字符串比较、复制、反转等。 4. **文件操作**：在课程设计中，文件输入输出是...
中国科技大学-C语言讲义7ppt课件.ppt
11-20
`，定义了两个字符型数组str1和str2，分别包含10个和20个元素。 数组的大小 数组的大小必须是整型常量表达式，不可以是变量或变量表达式。例如： * `int n = 10; int a[n];`，这是错误的，因为数组的大小不能是...
算法练习贴--70--寻找两个正序数组的中位数(C语言)
Inmaturity_7的博客
06-30 988
寻找两个正序数组的中位数(C语言) 一、题目描述 给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。 （题目来源：力扣（LeetCode）） 示例 1： 输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2 示例 2： 输入：nums1 = [1,2], nums2 = [3,4] 输出：2.50000 解释：合并数组 = [1,2,3,4] ，中位数
004. 寻找两个正序数组的中位数
qq_51517771的博客
05-01 185
题目链接源 题目 给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。 请你找出并返回这两个正序数组的 中位数 。 算法的时间复杂度应该为 O(log (m+n)) 。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 解题思路 求第一个数组和第二个数组的长度， 用length1和lengt
中位数
weixin_30652491的博客
04-04 533
1 /*中位数 2 时间限制：3000 ms | 内存限制：65535 KB 3 难度：2 4 描述 5 一组数据按从小到大的顺序依次排列，处在中间位置的一个数叫做中位数。 6 7 比如 1 5 10 11 9 其中位数就是9.因为排序过后，9处在中间位置。 8 9 现在给你一些数，请你求出其中位数。 10 11 输入 12 第一行输入一个整...
C语言中如何获取数组的中位数
我点评的博客
08-14 2792
在C语言编程中，获取数组的中位数是一项常见而重要的任务。中位数是一个数组中的一个特殊值，它将该数组分为两个等长的部分。因此，在编程开发中，了解如何获取数组的中位数是非常有帮助的。然后，根据数组长度的奇偶性，确定中位数的位置，并从排序后的数组中获取中位数的值。对数组进行排序：首先，我们需要对给定的数组进行排序，以便能够准确地找到中位数。确定中位数的位置：然后，我们需要确定中位数的位置。当数组长度为偶数时，中位数的位置为 (数组长度 / 2) 和 (数组长度 / 2 + 1)。// 获取中位数的值。
Leetcode_4 寻找两个正序数组的中位数 C语言
仅进行技术交流，不代写代码及其他
04-09 407
题目描述： 示例： 输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2 输入：nums1 = [2], nums2 = [] 输出：2.00000 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters 解题思路：      &n
寻找两个正序数组的中位数（C语言）
a_ha_____的博客
11-14 1884
题目： 给定两个大小分别为 m 和 n 的正序（从小到大）数组nums1 和nums2。请你找出并返回这两个正序数组的 中位数 。 算法的时间复杂度应该为 O(log (m+n)) 。 示例 1： 输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2 示例 2： 输入：nums1 = [1,2], nums2 = [3,4] 输出：2.50000 解释：合并数组 = [1,2,...
LeeCode4：求两个有序数组的中位数
qq_43406565的博客
03-23 131
求两个有序数组的第k个数，要求时间复杂度是O(log(m+n))
【LeetCode】求中位数（数据流、滑动窗口、两个正序数组）
热门推荐
像写诗一样优雅地写代码~
01-20 1万+
文章目录数据流中的中位数★★★滑动窗口中位数★★★寻找两个正序数组的中位数★★★ 数据流中的中位数★★★ LeetCode 剑指 Offer 41. 数据流中的中位数 【题目】如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。 例如， [2,3,4] 的中位数是 3 [2,3] 的中位数是 (2 + 3) / 2 = 2.5 设计一个支持以下两种操作的数据结构： vo
"中国科技大学-C语言讲义.ppt：一维、二维数组的定义和引用
二维数组的定义方式为"数据类型 数组名[行数][列数]"，通过两个下标可以唯一确定数组中的元素。讲义给出了二维数组的声明示例，并详细解释了行数、列数和下标的含义。同时讲义强调了二维数组中元素的存储类别和数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值