java从入门到入土第6天

已于 2024-05-05 21:14:03 修改
阅读量106 收藏
点赞数 3
分类专栏： java入门到入土 文章标签： java 开发语言
于 2024-04-28 16:56:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_yin0/article/details/138283979
版权

Day06

public class Work01{
	/**
		1.求出1-100之间偶数和
	*/
	public static void main(String[] args){
		
		int sum = 0;
		for(int i = 1;i<=100;i++){
			if(i % 2 == 0){
				sum += i;
			}
		}
		
		System.out.println("1~100之间偶数之和为：" + sum);
		
	}
}

public class Work02{
	/**
		2.计算从1到100个值以内所有能被3或者17整除的数的和并输出。
	*/
	public static void main(String[] args){
		
		int sum = 0;
		for(int i = 1;i<=100;i++){
			if(i%3==0 || i%17==0){
				sum += i;
			}
		}
		
		System.out.println("1~100之间能被3或者17整除的数之和为：" + sum);
		
	}
}

public class Work03{
	/**
		3.3000米长的绳子，每天减一半。问多少天这个绳子会小于5米？不考虑小数
	*/
	public static void main(String[] args){
		
		int length = 3000;
		int day = 0;
		while(length >= 5){
			length /= 2;
			day++;
		}
		
		System.out.println(day + "天后绳子的长度小于5米");
	}
}

public class Work04{
	/**
		4.求2～100之内的素数。【素数 ： 只能被1或本身整除的数】
	*/
	public static void main(String[] args){
		
		for(int num = 2;num<=100;num++){
			boolean bool = true;
			for(int i = 2;i<num;i++){
				if(num % i == 0){
					bool = false;
					break;
				}
			}
			if(bool){
				System.out.println(num);
			}
		}
	
	}
}

import java.util.Scanner;
public class Work05{
	/**
		5.模拟ATM取款机的三次密码校验，当天达到3次输入密码错误，
		  则提示“账号被冻结”，其他情况则提示还有多少次输入机会
	*/
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		
		int count = 3;
		
		while(count > 0){
			System.out.println("请输入密码：");
			String password = scan.next();
			
			if(password.equals("123456")){
				System.out.println("随便取款...");
				break;
			}else{
				count--;
				if(count == 0){
					System.out.println("账号被冻结，请携带身份证前往银行办理");
					break;
				}
				
				System.out.println("您还有" + count + "次机会");
				System.out.println("是否继续录入，录入请按y，退出请按其他任意键");
				String str = scan.next();
				if(!str.equals("y")){
					System.out.println("正在退出**银行系统，欢迎下次再来...");
					break;
				}
			}
		}
	}
}

import java.util.Scanner;
public class Work06{
	/**
		6.要求循环录入2个班的学员成绩，假设每个班都有3个学员，
		 依次录入，统计超过90分的学员人数，以及这批超过90分的学员平均分。
	*/
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		
		int count = 0;//超过90分学生的人数
		double sum = 0;//超过90分学生成绩的总和
		
		for(int i = 1;i<=2;i++){
			for(int j = 1;j<=3;j++){
				System.out.println("请输入第" + i + "个班的第" + j + "名学生的成绩：");
				double score = scan.nextDouble();
				if(score > 90){
					count++;
					sum += score;
				}
			}
		}
		
		System.out.println("超过90分学生的人数为：" + count);
		
		double avg = sum/count;
		System.out.println("超过90分学生成绩的平均分为：" + avg);
		
		//保留两位小数
		avg = (int)(avg*100)/100.0;
		System.out.println("超过90分学生成绩的平均分为：" + avg);
		
		
	}
}

public class Test01{
	/**
		知识点：静态方法
		理解：特定功能的代码块
		好处：解决代码的冗余
		语法结构：
			访问修饰符 static 返回值类型 方法名([参数列表]){
				...代码块...
			}
		分类：
			无参数无返回值的方法
			带参数的方法
			带返回值的方法
			
		
		知识点：静态方法 -- 无参数无返回值的方法
		语法结构：
			public static void 方法名(){
				...代码块
			}
			
		注意：
			1.public是访问修饰符的一种，表示公有的
			2.void表示无返回值（关键字）
			3.方法在类中声明
			4.方法与方法之间是平级关系
			5.方法没被调用，就是个摆设
			
		需求1：模拟玩家LOL的操作过程
		分析：走位、发技能
		
			
		需求2：设计一个方法，打印三角形
			
	*/
	public static void main(String[] args){
		
		//调用方法
		//Test01.run();
		//Test01.run();
		//Test01.play();
		//Test01.run();
		//Test01.play();
		//Test01.run();
		
		//调用方法
		run();
		run();
		play();
		run();
		play();
		run();
		
		printStar();
		printStar();
		
	}
	
	public static void printStar(){
		for(int i = 0;i<5;i++){
			for(int j = 0;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
	
	public static void run(){
		System.out.println("风骚的走位 -- 500行");
	}
	
	public static void play(){
		System.out.println("发技能 -- 1200行");
	}
}

public class Test02{
	/**
		知识点：静态方法 -- 带参数的方法
		语法结构：
			public static void 方法名(参数列表){
				...代码块...
			}
			
		注意：
			1.形式参数/形参：声明方法时规定的参数
			2.形参必须声明类型
			3.形参属于该方法的变量，作用域就在该方法内，形参也是局部变量
			4.局部变量：方法里声明的变量
			5.实际参数/实参：调用方法时传入的数据
			6.实参和形参的类型必须兼容
			7.实参和形参可以有多个，用逗号分割
			
		需求1：设计一个方法，打印三角形，三角形的行数由调用方传入
		
		需求2：设计一个方法，传入两个int值，输出最大值
			
	*/
	public static void main(String[] args){
		
		printStar(3);
		printStar(5);
		printStar('A');//'A' - 65
		
		getMax(10,20);
	}
	
	public static void getMax(int a,int b){
		int max = (a>b)?a:b;
		System.out.println("最大值为：" + max);
	}
	
	public static void printStar(int num){
		for(int i = 0;i<num;i++){
			for(int j = 0;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
	
}

import java.util.Scanner;
public class Test03{
	/**
		知识点：静态方法 -- 带返回值的方法
		语法结构：
			public static 返回值类型 方法名([参数列表]){
				...代码块...
				return 数据;//1.结束当前方法 2.将数据返回给调用方
			}
			
		注意：
			1.带返回值的方法有没有参数要看具体需求
			2.声明方法时需要设置返回值类型
			3.return后接的是需要返回的具体数据
			4.方法功能单一性（一个方法的功能不要过于强大）
			5.方法声明时规定的返回值类型 和 return后的数据 必须兼容
			6.返回值只能有一个，如果想返回多个值就必须使用数组、集合、....
			
		需求：
			设计一个方法，传入两个int值，返回最大值	
			在控制台输入是三个int值，输出最大值
	*/
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入第一个数字：");
		int a = scan.nextInt();
		System.out.println("请输入第二个数字：");
		int b = scan.nextInt();
		System.out.println("请输入第三个数字：");
		int c = scan.nextInt();
	
		int max = getMax(a,b);
		max = getMax(max,c);
		System.out.println("最大值为：" + max);
	}
	
	public static int getMax(int a,int b){
		int max = (a>b)?a:b;
		return max;
	}
	
	
}

public class Test04{
	/**
		知识点：方法的重载
		概念：方法之间的关系
		条件：
			1.在同一个类中
			2.方法名必须一致
			3.参数列表的个数或者类型不一致
			4.与返回值无关
		好处：系统会根据实参类型自动匹配到对应的方法中
		应用场景：在同一个类中，多个方法功能大概一致，但是细节实现不一致，就可以考虑使用重载
		
		需求1：设计一个方法，传入两个int值，返回最大值 -- getMax(int a,int b)
		需求2：设计一个方法，传入三个int值，返回最大值 -- getMax(int a,int b,int c)
		需求3：设计一个方法，传入两个double值，返回最大值 -- getMax(double a,double b)
		需求4：设计一个方法，传入三个double值，返回最大值 -- getMax(double a,double b,double c)
		
		设计方法的步骤：
			1.考虑方法名（见名知意）
			2.考虑形参（几个？类型？）
			3.考虑返回值（需不需要？返回值类型）
		
	*/
	public static void main(String[] args){
		
		//打印getMax方法，前提是该方法必须有返回值
		System.out.println(getMax(10.1,20,30));
	}
	
	public static int getMax(int a,int b){
		return (a>b)?a:b;
	}
	
	public static int getMax(int a,int b,int c){
		int max = (a>b)?a:b;
		max = (max>c)?max:c;
		return max;
	}
	
	public static double getMax(double a,double b){
		return (a>b)?a:b;
	}
	
	public static double getMax(double a,double b,double c){
		double max = (a>b)?a:b;
		max = (max>c)?max:c;
		return max;
	}
	
	//错误示范：重载要关注形参的类型，不关注形参的名字
	
	//public static void method(String str,int i){
	//}
	
	//public static void method(String ss,int ii){
	//}
	
}

public class Test05{
	/**
		知识点：方法的递归
		含义：方法调用方法自身
		注意：递归是一种程序设计的思想
	*/
	public static void main(String[] args){
		
		//错误示范
		//StackOverflowError - 栈内存溢出
		//原因：调用方法就会在栈内存中开辟空间，用于存放该方法的局部变量，
		//		死循环的调用方法，就会使得栈内存满载并溢出了
		method();
	}
	
	
	public static void method(){
		method();
	}

}

public class Test06{
	/**
		知识点：方法的递归
		含义：方法调用方法自身
		注意：递归是一种程序设计的思想
		经验：
			1.找规律：什么情况下方法应该调用方法自身
			2.找出口：什么情况下应该解决该方法
		
		需求：设计一个方法，传入一个int值n，求n的阶乘
		分析：
			5! = 1*2*3*4*5 	-> 5! = 4! * 5
			4! = 1*2*3*4	-> 4! = 3! * 4
			3! = 1*2*3		-> 3! = 2! * 3
			2! = 1*2		-> 2! = 1! * 2
			1! = 1			-> 1! = 1
			找规律：n! = (n-1)! * n
			找出口：1! = 1
			
			
	*/
	public static void main(String[] args){
		
		int num = getFactorial(5);
		System.out.println(num);
	}
	
	public static int getFactorial(int n){
		
		if(n != 1){
			return getFactorial(n-1) * n;
		}else{
			return 1;
		}
	}
	
}

public class Test07{
	/**
		知识点：方法的递归
		含义：方法调用方法自身
		注意：递归是一种程序设计的思想
		经验：
			1.找规律：什么情况下方法应该调用方法自身
			2.找出口：什么情况下应该解决该方法
		
		需求 - 不死神兔问题：
			有1对兔子，从出生后的第3个月起每个月都生一对兔子，
			小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第n个月有几对兔子
			设计一个方法，传入月份，获取当月兔子的对数
		分析：
			找规律：当月兔子的对数等于上个月+上上个月兔子的对数
			找出口：1月或2月都是1对兔子
			
		扩展：
			不死神兔的数据：1,1,2,3,5,8,13,21...
			这种数列叫做斐波那契数列/黄金分割数列
			该数列相邻两个数的比例越往后越趋近于0.618
	*/
	public static void main(String[] args){
	
		int num = getRabbit(10);
		System.out.println(num);
	}
	
	public static int getRabbit(int month){
		if(month == 1 || month == 2){
			return 1;
		}else{
			return getRabbit(month-1) + getRabbit(month-2);
		}
	}
}

import java.util.Scanner;
public class Test08{
	/**	
		知识点：万年历
		
		需求：输入年和月，打印当月的日历
		线索：1900年1月1日是星期一
		
		要想打印当月的日历，需要哪些数据作为支持？
			年份、月份、当月天数、当月第一天是星期几
	*/
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入年：");
		int year = scan.nextInt();
		System.out.println("请输入月：");
		int month = scan.nextInt();
		
		//当月天数
		int day = getDay(year,month);
		
		//总天数
		int allDay = getAllDay(year,month);
		//计算星期
		int week = getWeek(allDay);
		
		//打印日历
		printCalendar(year,month,day,week);
	}
	
	//打印日历
	public static void printCalendar(int year,int month,int day,int week){
		System.out.println(" --- " + year + "年" + month + "月 ---");
		System.out.println("一\t二\t三\t四\t五\t六\t日");
		
		int count = 0;
		
		for(int i = 1;i<week;i++){
			System.out.print("\t");
			count++;
		}
		
		for(int i = 1;i<=day;i++){
			System.out.print(i + "\t");
			count++;
			if(count % 7 == 0){
				System.out.println();
			}
		}
	}
	
	//计算星期
	public static int getWeek(int allDay){
		int week = allDay%7;
		if(week == 0){
			week = 7;
		}
		return week;
	}
	
	//计算1900年1月1日到输入年输入月的总天数
	public static int getAllDay(int year,int month){
		int allDay = 0;
		
		//年的总天数
		for(int i = 1900;i<year;i++){
			if(isLeapYear(i)){
				allDay += 366;
			}else{
				allDay += 365;
			}
		}
		
		//月的总天数
		for(int i = 1;i<month;i++){
			allDay += getDay(year,i);
		}
		
		//累加当月的第一天
		allDay += 1;
		
		return allDay;
	}
	
	//获取当月天数
	public static int getDay(int year,int month){
		int day = 0;
		switch(month){
			case 1:case 3:case 5:case 7:case 8:case 10:case 12:
				day = 31;
			break;
			case 4:case 6:case 9:case 11:
				day = 30;
			break;
			case 2:
				if(isLeapYear(year)){
					day = 29;
				}else{
					day = 28;
				}
			break;
		}
		return day;
	}
	
	//判断是否是闰年
	public static boolean isLeapYear(int year){
		if(year%4==0 && year%100!=0 || year%400==0){
			return true;
		}
		return false;
	}
}

public class Test09{
	/**	
		知识点：Java的引用数据类型
			数组
			类
			接口
			枚举
	
		知识点：一维数组
		理解：一组数据的容器
		声明：
			数据类型[] 数组名;
			数据类型 数组名[];
		概念：
			1.数组是引用数据类型
			2.数组中的数据也叫做元素
			3.元素都是编号也叫做下标/索引
			4.下标从0开始
			5.数组元素在内存中开辟的空间是连续的
			6.数组一旦初始化成功，长度不可变（意味着数组不能添加和删除）
			
		数组的初始化：
			静态初始化：元素由程序员指定，长度由系统分配
			动态初始化：
	*/
	public static void main(String[] args){
		
		//静态初始化1：
		//String[] names = new String[]{"麻生希","椎名空","水菜丽","朝桐光","樱井步"};
		
		//静态初始化2：先声明，再初始化
		//String[] names;
		//names = new String[]{"麻生希","椎名空","水菜丽","朝桐光","樱井步"};
		
		//静态初始化3：简化静态初始化1：
		String[] names = {"麻生希","椎名空","水菜丽","朝桐光","樱井步"};
		
		
		//设置指定下标上的元素
		names[2] = "侯小康";
		
		//获取指定下标上的元素
		String str = names[2];
		System.out.println("获取指定下标上的元素：" + str);//侯小康
		
		//获取数组元素的个数
		int len = names.length;
		System.out.println("获取数组元素的个数：" + len);//5
		
		System.out.println("------------------------------------");
		
		//遍历数组 -- for
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("------------------------------------");
		
		//遍历数组 -- foreach/增强for循环
		for(String element : names){
			System.out.println(element);
		}
		
		/**
			for vs foreach
				遍历数组时，使用到下标 -- for循环
				遍历数组时，不使用到下标 -- foreach
		*/
	}
}

public class Test10{
	/**	
		知识点：一维数组
		理解：一组数据的容器
		声明：
			数据类型[] 数组名;
			数据类型 数组名[];
		概念：
			1.数组是引用数据类型
			2.数组中的数据也叫做元素
			3.元素都是编号也叫做下标/索引
			4.下标从0开始
			5.数组元素在内存中开辟的空间是连续的
			6.数组一旦初始化成功，长度不可变（意味着数组不能添加和删除）
			
		数组的初始化：
			静态初始化：元素由程序员指定，长度由系统分配
			动态初始化：长度由程序员指定，元素由系统分配
				整数类型默认值：0
				浮点类型默认值：0.0
				字符类型默认值：' '
				布尔类型默认值：false
				引用类型默认值：null(空)
	*/
	public static void main(String[] args){
		
		//动态初始化1：[null,null,null,null,null]
		//String[] names = new String[5];//5表示该数组需要开辟空间的个数
		
		//动态初始化2：先声明，再初始化
		String[] names;
		names = new String[5];
		
		//设置指定下标上的元素
		names[0] = "侯小康1";
		names[1] = "侯小康2";
		names[2] = "侯小康3";
		names[3] = "侯小康4";
		names[4] = "侯小康5";
		
		//ArrayIndexOutOfBoundsException -- 数组下标越界异常
		//names[5] = "侯小康";
		
		//获取指定下标上的元素
		String str = names[2];
		System.out.println("获取指定下标上的元素：" + str);//侯小康
		
		//获取数组元素的个数
		int len = names.length;
		System.out.println("获取数组元素的个数：" + len);//5
		
		System.out.println("------------------------------------");
		
		//遍历数组 -- for
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("------------------------------------");
		
		//遍历数组 -- foreach/增强for循环
		for(String element : names){
			System.out.println(element);
		}
		
		/**
			for vs foreach
				遍历数组时，使用到下标 -- for循环
				遍历数组时，不使用到下标 -- foreach
		*/
	}
}

import java.util.Scanner;
public class Test11{
	/**	
		知识点：一维数组的案例
		
		创建一个int类型的数组，长度由用户指定，数据由用户输入，输入完毕后获取最大值并输出
	*/
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入数组长度：");
		int len = scan.nextInt();
		
		int[] arr = new int[len];
		
		for(int i = 0;i<arr.length;i++){
			System.out.println("请输入第" + (i+1) + "个元素：");
			int num = scan.nextInt();
			arr[i] = num;
		}
		
		//假设下标为0的位置上的元素为最大值
		int max = arr[0];
		for(int i = 1;i<arr.length;i++){
			if(max < arr[i]){
				max = arr[i];
			}
		}
		
		System.out.println("最大值为：" + max);
		
		/**
			小结：
				初始化时只知道元素，就使用静态初始化
				初始化时只知道长度，就使用动态初始化
				int类型的数组为引用数据类型，数组中的元素是基本数据类型
		*/
	}
}

1.方法
无参数无返回值的方法
带参数的方法（形参和实参）
带返回值的方法（方法声明时的类型、return后接的数据）

2.方法的重载（概念、条件、好处、应用场景）

3.方法的递归（概念、找出口、找规律）

4.方法版本的万年历

5.一维数组

作业：
1.知识点的梳理文档（方法.md、数组.md）
2.代码编写3遍
3.画内存图（手画2遍、拍照发到QQ群里）
4.课后作业
5.复习：上周所有内容
6.预习：面相对象

奇怪的魔法猫娘
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java从入门到入土第一卷
11-08
没事复习一遍
Java 学习路线思维导图-从入门到入土
11-19
这份资源是xmind版本，自己电脑需要下载个xmind软件才能打开。
Java学习路线从入门到入土
热门推荐
qq_45077173的博客
09-20 1万+
Java学习路线从入门到入土 简介 一门永不过时的编程语言——Java 编程开发。Java编程语言占比：据官方数据统计，在全球编程语言工程师的数量上，Java编程语言以900万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程，因此其程序员的数量最多。而在以Java编程为核心的开发领域中，javaEE程序员的需求量10年来一直居于首位！Java工程师人才缺口：根据IDC的统计数字：就2017年来说，我国Java人才的缺口已达42.5万，并且以每年20%左右 的速度增长。在未来5年内,合格软件人才
java从入门到入土第1天
xiao_yin0的博客
04-22 625
JavaEE：就是服务端，接受来自客户端(前端)的请求，利用响应返回给客户端数据的技术目的：做饭工具：锅碗瓢盆环境：厨房目的：编写Java程序工具：JDK（Java开发工具包）环境：JRE（Java运行时环境）前言：上课时间、上课规矩、学习方法软件开发基础Java环境搭建：安装JDK和JRE，环境变量适配(JAVA_HOME、Path)编写第一个Java程序。
java从入门到入土第2天
xiao_yin0的博客
04-23 816
理解：IDE（编码环境），就是写代码的工具升级：记事本 -> nodepad++ -> eclipse -> IDEAIDE - 编码环境编码问题关键字及关键字变量及注意事项基本数据类型（byte、short、int、long、float、double、char、boolean）基本数据类型的转型。
java从入门到入土第4天
xiao_yin0的博客
04-25 362
6.预习：while、do-while、特殊的流程控制语句。1.转义字符：具有特殊意义的字符本身。数字字面量、字面值常量、final。5.复习：运算符的面试题、特殊点。3.Java执行语句的分类。1.知识点的梳理文档s。5.switch分支。
java从入门到入土第5天
xiao_yin0的博客
04-26 686
6.提升作业：分别使用for循环、while循环实现。5.预习：方法、数组、面向对象。1.嵌套for循环 – 重要。3.do-while循环。5.特殊的流程控制语句。4.复习：本周所有内容。6.万年历 – 重要。1.知识点的梳理文档。
java从入门到入土第3天
xiao_yin0的博客
04-24 540
1.算数运算符（+、-、*、/、%、++、–）注意：特殊点和面试题2.赋值运算符（=、+=、-=、*=、/=、%=）注意：复合赋值的底层公式3.关系运算符（==、!注意：关系运算符的结果都是boolean类型的值4.字符串拼接符（+）5.Scanner类注意：感受面相对象的思想6.逻辑运算符（&、&&、|、||、^、!注意：逻辑运算符的结果都是boolean类型的值7.三目运算符注意：语法结构、返回值规则8.位运算符（&、|、^、、>>>）
java从入门到入土第8天
xiao_yin0的博客
05-04 266
3.预习：面向对象 – 构造方法、this、private、封装、static、继承、super、重写、访问修饰符、抽象类及抽象方法、接口、多态、对象转型、内部类。2.复习：之前所有的内容。
java从入门到入土第9天
xiao_yin0的博客
05-06 136
6.预习：继承、重写、super、抽象类及抽象方法。提升作业：把面向对象版本的五子棋判断输赢实现！6.static修饰属性、修饰方法、静态代码块。4.课后作业：小明把大象装进冰箱。1.构造方法（概念、内存图）1.知识点梳理文档 – 手写。5.复习：之前所有的知识点。5.面向对象版本的五子棋。2.get/set方法。
java从入门到入土第7天
xiao_yin0的博客
04-29 63
【代码】java从入门到入土第7天。
Java从入门到入土之面向对象之三大特性之多态的思维导图
12-18
多态的思维导图
java入门到入土.md
02-20
java入门到入土.md
JAVA教程集合汇总-从入门到入土【汇总多年-史上最详细】呕心沥血整理
02-16
课程内容均为作者多年学习汇总出来的资料，下载后解压可提取相关资源列表，希望能与各位同行共同进步成长，有相关问题请私信我
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1159
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 305
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 398
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1120
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
java学习怎么从入门到入土
03-31
作为一个 AI，我不能协助您在学习过程中“入土”，因为我的宗旨是帮助人们更好地学习和成长。以下是一些建议，可以帮助您更好地学习 Java。 1. 学习基础：首先，您需要了解 Java 的基础知识，例如变量、数据类型、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值