Java 一些简单的编程思想和算法 韩顺平跟学

最新推荐文章于 2024-08-11 16:01:20 发布
最新推荐文章于 2024-08-11 16:01:20 发布
阅读量216 收藏 1
点赞数
分类专栏： 韩顺平java跟学 数据结构与算法 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_38316216/article/details/127815178
版权

Java一些简单的编程思想和算法

方法递归调用

方法递归调用

斐波那契

逆向思维

package com.exrecursion;

import org.junit.Test;

/**
 * 递归:斐波那契
 *
 * @author wty
 * @date 2022/11/11 23:51
 */
public class RecursionEx {
    @Test
    public void recursionEx() throws Exception {
        int i = fibonacci(0);
        System.out.println(i);
    }
    public int fibonacci(int n) throws Exception {
        //1.请使用递归的方式求出斐波那契数1,1 ,2,3,5,8,13...给你一个整数n,求出它的值是多

        /** 序号 和
         *  1    1
         *  2    1
         *  3    2
         *  4    3
         *  5    5
         *  6    8
         *  7    13
         *
         */
        if (n <= 0){
            throw new Exception("输入的数据有误");
        }
        if (n== 1 || n == 2){
            return 1;
        }

        return fibonacci(n-1) + fibonacci(n-2);
    }

    /**
     * 逆向思维
     *
     * @param
     * @return void
     * @date 2022/11/12 0:12
     * @author wty
     **/
    @Test
    public void monkeyEatPeach(){
        //2.猴子吃桃子问题:有一堆桃子，猴子第一天吃了其中的一 半，并再多吃了一个!以后
        //每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时(即还没吃)
        //发现只有1个桃子了。问题:最初共多少个桃子?

        /**
         * 第i天  桃子
         * 10     1
         *  9     4
         *  8     10
         *  7     22
         *  6     46
         */
        int n = 1;
        int i = PeachNums(1,10);
        System.out.println("最初有"+i+"个桃子");
    }

    public int PeachNums(int nums,int day){
        for (int i = day - 1; i >= 1; i--) {
            nums = (nums + 1) * 2;
            System.out.println("第"+i+"天有" +nums+ "个桃子");
        }
        return nums;
    }
}

迷宫问题

迷宫问题

策略:下右上左

package com.maze;

import org.junit.Test;

/**
 * 老鼠迷宫
 *
 * 老鼠初始位置:(1,1)
 *
 * 老鼠逃离迷宫位置:(6,5)
 *
 * @author wty
 * @date 2022/11/12 0:19
 */
public class Maze {
    @Test
    public void maze(){
        // 迷宫 8 行 7  列
        int maze[][] = new int[8][7];
        // 0 表示无障碍物， 1 表示有障碍物
        System.out.println(maze[0].length);
        System.out.println(maze.length);
        /**
         * 7 列
         * 8 行
         */

        // 四周设置障碍物
        // 1. 最上面一行和最下面一行设置障碍物
        for (int j = 0; j < maze[0].length; j++) {
            maze[0][j] = 1;
        }
        for (int j = 0; j < maze[7].length; j++) {
            maze[7][j] = 1;
        }

        // 2. 最左边一列和最右面一列设置障碍物
        for (int i = 0; i < maze.length; i++) {
            maze[i][0] = 1;
        }

        for (int i = 0; i < maze.length; i++) {
            maze[i][6] = 1;
        }

        // 3.第四行左边三个设置障碍物
        for (int j = 0; j < 3; j++) {
            maze[3][j] = 1;
        }

        // 遍历
        for (int i = 0; i < maze.length; i++) {
            for (int j = 0; j < maze[i].length; j++) {
                System.out.print(maze[i][j] + "\t");
            }
            System.out.println();
        }


        new Mouse().findway(maze,1,1);

        System.out.println("=====找到路后:=====");
        // 遍历
        for (int i = 0; i < maze.length; i++) {
            for (int j = 0; j < maze[i].length; j++) {
                System.out.print(maze[i][j] + "\t");
            }
            System.out.println();
        }


    }

    class Mouse{
        // 使用递归回溯的思想来解决老鼠出迷宫
        /**
         * 找路
         *
         * @param
         * @param: map 迷宫
         * @param: i 老鼠的横坐标
         * @param: j 老鼠的纵坐标
         * @return boolean
         * @date 2022/11/12 0:34
         * @author wty
         **/
        public boolean findway(int map[][],int i,int j){
            // 规定map地图的规则
            // 0 表示无障碍物， 1 表示有障碍物
            // 2 表示可以走的路  3 死路
            // 获胜条件,当map[6][5] = 2 就说明找到通路了,否则就继续找
            // 先确定一个找路的策略 下右上左
            if (map[6][5] == 2){
                return true;
            }else if (map[i][j] == 0){
                // 表示无障碍物
                // 假定可以走通设置为2
                map[i][j] = 2;

                // 用找路策略来测试是否可以真的走通
                // 下右上左

                if (findway(map,i+1,j)){
                    // 下
                    return true;
                }else if (findway(map,i,j+1)){
                    // 右
                    return true;
                }else if (findway(map,i-1,j)){
                    // 上
                    return true;
                }else if (findway(map,i,j-1)) {
                    // 左
                    return true;
                }else {
                    map[i][j] = 3;
                    return false;
                }


            }else {
                //  map[i][j] == 2 || map[i][j] == 1 || map[i][j] == 3
                return false;
            }


        }
    }
}

输出结果

7
8
1	1	1	1	1	1	1	
1	0	0	0	0	0	1	
1	0	0	0	0	0	1	
1	1	1	0	0	0	1	
1	0	0	0	0	0	1	
1	0	0	0	0	0	1	
1	0	0	0	0	0	1	
1	1	1	1	1	1	1	
=====找到路后:=====
1	1	1	1	1	1	1	
1	2	0	0	0	0	1	
1	2	2	2	0	0	1	
1	1	1	2	0	0	1	
1	0	0	2	0	0	1	
1	0	0	2	0	0	1	
1	0	0	2	2	2	1	
1	1	1	1	1	1	1

策略:右下左上

package com.maze;

import org.junit.Test;

/**
 * @author wty
 * @date 2022/11/12 10:02
 */
public class Maze02 {
    @Test
    public void maze(){

        // 初始化地图
        int maze[][] = new int [8][7];

        // 无障碍物为0  有障碍物为1
        // 将第一行和最后一行设置障碍物
        System.out.println(maze.length);
        for (int i = 0; i < maze.length - 1; i++) {
            maze[0][i] = 1;
            maze[7][i] = 1;
        }

        // 将第一列和最后一列设置障碍物
        for (int i = 0; i < maze[0].length; i++) {
            maze[i][0] = 1;
            maze[i][6] = 1;

        }

        // 将第四行增加障碍
        maze[3][1] = 1;
        maze[3][2] = 1;

        System.out.println("=====找路前遍历=====");
        for (int i = 0; i < maze.length; i++) {
            for (int j = 0; j < maze[i].length; j++) {
                System.out.print(maze[i][j] + "\t");
            }
            System.out.println();
        }

        // 定义老鼠初始位置
        findway(maze,1,1,2);

        System.out.println("=====找路后遍历=====");
        for (int i = 0; i < maze.length; i++) {
            for (int j = 0; j < maze[i].length; j++) {
                System.out.print(maze[i][j] + "\t");
            }
            System.out.println();
        }

    }

    public boolean findway(int maze[][],int i,int j,int step){
        if (!(i>=0 && i<= maze.length && j >=0 && j<= maze[i].length)){
            return false;
        }
        // 0 无障碍
        // 1 有障碍
        // 2 通路
        // 3 死路

        if (maze[6][5] == 2){
            return true;
        }else if (maze[i][j] == 0){
            maze[i][j] = step;
            // 右下左上顺序
            if (findway(maze,i,j+1,2)){
                return true;
            }else if(findway(maze,i+1,j,2)){
                return true;
            }else if(findway(maze,i,j-1,2)){
                return true;
            }else if(findway(maze,i-1,j,2)){
                return true;
            }else {
                maze[i][j] = 3;
                return false;
            }
        }else {
            return false;
        }
    }


}

输出结果

8
=====找路前遍历=====
1	1	1	1	1	1	1	
1	0	0	0	0	0	1	
1	0	0	0	0	0	1	
1	1	1	0	0	0	1	
1	0	0	0	0	0	1	
1	0	0	0	0	0	1	
1	0	0	0	0	0	1	
1	1	1	1	1	1	1	
=====找路后遍历=====
1	1	1	1	1	1	1	
1	2	2	2	2	2	1	
1	0	0	0	0	2	1	
1	1	1	0	0	2	1	
1	0	0	0	0	2	1	
1	0	0	0	0	2	1	
1	0	0	0	0	2	1	
1	1	1	1	1	1	1

测试回溯现象

package com.maze;

import org.junit.Test;

/**
 * @author wty
 * @date 2022/11/12 10:46
 */
public class Maze03 {
    @Test
    public void maze03(){
        // 初始化地图
        int maze[][] = new int [8][7];

        // 无障碍物为0  有障碍物为1
        // 将第一行和最后一行设置障碍物
        System.out.println(maze.length);
        for (int i = 0; i < maze.length - 1; i++) {
            maze[0][i] = 1;
            maze[7][i] = 1;
        }

        // 将第一列和最后一列设置障碍物
        for (int i = 0; i < maze[0].length; i++) {
            maze[i][0] = 1;
            maze[i][6] = 1;

        }

        // 将第四行增加障碍
        maze[3][1] = 1;
        maze[3][2] = 1;

        // 测试回溯现象，增加墙
        maze[2][5] = 1;

        System.out.println("=====找路前遍历=====");
        for (int i = 0; i < maze.length; i++) {
            for (int j = 0; j < maze[i].length; j++) {
                System.out.print(maze[i][j] + "\t");
            }
            System.out.println();
        }

        // 定义老鼠初始位置
        findway(maze,1,1,2);

        System.out.println("=====找路后遍历=====");
        for (int i = 0; i < maze.length; i++) {
            for (int j = 0; j < maze[i].length; j++) {
                System.out.print(maze[i][j] + "\t");
            }
            System.out.println();
        }

    }

    public boolean findway(int maze[][],int i,int j,int step){
        if (!(i>=0 && i<= maze.length && j >=0 && j<= maze[i].length)){
            return false;
        }
        // 0 无障碍
        // 1 有障碍
        // 2 通路
        // 3 死路

        if (maze[6][5] == 2){
            return true;
        }else if (maze[i][j] == 0){
            maze[i][j] = step;
            // 右下左上顺序
            if (findway(maze,i,j+1,2)){
                return true;
            }else if(findway(maze,i+1,j,2)){
                return true;
            }else if(findway(maze,i,j-1,2)){
                return true;
            }else if(findway(maze,i-1,j,2)){
                return true;
            }else {
                maze[i][j] = 3;
                return false;
            }
        }else {
            return false;
        }
    }
}

输出结果

8
=====找路前遍历=====
1	1	1	1	1	1	1	
1	0	0	0	0	0	1	
1	0	0	0	0	1	1	
1	1	1	0	0	0	1	
1	0	0	0	0	0	1	
1	0	0	0	0	0	1	
1	0	0	0	0	0	1	
1	1	1	1	1	1	1	
=====找路后遍历=====
1	1	1	1	1	1	1	
1	2	2	2	2	3	1	
1	0	0	0	2	1	1	
1	1	1	0	2	2	1	
1	0	0	0	0	2	1	
1	0	0	0	0	2	1	
1	0	0	0	0	2	1	
1	1	1	1	1	1	1

求出最短路径

这一块后续补充，需要学习图的遍历：深度优先和广度优先，弗洛伊德算法等

汉诺塔

汉诺塔

package com.hanoi;

import org.junit.Test;

/**
 * 汉诺塔
 *
 * @author wty
 * @date 2022/11/12 11:12
 */
public class Hanoi {
    @Test
    public void hanoi(){
            new Tower().move(3,'A','B','C');
        }
}

class Tower{
    /**
     * 汉诺塔的移动
     *
     * @param
     * @param: num 移动的个数
     * @param: a 塔
     * @param: b 塔
     * @param: c 塔
     * @return void
     * @date 2022/11/12 11:13
     * @author wty
     **/
    public void move(int num,char a,char b,char c){

        // 如果只有一个盘
        if (num == 1){
            System.out.println(a+"->"+c);
        }else {
            // 如果有多个盘，可以看成2个盘
            //(1)先移动上面所有的盘到B(需要借助C)
            move(num - 1,a,c,b);
            //(2)把最下面的盘，移动到C
            System.out.println(a+"->"+c);
            //(3)把B塔的所有盘，移动到C，借助A塔
            move(num - 1,b,a,c);
        }

    }

}

八皇后问题

八皇后问题

package com.queen;

import org.junit.Test;

/**八皇后
 *
 * @author wty
 * @date 2022/11/12 11:35
 */
public class EightQueen {
    @Test
    public void eightQueen(){
     int array[] = new int[8];
     put(array,0);
    }

    /***
     * 输出一维数组
     *
     * @param
     * @param: array
     * @return void
     * @date 2022/11/12 12:18
     * @author wty
     **/
    public void print(int array[]){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        System.out.println();
    }


    /**
     * 放置方式
     *
     * @param
     * @param: array 代表棋盘的每一行
     * @param: n 代表位置
     * @return boolean
     * @date 2022/11/12 11:37
     * @author wty
     **/
    public boolean findResult(int array[],int n){
        for (int i = 0; i < n; i++) {
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])){
                return false;
            }
        }
        return true;
    }

    /**
     * 放置棋子
     *
     * @param
     * @param: array 代表棋盘
     * @param: n 代表放置第n个位置
     * @return void
     * @date 2022/11/12 12:43
     * @author wty
     **/
    public void put(int array[],int n){
        if (n == array.length){
            print(array);
            return;
        }
        for (int i = 0; i < array.length; i++) {
            array[n] = i;
            // 只看0开头的分析即可
//            if (array[0] > 0){
//                break;
//            }
            if (findResult(array,n)){
                put(array,n+1);
            }
        }
    }



}
心向阳光的天域
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
常见的Java编程思想
m0_61902970的博客
08-08 330
对于隐藏的部分客户端程序员将不能够访问它，这部分通常代表对象内部脆弱的部分，很容易被粗心的或不知内情的客户端程序员所毁坏，因此隐藏这部分可以减少程序bug。（这对客户端程序员来说其实是一项服务，因为他们可以很容易地看出哪些东西对他们来说很重要，哪些可以忽略）第二个原因就是允许库设计者可以改变类内部的工作方式而不用担心会影响到客户端程序员。相互关系很重要，当创建一个类库时，就建立了与客户端程序员之间的关系，他们同样是程序员，但是他们是使用你的类库来构建应用、或者构件更大的类库的程序员。...
4.java数据结构与算法 ---- 第六章递归(回溯) --师承尚硅谷韩顺平
Kevinwen0228的博客
09-06 195
递归
笔记_尚硅谷Java数据结构与java算法 韩顺平数据结构与算法_Part1(经典算法面试题和实际问题)
Jeankyw的博客
08-18 833
字符串匹配问题： 有一个字符串 str1= ““硅硅谷 尚硅谷你尚硅 尚硅谷你尚硅谷你尚硅你好””， 和一个子串 str2=“尚硅谷你尚硅你” 现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1 暴力匹配 (简单，但是效率低) KMP 算法(部分匹配表) 汉诺塔游戏 请完成汉诺塔游戏的代码: 要求： 1)将 A 塔的所有圆盘移动到 C 塔。并且规定，在 2) 小圆盘上不能放大圆盘， 3)在三根柱子之间一次只能移动一个圆盘 八皇后问题.
迷宫最短路径【Java实现】
Infinity_and_beyond的博客
02-10 1626
现有一个n∗m大小的迷宫，其中1表示不可通过的墙壁，0表示平地。每次移动只能向上下左右移动一格，且只能移动到平地上。假设左上角坐标是(1,1)，行数增加的方向为x增长的方向，列数增加的方向为y增长的方向，求从迷宫左上角到右下角的最少步数的路径。
Java基础算法50题（二）
HK的博客
07-17 7105
Java基础算法后25题
尚硅谷【韩顺平】 | Java数据结构和算法【详细笔记】（持续更新）
热门推荐
小七自学博客
11-04 1万+
这里写目录标题数据结构线性结构和非线性结构线性结构非线性结构稀疏 sparsearray 数组 和队列稀疏 sparsearray 数组基本介绍应用实例代码的实现队列数组模拟队列思路实现代码问题分析并优化数组模拟环形队列实现代码链表链表介绍单链表的应用：第一步：在添加英雄时，直接添加到链表的尾部第二步：根据排名插入到指定位置第三步：修改节点第四步：删除节点面试题求单链表中有效节点的个数求单链表的倒数第K个节点反转链表打印逆序列表合并两个有序链表实现全部代码双向链表管理单向链表的缺点分析:双向链表的操作分析单
java算法编程题（60题）
似水流年风萧兮
06-16 1万+
题目1、兔子问题2、求素数3、水仙花数4、分解质因数5、成绩问题6、最大公约数和最小公倍数7、统计字符个数8、a+aa+aaa+…9、完数10、自由落体11、无重复数12、利润问题13、完全平方数14、判断这这一天是这一年的第几天15、升序输出16、九九乘法表17、猴子问题一18、猴子问题二19、输出棱形20、数列的前n项和问题21、阶乘相加22、递归求阶乘23、岁数问题24、逆序输出25、判断回...
java经典算法题
ZHANGLIZENG的博客
08-29 6875
1.Java多线程：写一下两个线程交替打印 0~100 的奇偶数 这种实现方式的原理就是线程1打印之后唤醒其他线程，然后让出锁，自己进入休眠状态。因为进入了休眠状态就不会与其他线程抢锁，此时只有线程2在获取锁，所以线程2必然会拿到锁。线程2以同样的逻辑执行，唤醒线程1并让出自己持有的锁，自己进入休眠状态。这样来来回回，持续执行直到任务完成。就达到了两个线程交替获取锁的效果了。 private int count = 0; private final Object lock = new Object()
迷宫问题（Java实现，求最短路径）
就这样吧
07-10 8277
题目链接 迷宫问题 定义一个二维数组： int maze[n][m]; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 输入描述： 一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。 int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 样式输出： (0,0) (
【Java编程思想】
weixin_42036558的博客
03-23 1843
Java编程思想（一） https://blog.csdn.net/weixin_40841731/article/details/83861285 MikeShine 2019.04.22 20:15:23 字数 2,324 阅读 12,067 前面我们在网站上面学过 java，但是学到的东西不够系统。这里通过对 Bruce Eckel《Thinking in Java》的学习，希望可以系统的掌握 java 的相关知识。在这本书之后，还需要学习 JVM 相关知识。才称得上对 java 有一定的理解。 这一
JAVA:递归与迷宫问题
weixin_51852915的博客
05-06 737
public class Test { public static void main(String[] args) { int[][] map = new int[8][7]; // 先创建一个二维数组，模拟迷宫 for(int i=0;i<7;i++){ // 建筑上下墙 map[0][i] = 1; map[7][i] = 1; } for(int j=0;j<8.
【高级语法篇】Java必备基础(思维导图+代码)
weixin_62633072的博客
06-28 686
⭐代码和思维导图详见仓库：Sivan_Xin的代码仓库—Java语法。如果觉得有帮助的话，可以帮作者点一个star⭐哦~本文共16000字，读完约需30分钟。多个线程可以对内存进行操作，这时就可能会出现一些问题。一个Java程序至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。并行与并发： 并行：多个CPU同时执行多个任务。 并发：一个CPU同时执行多个任务。比如：秒杀、多个人做同一件事。问：何时需要多线程？相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。时
Java专题训练——21天学习挑战赛
zhyy-ang的博客
08-06 385
​​练习建议：编程思维和编程能力不是一朝一夕形成的，需要时间的沉淀和大量练习。具体措施：勤于练习代码，勤于思考，孰能生巧。前期：先模仿，后期：再创新。不积跬步，无以至千里；不积小流，无以成江海。...
【基础语法篇】Java必备基础(思维导图+代码)
weixin_62633072的博客
06-28 915
⭐代码和思维导图详见仓库：Sivan_Xin的代码仓库—Java语法。如果觉得有帮助的话，可以帮作者点一个star⭐哦~本文共5600字，读完约需12分钟。 ：jdk是java软件开发工具包，包含jre和JAVA工具。JAVA工具： javac：JAVA编译器（程序—字节码）； java：JAVA解释器（解释编译后的字节码文件）； jdb：JAVA调试器； javadoc：文档生成器。jre： JAVA运行环境，包括jvm和系统类库等。ps：本文使用JDK8的版本。从输出设备（显示屏）输出： 从输入设备（键
java编程思想实用整理
qq_41721646的博客
12-31 924
对java编程思想这本书籍的整理，主要针对本人认为比较有趣重要的思想和特性进行的学习和整理。 对象存储位置，java基本数据类型 static关键字，java垃圾回收机制
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1278
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 274
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
（javaweb）请求响应postman
2301_79144798的博客
08-08 468
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
最新发布
VX_DZbishe的博客
08-11 208
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
韩顺平Oracle教学笔记：数据库查询实例解析
“韩顺平Oracle教学笔记包含了作者对Oracle数据库的学习和复习记录，适用于Oracle的初学者和进阶者，提供了丰富的SQL查询示例。” 在韩顺平的Oracle教学笔记中，我们可以找到许多关于Oracle数据库操作和SQL查询的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

心向阳光的天域

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

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

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

打赏作者

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

抵扣说明：

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

余额充值