算法与数据结构全阶班-左程云版（二）基础阶段之1.复杂度、对数器、二分法和异或运算

已于 2022-02-26 11:05:17 修改
阅读量914 收藏 1
点赞数
分类专栏： 算法与数据结构全阶班-左程云版 文章标签： 算法与数据结构全阶班-左程云版 基础班 复杂度、对数器、二分法和异或
于 2022-02-18 11:55:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CUFEECR/article/details/122992782
版权

文章目录

引言

本文主要介绍了数据结构与算法的基本概念，包括算法评价指标、复杂度、对数器、二分法和异或运算。

1.概述

评价算法优劣的核心指标

  • 时间复杂度（流程决定）
  • 额外空间复杂度（流程决定）
  • 常数项时间（实现细节决定）

常见的常数时间的操作：

  • 常见的算术运算(+、-、*、/、%等)

  • 常见的位运算（>>、>>>、<<、|、&、^等)

  • 赋值、比较、自增、自减操作等

  • 数组寻址操作

总之，执行时间固定的操作都是常数时间的操作。
反之，执行时间不固定的操作，都不是常数时间的操作。

时间复杂度就是计算常数操作了多少次。

如何确定算法流程的总操作数量与样本数量之间的表达式关系：

  1. 想象该算法流程所处理的数据状况，要按照最差情况来。
  2. 把整个流程彻底拆分为一个个基本动作,保证每个动作都是常数时间的操作。
  3. 如果数据量为N,看看基本动作的数量和N是什么关系。

2.复杂度

如何确定算法流程的时间复杂度：

当完成了表达式的建立，只要把最高阶项留下即可。低阶项都去掉，高阶项的系数也去掉。

记为：O(忽略掉系数的高阶项)

例如下图：

complexity

显然后者的时间复杂度更低。

时间复杂度的意义在于:
当我们要处理的样本量很大很大时，我们会发现低阶项是什么不是最重要的;每一项的系数是什么，不是最重要的。真正重要的就是最高阶项是什么。
这就是时间复杂度的意义．它是衡量算法流程的复杂程度的一种指标，该指标只与数据量有关，与过程之外的优化无关。

三种基本排序：

选择排序：

package complexity01;

import java.util.Arrays;

/**
 * @author Corley
 * @date 2021/10/3 19:26
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class SelectionSort {

    public static void selectionSort(int[] arr) {
        if (null == arr || arr.length < 2) {
            return;
        }
        int minIndex;
        for (int i = 0; i < arr.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = arr[minIndex] < arr[j] ? minIndex : j;
            }
            swap(arr, i, minIndex);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 5, 1, 4, 9, 0, 7, 12, 5, 7, 3};
        System.out.println(Arrays.toString(arr));
        selectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

冒泡排序：

package complexity01;

import java.util.Arrays;

/**
 * @author Corley
 * @date 2021/10/3 19:41
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        if (null == arr || arr.length < 2) {
            return;
        }
        
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 5, 1, 4, 9, 0, 7, 12, 5, 7, 3};
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

这两种排序算法的效果不会受到数据的初始状态的影响。

插入排序：

package complexity01;

import java.util.Arrays;

/**
 * @author Corley
 * @date 2021/10/3 20:10
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class InsertionSort {

    public static void insertionSort(int[] arr) {
        if (null == arr || arr.length < 2) {
            return;
        }

        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 5, 1, 4, 9, 0, 7, 12, 5, 7, 3};
        System.out.println(Arrays.toString(arr));
        insertionSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

插入排序的效果会受到数据的初始状态的影响，例如数组已经是有序的情况下。

额外空间复杂度：
你要实现一个算法流程，在实现算法流程的过程中，你需要开辟一些空间来支持你的算法流程。
作为输入参数的空间，不算额外空间；
作为输出结果的空间，也不算额外空间。
因为这些都是必要的、和现实目标有关的，所以都不算。
但除此之外，你的流程如果还需要开辟空间才能让你的流程继续下去。这部分空间就是额外空间。如果你的流程只需要开辟有限几个变量，额外空间复杂度就是O(1)。

算法流程的常数项的比拼方式：
放弃理论分析，生成随机数据直接测。为什么不去理论分析?
不是不能纯分析．而是没必要。因为不同常数时间的操作，虽然都是固定时间，但还是有快慢之分的。
比如，位运算的常数时间原小于算术运算的常数时间，这两个运算的常数时间又远小于数组寻址的时间。
所以如果纯理论分析，往往会需要非常多的分析过程。都已经到了具体细节的程度．莫不如交给实验数据好了。

常见的时间复杂度(我们陆续都会见到的)：
排名从好到差:

O(1)
O(logN)
O(N)
O(N*logN)
O(N^2) O(N^3) … O(N^K)
O(2^N) O(3^N)… O(K^N)
O(N!)

算法和数据结构学习的大脉络：
1)知道怎么算的算法
2)知道怎么试的算法

3.对数器

对数器：

1，你想要测的方法a
2，实现复杂度不好但是容易实现的方法b，实现一个随机样本产生器
4，把方法a和方法b跑相同的随机样本，跑多次，看看得到的结果是否一样
5，如果有一个随机样本使得比对结果不一致，打印样本进行人工干预，改对方法a和方法b
6，当样本数量很多时比对测试依然正确，可以确定方法a已经正确。

4.二分法

二分法：

只要构建出能够排除另外一端的逻辑，就可以使用二分，而不一定需要保证数组有序。

应用：

1)在一个有序数组中，找某个数是否存在

package complexity01;

/**
 * @author Corley
 * @date 2021/10/4 9:03
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BinarySearchExist {

    public static boolean exist(int[] arr, int num) {
        if (null == arr || 0 == arr.length) {
            return false;
        }
        int L = 0, R = arr.length - 1;
        int mid;
        while (L < R) {
            mid = L + ((R - L) >> 1);
            if (arr[mid] == num) {
                return true;
            } else if (arr[mid] < num) {
                L = mid + 1;
            } else {
                R = mid - 1;
            }
        }
        return arr[L] == num;
    }

    public static void main(String[] args) {
        int[] arr = {0, 2, 5, 5, 6, 7, 7, 7, 9, 12};
        System.out.println(exist(arr, 5));
        System.out.println(exist(arr, 8));
        System.out.println(exist(arr, 9));
    }
}

2)在一个有序数组中，找>=某个数最左侧的位置

package complexity01;

/**
 * @author Corley
 * @date 2021/10/4 9:20
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BinarySearchNearLeft {

    public static int nearestIndex(int[] arr, int num) {
        int index = -1;
        if (null == arr || 0 == arr.length) {
            return index;
        }
        int L = 0, R = arr.length - 1;
        int mid;
        while (L <= R) {
            mid = L + ((R - L) >> 1);
            if (arr[mid] >= num) {
                index = mid;
                R = mid - 1;
            } else {
                L = mid + 1;
            }
        }
        return index;
    }

    public static void main(String[] args) {
        int[] arr = {0, 2, 5, 5, 6, 7, 7, 7, 9, 12};
        System.out.println(nearestIndex(arr, 5));
        System.out.println(nearestIndex(arr, 8));
        System.out.println(nearestIndex(arr, 9));
    }
}

3)在一个有序数组中，找<=某个数最右侧的位置

package complexity01;

/**
 * @author Corley
 * @date 2021/10/4 9:30
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BinarySearchNearRight {

    public static int nearestIndex(int[] arr, int num) {
        int index = -1;
        if (null == arr || 0 == arr.length) {
            return index;
        }
        int L = 0, R = arr.length - 1;
        int mid;
        while (L <= R) {
            mid = L + ((R - L) >> 1);
            if (arr[mid] <= num) {
                index = mid;
                L = mid + 1;
            } else {
                R = mid - 1;
            }
        }
        return index;
    }

    public static void main(String[] args) {
        int[] arr = {0, 2, 5, 5, 6, 7, 7, 7, 9, 12};
        System.out.println(nearestIndex(arr, 5));
        System.out.println(nearestIndex(arr, 8));
        System.out.println(nearestIndex(arr, 9));
    }
}

4)局部最小值问题

一个无序数组，任意两个相邻元素都不相等，找到一个局部最小值。

package complexity01;

/**
 * @author Corley
 * @date 2021/10/4 9:45
 * @description LeetCodeAlgorithmZuo-complexity01
 */
public class BinarySearchLocalMin {

    public static int getLessIndex(int[] arr) {
        if (null == arr || 0 == arr.length) {
            return -1;
        }
        if (1 == arr.length || arr[0] < arr[1]) {
            return 0;
        }
        if (arr[arr.length - 1] < arr[arr.length - 2]) {
            return arr.length - 1;
        }
        int left = 1, right = arr.length - 2;
        int mid;
        while (left < right) {
            mid = left + ((right - left) >> 1);
            if (arr[mid - 1] < arr[mid]) {
                right = mid - 1;
            } else if (arr[mid + 1] < arr[mid]) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return left;
    }

    public static void main(String[] args) {
        System.out.println(getLessIndex(new int[]{0, 2, 5, 5, 6, 7, 7, 7, 9, 12}));
        System.out.println(getLessIndex(new int[]{8, 2, 5, 7, 6, 4, 7, 2, 3, 4}));
        System.out.println(getLessIndex(new int[]{7, 2, 8, 5, 6, 9, 7, 3, 9, 0}));
    }
}

5.异或运算

认识异或运算

异或运算:相同为0，不同为1
同或运算:相同以1，不同为0
能长时间记住的概率接近0%
所以，异或运算就记成无进位相加!

xor

异或运算的性质
1)0^N==N
N^N == 0
2)异或运算满足交换律和结合率

xor attribute

上面的两个性质用无进位相加来理解就非常的容易

如何不用额外变量交换两个数

xor exchange

可以进行这种操作的前提是变量属于不同的对象，即指向不同的内存，否则对象的数值会被置为0，但是允许两个对象的值相等。

一个数组中有一个数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这一个数。

num time odd

代码：

public static void getOneOddTimes(int[] arr) {
    int eor = 0;
    for (int i = 0; i < arr.length; i++) {
        eor ^= arr[i];
    }
    System.out.println(eor);
}

怎么把一个int类型的数，提取出最右侧的1

方法：N & ((~N) + 1)

num 1 right

一个数组中有两个数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这两个数。

number odd 2

如下：

/*
一个数组中有两个数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这两个数。
 */
public static void getTwoOddTimes(int[] arr) {
    int eor1 = 0;
    for (int j : arr) {
        eor1 ^= j;
    }
    // 提取最右边的1
    int rightOne = eor1 & (~eor1 + 1);

    int eor2 = 0;
    for (int j : arr) {
        if ((j & rightOne) != 0) {
            eor2 ^= j;
        }
    }
    int num1 = eor2, num2 = eor1 ^ eor2;
    System.out.println(num1 + " " + num2);
}

public static void main(String[] args) {
    int[] arr = {1, 2, 2, 4, 6, 6, 6, 6, 6, 4, 4, 4, 7, 7, 6, 7, 8, 8};
    getTwoOddTimes(arr);
}

给定一个数，计算这个数的二进制形式中1的个数。

public static int bit1Count(int num) {
    int count = 0;
    int rightOne;
    while (num != 0) {
        rightOne = num & (~num + 1);
        count++;
        num ^= rightOne;
    }
    return count;
}

public static void main(String[] args) {
    // int[] arr = {1, 2, 2, 4, 6, 6, 6, 6, 6, 4, 4, 4, 7, 7, 6, 7, 8, 8};
    // getTwoOddTimes(arr);
    System.out.println(Integer.toBinaryString(12345));
    System.out.println(bit1Count(12345));
}

总结

左神极力推荐的对数器是检验算法实现正确性的有力工具，可以覆盖几乎所有情况的测试用例，无死角实现对算法的验证。同时异或也是可以在算法实现中加快运算效率的技巧。

AI码东道主
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
php数据结构与算法(PHP描述) 查找与二分法查找
12-19
在IT领域，数据结构与算法是编程基础的重要组成部分，它们直接影响到程序的效率和性能。在PHP编程中，数据结构通常涉及如何组织和存储数据，而算法则关注解决问题的步骤和逻辑。本篇将深入讨论两种查找算法：顺序...
算法与数据结构全阶班-左程云版（二）基础阶段之2.链表、栈、队列、递归行为、哈希表和有序表
CUFEECR的博客
02-18 662
本文主要介绍了常用的数据结构：链表分为单链表和双向链表，可以实现反转单链表和双链表和删除给定值；栈数据先进后出，队列数据先进先出，队列和栈既可以使用双端队列实现，也可以使用数组实现，数组实现栈较简单，实现队列需要使用循环数组，可以实现返回栈中最小元素的栈，并且为常数时间复杂度，还可以用两个队列实现栈，或者用两个栈实现队列；递归的思想是将一个大的任务分解成小的任务，最后经过整合得到整个问题的解，可以使用Master公式计算出递归的时间复杂度；哈希表时间复杂度为O(1)，有序表时间复杂度为O(logN)。
算法与数据结构全阶班-左程云版（二）基础阶段之4.堆和比较器
CUFEECR的博客
02-23 484
本文主要介绍了堆和比较器：堆结构就是用数组实现的完全二叉树结构，每棵子树的最大值都在顶部是大根堆，每棵子树的最小值都在顶部是小根堆，有heapInsert与heapify操作，时间复杂度分别为O(N*logN)和O(N)，堆排序实现了O(N*LogN)的时间复杂度，同时空间复杂度O(1)，优先队列的底层就是堆；比较器的实质是重载比较运算符，可以很好的应用在特殊标准的排序上，也可以应用在特殊标准排序的结构上，手写堆结构，因为增加了对象的位置表，所以能够满足动态改信息的需求，可以自己实现堆和对应的比较器。
算法与数据结构全阶班-左程云版（二）基础阶段之3.归并排序和快速排序
CUFEECR的博客
02-21 1158
本文介绍了2种排序方式：归并排序，思路是整体为递归，左边排好序+右边排好序+ merge让整体有序，也可以用非递归实现，时间复杂度为O(N*logN)，额外空间复杂度为O(N)，相比于冒泡排序、选择排序和插入排序O(N2)的时间复杂度，归并排序的时间复杂度优化了很多，这是因为减少了比较次数，有很多应用，例如求小和、逆序对等，只要数组中左边的数比右边的数满足某个条件即可进行操作；快速排序有3种方式，普通分区算法，荷兰国旗算法，随机选数与最后一个数交换，再利用荷兰国旗算法，时间复杂度为O(N*logN)。
算法与数据结构全阶班-左程云版系列目录
CUFEECR的博客
02-17 2175
左程云俗称左神，是一个刷题7年的算法爱好者，也是马士兵教育的算法授课老师。2014年起专职做程序员算法和数据结构培训、代码面试培训、刷题交流等相关工作，是《程序员代码面试指南–IT名企算法与数据结构题目最优解》的作者。《算法与数据结构全阶班》包括5个系列，分别是算法和数据结构新手班、算法与数据结构基础班、算法数据结构体系学习班、算法与数据结构进阶班和大厂算法和数据结构刷题班，本系列汇总了全阶班的全部题目和解答，同时还穿插了算法与数据结构的笔试和面试技巧，用最通俗易懂的语言争取让每个人都能轻松学懂算法。
左神算法与数据结构全阶课上笔记(2)——随机数的原理与扩展应用(C++实现)
qq_36467101的博客
01-22 729
左神算法与数据结构全阶课上笔记(2)——随机数的原理与扩展应用(C++实现)，包含随机函数的概率变化、经典随机函数笔试题：等概率随机函数区域改变和不等概率改为等概率。
数据结构实训报告-二分查找学生管理实训报告(常用版).doc
12-01
通过本次实训，学生将能够巩固和掌握程序设计基础和数据结构课程的基本知识和技能，掌握算法分析和程序设计的一般方法，并具备熟练的数组和线性表知识、程序编写和调试的基本能力，以及文字表达和报告撰写能力。...
算法与数据结构C语言习题参考答案6-9章.pdf
03-28
在算法与数据结构的学习中，C语言是一种常用的编程语言，用于实现各种算法和数据结构。本文件中的内容主要涉及6-9章的习题解答，包括改进的二分法检索算法和确定二叉排序树中指定节点所在层次的算法。 首先，我们来...
算法数据结构学习视频教程，算法和数据结构的基础概念、进阶技巧以及特定算法的应用和实现
最新发布
03-26
第1节 算法和数据结构路线、注意点与常见问题.mp4 第2节 认识复杂度、对数器、二分法.mp4 第3节 异或运算相关面试题.mp4 第4节 一些基础的数据结构.mp4 第5节 归并排序及其相关面试题.mp4 第6节 归并排序附加题、...
计算机二分法的算法步骤-五大常用算法之一：分治算法，算法数据结构 五大常用算法
04-07
计算机二分法的算法步骤-五大常用算法之一：分治算法，算法数据结构 五大常用算法 分治算法是一种常用的算法设计方法，它将一个规模为n的问题P分解成k个规模较小的子问题，这些子问题相互独立，并且与原来的问题...
左程云著算法与数据结构题目最优解笔记-位运算
liuhaiyang210的博客
04-16 1363
位运算位运算是把数字用二进制表示之后，对每一位上的0或者1的运算。理解位运算的第一步是理解二进制。二进制是指数字每一位都是0或者1，如十进制的2转换为二进制之后是10，而十进制的10转换为二进制之后是1010。在程序员圈子里有一个流传了很久的笑话，说世界上有10种人，一种人知道二进制，另一种人不知道二进制。 下面是几个常见的关于位运算的算法题：基本位运算位运算总共只有5种运算：与&，或|，异或^，左
数据结构与算法（LeetCode高频300题 Python3实现）
算法探索之路
12-12 4601
文章目录1、课程：Introduction2、课程：数组和动态数组3、课程：递归4、课程：搜索与排序5、课程：二分搜索6、课程：分治法（上）7、课程：分治法（下）8、课程：链表（上）9、课程：链表（下）10、课程：堆栈和队列（上）11、课程：堆栈和队列（下）12、课程：哈希表（上）13、课程：哈希表（下）14、课程：树（上）15、课程：树（下）16、课程：堆（上）17、课程：堆（下）18、课程：图...
数据结构与算法JC班-左程云第一节课笔记（认识复杂度、对数器、二分法与异或运算）
DiPingXianhorizon的博客
03-12 1143
数据结构与算法基础班-左程云第一节课笔记（认识复杂度、对数器、二分法与异或运算）
左程云算法笔记总结-基础篇
m0_63323097的博客
04-02 1721
O 即 O(f(n))常数操作的数量写出来，不要低阶项，只要最高项，并且不要最高项的系数除了储存题目条件外的空间占用，如果只用固定数量的储存空间就能解决问题，不随N变化，那就是常数级O(1)相同为0，不同为1，也可以理解为无进位相加。两数交换的另一种写法，但实际上这种方式没一般方法快，而且如果两个数的内存地址一样，会把他们抹成0
左程云 算法与数据结构基础班
asdfadafd的博客
04-26 751
排序优化 在C++的STL中为我们提供了很多排序函数如sort、stable_sort等等，平时我们也会直接使用这些现成的排序函数，为了让我们更加深层的了解底层的排序函数，现在我们从如何实现一个通用的、高性能的排序函数这个问题出发，进而更加全面的理解排序算法。 https://pan.baidu.com/s/1izhWFEqCNhi2LK3MApk6ng?pwd=n4xy 线性排序算法的时间复杂度比较低，适用场景比较特殊。所以如果要写一个通用的排序函数，不能选择线性排序算法。如果对于小规模数据进行
对数器
大鱼物联
07-03 608
牛客网左神算法初级课里提到一个非常有用的东西——对数器对数器可以说是验证算法是否正确的一种方式。尤其是在笔试的时候，用贪心算法写出的程序，暂时无法用数学公式严格推导证明，只能通过大量的数据集验证算法的正确性。而大量的数据集当中要包括各种情况，各个方面都要考虑到，对我们自己来说，有时会考虑不周，而且又是在时间紧迫的情况下，对数器就派上了用场。对数器的概念   对数器的基本概念如下有一个你想测试的算法...
左神算法进阶班4_1画出楼的轮廓
weixin_34072458的博客
06-22 324
【题目】 给定一个N行3列二维数组，每一行表示有一座大楼，一共有N座大楼。 所有大楼的底部都坐落在X轴上，每一行的三个值(a, b, c)代表每座大楼的从(a, 0)点开始，到(b, 0)点结束，高度为c。 输入的数据可以保证 a < b, 且a，b，c均为正数。大楼之间可以有重合。 请输出整体的轮廓线。 例子：给定一个二维数组[[1, 3, 3], [2, 4, 4], [5, 6...
对数器都不准备那笔试什么的就凉透了！要打有准备的仗
Blog by Haris Ha
11-13 546
本文由左程云老师讲授个人整理总结 Js实现排序对数器对数器什么是对数器对数器的使用对数器编写测试结果对数器完整代码（测试插入排序为例） 对数器 在没法OJ，或OJ也有毛病的时候，我们的算法可能大致是正确的，能简单的通过几个样例，但遇到复杂庞大的样例时抛锚，我们对着冗长的代码，去调试，用人工写样例的方式去测试是愚蠢的，这时候我们需要对数器出场了 什么是对数器 对数器是通过用大量测试数据来验证算法...
对数器的使用
sdr_zd的博客
02-27 3613
听左神算法课的时候学到了一个非常有用的东西——对数器 对数器是用来测试代码正确性的，我们在找不到合适的oj系统测试自己的代码时，可以自己写一个对数器对代码进行测试 设计对数器的一般步骤为： 1.有一个你要测的方法a； 2.实现一个绝对正确即使复杂度不好的方法b； 3.实现一个随机样本产生器； 4.实现比对的方法； 5.把方法a和方法b比对很多次来验证方法a是否正确 6.如果有一个样...
全国计算机二级VB公共基础知识最新(常用版).doc
12-02
总之，全国计算机二级VB公共基础知识最新(常用版).doc是一份关于计算机二级VB公共基础知识的学习资料，重点涉及算法复杂度、数据结构的概念、栈、二叉树的遍历、二分法查找和冒泡排序等内容。读者应该重点学习算法的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

AI码东道主

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

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

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

打赏作者

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

抵扣说明：

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

余额充值