每天进步一点
- Java练习题
- 编程实现
- 1）某人有100000元，每经过一次路口，需要交费，规则如下：当现金>50000时，每次交5%；当现金<= 50000时，每次交1000。编程计算该人可以经过多少次路口，要求：使用while + break 方式完成。
- 2）实现判断一个整数，属于那个范围：大于0；小于0；等于0；
- 3）判断一个年份是否为闰年
- 4）判断一个整数是否是水仙花数，所谓水仙花数是指一个三位数，其各位上数字立方和等于其本身。例如：153 = 1 * 1 * 1 + 5 * 5 *5 + 3 * 3 * 3
- 5）看看下面代码输出什么？
- 6）输出1 - 100之间的不能被5整除，每五个一行。
- 7）输出小写的a - z 以及大写的 Z - A.
- 8）求出1 - 1/2 + 1/3 - 1/4......1/100的和
- 9）求 1 + （1 + 2）+（1 + 2 + 3）+（1 + 2 + 3 + 4）+....（1 + 2 +3 +...+100）的和
- 10）参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组, 输入成绩和性别，进行判断和输出信息。
- 11)买票：根据淡旺季的月份和年龄，打印票价
- 12）对学生成绩大于 60 分的，输出"合格"。低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100)
- 13）编写程序：如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止 [System.out.println("老韩问：还钱吗？y/n")
- 14）统计 3 个班成绩情况，每个班有 5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。统计三个班及格人数，每个班有 5 名同学。
- 15）1-100 以内的数求和，求出 **当和** 第一次大于 20 的**当前数** 【for + break】
- 16）实现登录验证，有 3 次机会，如果用户名为"丁真" ,密码"666"提示登录成功，否则提示还有几次机会，请使用 [for+break] 完成
- 17）打印出九九乘法表
- 数组练习
- 1）创建一个 char 类型的 26 个元素的数组，分别 放置'A'-'Z'。使用 for 循环访问所有元素并打印出来。提示：char 类型 数据运算 'A'+2 -> 'C
- 2）请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标。
- 3）编写代码 实现数组拷贝(内容复制) 将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 要求数据空间是独立的。
- 4）要求：把数组的元素内容反转。arr {11,22,33,44,55,66} ----》{66, 55,44,33,22,11}
- 5）数组扩容、添加
- 6）数组减少
- 7)冒泡排序
- 8）有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，判断数列中是否 包含此名称【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值。
- 9）已知有个升序的数组，要求插入一个元素，该数组顺序依然时升序，比如：【10，12，45，90】，添加23后，数组为【10，12，23，45，90】
- 10）随机生成10个整数（1-100的范围）保存到数组，并倒序打印以及求平均值、求最大值和最大值的下标，并查找里面是否有8
- 11）选择题
- 杨辉三角
- 打印空心金字塔
- 打印空心菱形
- 递归练习
Java练习题
编程实现
1）某人有100000元，每经过一次路口，需要交费，规则如下：当现金>50000时，每次交5%；当现金<= 50000时，每次交1000。编程计算该人可以经过多少次路口，要求：使用while + break 方式完成。
public class one{
public static void mian(){
//思路分析
//定义一个变量 int count 计算经过人数
//定义一个变量 double money 初值 100000
/*根据要求，分析出三种情况
money > 50000
money >= 1000 && money <= 50000
money < 1000
*/
int count = 0;
double money = 100000;//初值
while(true){//无限循环
if(money > 50000){
money = money * (1 - 0.05);
count++;
}else if(money >= 1000 && money <= 50000){
money -= 1000;
count++;
}else if(money < 1000)//钱不够
break;
}
//退出while循环，输出count
System.out.println("100000元经过" +count +"次路口。");
}
}
2）实现判断一个整数，属于那个范围：大于0；小于0；等于0；
public class two{
public static void mian(){
//思路分析
//使用scanner对象输入一个整型
//定义一个整数，使用if - else 判断
Scanner myscanner = new Scanner(System.in);
int num = myscanner.nextInt();
if(num > 0){
System.out.println(num + "大于0");
}else if(num == 0){
System.out.println(num + "等于0");
}else{
System.out.println(num + "小于0");
}
}
}
3）判断一个年份是否为闰年
public class three{
public static void mian(){
//思路分析
//使用Scanner对象输入int 型
//闰年：(1)年份能被 4 整除，但不能被 100 整除；(2)能被 400 整除
Scanner myscanner = new Scanner(System.in);
int year = myscanner.nextInt();
if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
System.out.println(year + "是闰年");
}else{
System.out.println(year + "不是闰年");
}
}
}
4）判断一个整数是否是水仙花数，所谓水仙花数是指一个三位数，其各位上数字立方和等于其本身。例如：153 = 1 * 1 * 1 + 5 * 5 *5 + 3 * 3 * 3
public class four{
public static void mian(){
//思路分析
//使用Scanner对象 输入 int num
//取个位 num % 10
//取十位 num / 10 %10
//取百位 num / 100
Scanner myscanner = new Scanner(System.in);
int num = myscanner.nextInt();
int a = num % 10;
int b = num / 10 % 10;
int c = num / 100;
int sum =0;
sum = a * a * a + b * b * b + c * c * c;
if(sum == num)
System.out.println(num + "是水仙花数");
else
System.out.println(num + "不是水仙花数");
}
}
5）看看下面代码输出什么？
public class five{
public static void mian(){
int m = 0,n = 3;
if(m > 0){
if(n > 2)
System.out.println("OK1");
else
System.out.println("OK2");
}
//分析
//m>0假直接结束if循环，所以没有输出
}
}
6）输出1 - 100之间的不能被5整除，每五个一行。
public class six{
public static void mian(){
//思路分析
//for循环1 - 100
//过滤判断 不能被5整除的输出
//定义一个变量计数 int count ,五个一行（count%5==0）
int count = 0;
for(int i = 1;i <= 100;i++){
if(i % 5 != 0){
System.out.print(i + "\t");//使用print不换行
count++;
if(count % 5 == 0)
System.out.println();//换行
}
}
}
}
7）输出小写的a - z 以及大写的 Z - A.
public class seven{
public static void mian(){
//思路分析
//26个字母
//一个循环 从 a - z
//一个循环 从 A - Z
for(char i = 'a';i <= 'z';i++)
System.out.print(i + "\t");
System.out.println();
for(char i = 'Z';i >= 'A';i--)
System.out.print(i + "\t");
}
}
8）求出1 - 1/2 + 1/3 - 1/4…1/100的和
public class egiht{
public static void mian(){
//思路分析1
//循环1 - 100
//求和 int sum = 0;
//符号变换 sign = - sign
//定义一个变量 a 接收每一个变化的项
double sum = 0;
int sign = 1;//第一项保持为正
double a = 1;//首项
for(int i = 1;i <= 100;i++){
a = sign * (1.0/i);
sign = - sign;//变号
sum += a;
}
System.out.print("和为" + sum);
}
}
public class eight{
public static void mian(){
//思路分析2
/*一共100数， 分子为1，分母从1 - 100
当分母为奇数时，前面时+，是偶数时，前面是-
我们可以使用for+判断即可完成
把结果存放到double sum
隐藏陷阱，分子写成1.0才能得到精确值
*/
double sum = 0;
for(int i = 1;i <= 100;i++){
if(i % 2 != 0)//奇数
sum += 1.0 / i;
else
sum -= 1.0 / i;
}
System.out.print(sum);
}
}
9）求 1 + （1 + 2）+（1 + 2 + 3）+（1 + 2 + 3 + 4）+…（1 + 2 +3 +…+100）的和
public class nine{
public static void mian(){
//思路分析
//for循环 1 - 100;
//定义一个变量 int num 每项的和 初值为0 num = num + i
//定义一个变量 int sum 求总和 初值为0 sum = sum + num
int num = 0;
int sum = 0;
for(int i = 1;i <= 100;i++){
//从1到当前值的和
num += i;
//求总和
sum += num;
}
System.out.print(sum);
}
}
public class nine{
public static void mian(){
//思路分析
/*一共100相加
每一项数字逐渐增加
双层循环
i可以表示第几项，同时也是当前项的最后一个数
sum记录累加和。
*/
double sum = 0;
for(int i = 1;i <= 100;i++){
for(int j = 1;j <= i;j++){//循环1-i
sum += j;
}
}
System.out.print(sum);
}
}
10）参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组, 输入成绩和性别，进行判断和输出信息。
//思路分析
//定义一个变量记录成绩 double score
//定义一个变量记录性别 char gender
//使用Scanner 对象 接收输入的成绩和性别
//if -else -if --else 输出提示信息
public class rhombus{
public static void mian(){
Scanner scanner = new Scanner(System.in);
double score = scanner.nextDouble();
char gender = scanner.next().charAt(0);//取一个字符
if(score >= 0.0 && score <= 10.0){
if(score > 8.0){
if("女".equals(gender))
System.out.println("恭喜您进入女子组决赛");
else if("男".equals(gender))
System.out.println("恭喜您进入男子组决赛");
else
System.out.println("您的比赛成绩优秀可以进入决赛，请输入正确性别 男 or 女！");
}else
System.out.println("很遗憾，您的成绩偏低被淘汰");
}else
System.out.println("请输入正确成绩 0-10");
}
}
11)买票：根据淡旺季的月份和年龄，打印票价
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a7FJd45P-1644720902911)(C:\Users\24989\AppData\Roaming\Typora\typora-user-images\image-20220131112003686.png)]
public class rhombus{
public static void mian(){
//思路分析
//定义一个变量记录月份 int month
//定义一个变量记录年龄 int year
//定义一个变量记录money double money
//使用Scanner 对象 接收输入的月份和年龄
//4-10月是旺季，其余是淡季，使用if -- else -if -- else判断年龄
Scanner scanner = new Scanner(System.in);
int month = scanner.nextInt();
int year = scanner.nextInt();
double money = 0;
if(month >= 0 && month <= 12) {
if (month >= 4 && month <= 10) {
System.out.println("旺季\t");
if(year >= 1 && year <= 120) {
if (year > 60) {
money = 60 / 3.0;
} else if (year >= 18 && year <= 60)
money = 60;
else
money = 60 / 2.0;
}else{
System.out.println("请输入正确年龄 1 - 120");;
}
} else {
System.out.println("淡季");
if (month >= 4 && month <= 10) {
if (year >= 18 && year <= 60)
money = 40;
else
money = 20;
}else{
System.out.println("请输入正确年龄 1 - 120");;
}
}
System.out.println("花费了 " + "\t" + money);
}else
System.out.println("请输入正确月份 1-12");
}
}
12）对学生成绩大于 60 分的，输出"合格"。低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100)
提示 switch成绩/60
public class StudentScore{
public static void mian(){
//思路分析
//使用Scanner 对象输入
//定义一个变量 int score 接收输入的成绩
//普通switch是
// switch(score / 10){//输入成绩不能大于100通过取十位得到对应数字
// case 10:
// case 9:
// case 8:
// case 7:
// case 6:
// System.out.println("合格");
// break;
// default:
// System.out.println("不合格");
// break;
// }
//score / 60 结果为1为大于60，结果为0为小于60
Scanner scanner = new Scanner(System.in);
int score = scanner.nextInt();
switch(score / 60){
case 1:
System.out.println("合格");
break;
case 0:
System.out.println("不合格");
break;
}
}
}
13）编写程序：如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止 [System.out.println(“老韩问：还钱吗？y/n”)
public class StudentScore{
public static void mian(){
/* 思路分析
* 定义一个变量接收输入的字符
* do{}while()先问后答
* */
Scanner myscanner = new Scanner(System.in);
char answer;
do{
System.out.println("老韩使出五连鞭~");
System.out.println("老韩问：还钱吗？y/n");
answer = myscanner.next().charAt(0);
System.out.println("它的回答是：answer= " + answer);
}while(answer != 'y');
}
}
14）统计 3 个班成绩情况，每个班有 5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。统计三个班及格人数，每个班有 5 名同学。
public class StudentScore{
public static void mian(){
* 定义一个变量sum用来算各个班的总分
* 定义一个变量num用来算输入的同学成绩
* 定义一个变量totalsum 记录所有班级的成绩
* 1)计算每个班的成绩求平均分---内循环
* 2）计算三个班的成绩求平均分---外循环
* 3）if判断 num >=60为及格 定义一个变量int count，记录及格人数
* */
Scanner myscanner = new Scanner(System.in);
double sum;
double totalsum = 0;
int count = 0;
double num = 0;
for(int i = 1;i <= 3;i++){
sum = 0;
for(int j = 1;j <= 5;j++){
num = myscanner.nextDouble();
if(num >= 60)
count++;
sum += num;
totalsum += sum;
}
System.out.println(i + "班的平均分为" + sum/5.0);
}
System.out.println("所有班的平均分为" + totalsum/3.0 + "及格人数为" + count);
}
}
15）1-100 以内的数求和，求出 当和 第一次大于 20 的当前数 【for + break】
public class StudentScore{
public static void mian(){
/* 思路分析
* 循环1-100
* 定义一个变量求和 int sum ;
* 当sum > 20 输出当前i,跳出循环
* */
int sum = 0;
for(int i = 1;i <= 100;i++){
sum += i;
if(sum > 20){
System.out.println("当前i为" + i + "和为" + sum);
break;
}
}
}
}
16）实现登录验证，有 3 次机会，如果用户名为"丁真" ,密码"666"提示登录成功，否则提示还有几次机会，请使用 [for+break] 完成
public class StudentScore{
public static void mian(){
/* 使用Scanner对象输入
* 定义一个变量String name 记录输入的用户名 --字符串使用scanner.next();
* 定义一个变量string password 记录密码
* 三次循环，循环输入进行判断
* 字符串判断使用equals进行判断，提示相应内容
* */
Scanner scanner = new Scanner(System.in);
String name;
String password;
int i;
for(i = 3;i > 0;i--){
name = scanner.next();
password = scanner.next();
if("丁真".equals(name) && "666".equals(password)){
System.out.println("恭喜您登录成功");
break;
}else
System.out.println("您还有" + (i-1) + "次机会");
}
}
}
17）打印出九九乘法表
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-siNJuMKz-1644720902913)(C:\Users\24989\AppData\Roaming\Typora\typora-user-images\image-20220201141318135.png)]
public class rhombus{
public static void mian(){
//外循环从1-9,内循环从1-i
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i + "*" + j + "=" + (i*j)+ "\t");
}
System.out.println();
}
}
}
数组练习
1）创建一个 char 类型的 26 个元素的数组，分别 放置’A’-‘Z’。使用 for 循环访问所有元素并打印出来。提示：char 类型 数据运算 ‘A’+2 -> 'C
public class rhombus{
public static void mian(){
char[] a = new char[26];
for(int i = 0;i < a.length;i++){
a[i] = (char)('a'+i);; //'A' + i 是 int , 需要强制转换
}
for(int i = 0;i < a.length;i++){
System.out.print(a[i]);
}
}
}
2）请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标。
public class rhombus{
public static void mian(){
/*
定义一个变量保存最大值 int max = a[0],默认第一个是最大值
定义一个变量记录下标int j=0,默认是a[0]
循环判断找到最大值以后重新赋值。
*/
int[] a = {4,-1,9, 10,23};
int max = a[0];
int j = 0;
for(int i = 0;i < a.length;i++){
if(max < a[i]){
max = a[i]; //将最大值给max
j = i; //将最大值下标赋给j
}
}
System.out.println("数组的最大值是" + max + "对应的下标是" +j);
}
}
3）编写代码 实现数组拷贝(内容复制) 将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 要求数据空间是独立的。
public class rhombus{
public static void mian(){
int[] arr1 = {10,20,30};
int[] arr2 = new int[arr1.length];
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];//依次赋值
}
System.out.println("输出arr1数组");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
System.out.println("\n输出arr2数组");
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i] + "\t");
}
}
}
4）要求：把数组的元素内容反转。arr {11,22,33,44,55,66} ----》{66, 55,44,33,22,11}
public class rhombus{
public static void mian(){
/*
方法一：
使用一个数组
规律：第一个 和 最后一个 交换
第二个 和 倒数第二个 交换
第三个 和 倒数第三个 交换 交换了arr.length/2
第i个 和 第n-1-i 进行交换，使用中间变量
方法二：
使用两个数组将第一个数组内容逆序存放到第二个数组，然后再将第一个数组指向第二个数组的地址
*/
//方法1：
// int[] arr = {11,22,33,44,55,66};
// int n = arr.length;//数组长度
// int temp = 0;//中间变量
// for(int i = 0;i < n/2;i++){
// temp = arr[i];
// arr[i] = arr[n - 1 - i];
// arr[n - 1 - i] = temp;
// }
// for(int i = 0;i < n;i++)
// System.out.print(arr[i] + "\t");
//方法二：
int[] arr1 = {11,22,33,44,55,66};
int[] arr2 = new int[6];
int n = 0;//第二个数组
for (int i = arr1.length - 1;i >= 0;i--) {
arr2[n] = arr1[i];
n++;
}
arr1 = arr2;//将第二个数组的地址给了第一个数组
for(int j = 0;j < arr1.length;j++)
System.out.print(arr1[j] + "\t");
}
}
5）数组扩容、添加
要求：实现动态的给数组添加元素效果，实现对数组扩容。
-1) 原始数组使用静态分配 int[] arr = {1,2,3}
-2) 增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
-3) 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
public class rhombus{
public static void mian(){
/*思路分析
定义一个原始数组int[] arr = {1,2,3}
定义一个扩容数组int[] arrNew = new int[arr.length+1];
定义一个变量char answer 接收输入的y/n
定义一个变量 int num 接收新加的数
将arr的内容依次给数组arrNew,将输入的num的值赋给arrNew的最后一个，然后将arr指向arrNew,循环输入arr数组
输入answer，判断，n时退出循环
使用Scanner对象接收answer
*/
int[] arr = {1,2,3};
Scanner scanner = new Scanner(System.in);
char answer;
do{
int[] arrNew = new int[arr.length+1];//扩容
for(int i = 0;i < arr.length;i++)//将arr数组的内容赋值给arrNew
arrNew[i] = arr[i];
System.out.println("请输入你要添加的元素");
arrNew[arrNew.length-1] = scanner.nextInt();//输出新数
//让 arr 指向 arrNew,
arr = arrNew;
//输出 arr 看看效果
System.out.println("====arr 扩容后元素情况====");
for(int i = 0; i < arr.length; i++)
System.out.print(arr[i] + "\t");
System.out.println("请输入你选择是否要添加： y/n ?");
answer = scanner.next().charAt(0);
if(answer == 'n')//循环结束条件,跳出循环
break;
}while(true);
System.out.println("你退出了添加...");
}
}
6）数组减少
有一个数组 {1， 2， 3， 4， 5}， 可以将该数组进行缩减，提示用户是否继续缩减，每次缩减最后那个元素。当只剩下最后一个元素，提示，不能再缩减。
public class rhombus{
public static void mian(){
/*思路分析
定义一个原始数组int[] arr = {1,2,3,4,5}
定义一个扩容数组int[] arrNew = new int[arr.length-1];
定义一个变量char answer 接收输入的y/n
将arr的内容-1依次给数组arrNew,然后将arr指向arrNew,循环输出arr数组
输入answer，判断，answer==n || arr.length==1时,不继续缩减或者只有最后一个元素，退出循环
使用Scanner对象接收answer
*/
int[] arr = {1,2,3,4,5};
Scanner scanner = new Scanner(System.in);
char answer;
do{
int[] arrNew = new int[arr.length-1];//缩减
for(int i = 0;i < arr.length - 1;i++)//将arr数组-1的内容赋值给arrNew
arrNew[i] = arr[i];
//让 arr 指向 arrNew,
arr = arrNew;
//输出 arr 看看效果
System.out.println("====arr 缩减后元素情况====");
for(int i = 0; i < arr.length; i++)
System.out.print(arr[i] + "\t");
System.out.println("请输入你选择是否要缩减： y/n ?");
answer = scanner.next().charAt(0);
if(answer == 'n' || arr.length == 1)//循环结束条件,跳出循环
break;
}while(true);
System.out.println("====arr 缩减后元素情况====");
for(int i = 0; i < arr.length; i++)
System.out.print(arr[i] + "\t");
System.out.println("你退出了添加...");
}
}
7)冒泡排序
public class rhombus{
public static void mian(){
/*冒泡排序 从小到大*/
/*思路分析
五个元素
进行四轮，第一轮 排序四次
第二轮 排序三次
第三轮 排序二次
第四轮 排序一次
n - 1 n-1-i 冒泡交换
定义一个变量int temp 交换
*/
int n = 5;//数组个数
int[] a = {24,69,80,57,13};
int temp;
for(int i = 1;i <= n - 1;i++){
for(int j = 1;j <= n - 1 - i;j++){
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
for(int i = 1;i <= n - 1;i++){
System.out.print(a[i] + "\t");
}
}
}
8）有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，判断数列中是否 包含此名称【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值。
public class rhombus{
public static void mian(){
/*思路分析
定义一个变量string result 接收输入的名称
定义字符串数组string[] name;
定义一个变量int index 标记循环中如果相等则把下标值记录，否则不变
循环结束index不变时，则找到，否则，没有找到
使用Scanner对象接收result
* */
String[] name ={"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
Scanner myscanner = new Scanner(System.in);
String result = myscanner.next();
int index = -1;
for(int i = 0;i < name.length;i++){
if(result.equals(name[i])){
index = i;
break;
}
}
if(index != -1){
System.out.println(result + "找到了,下坐标为" + index);
}else
System.out.println("抱歉没有找到！");
}
}
9）已知有个升序的数组，要求插入一个元素，该数组顺序依然时升序，比如：【10，12，45，90】，添加23后，数组为【10，12，23，45，90】
//笨方法
public class rhombus{
public static void mian(){
/*思路分析
使用Scanner对象接收输入的数int num
创建一个扩容数组，将原数组元素和增加的数加入，将arr1指向arr2实现数组扩容
进行从小到大的排序
输出验证
*/
Scanner scanner = new Scanner(System.in);
int[] arr1 = {10,12,45,90};
int[] arr2 = new int[arr1.length + 1];//使用arr2数组扩容
int num = scanner.nextInt();
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
arr2[arr1.length] = num;//将新数加入数组末尾
//将arr1指向arr2实现数组扩容
arr1 = arr2;
System.out.println("输出添加以后的arr1数组");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
//对数组进行从小到大排序
int temp;
for (int i = 0; i < arr1.length - 1; i++) {
if(arr1[i] > arr1[i + 1]){//大于则交换
temp = arr1[i];
arr1[i] = arr1[i + 1];
arr1[i + 1] = temp;
}
}
System.out.println("\n输出排序以后的arr1数组");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
}
}
public class ran {
public static void main(String[] args){
/*已知有个升序的数组，要求插入一个元素，该数组顺序依然时升序，
比如：【10，12，45，90】，添加23后，数组为【10，12，23，45，90】
思路分析
1）定位
遍历循环如果insertnum <= a[i],则index = i;
极端情况下，如果没有找到，则说明新插入的数比arr数组中的都大，index=arr.length;
2）使用扩容数组，如果index = arr.length 时，直接拷贝arr数组到arrNew数组，跳过index位置的数,最后再给空着的位置index赋值，arr指向arrNew实现数组arr扩容
*/
Scanner scanner = new Scanner(System.in);
int arr[] = {10,12,45,90};
int arrNew[] = new int[arr.length + 1];//扩容数组
int insertNum = scanner.nextInt();//插入的新数
int index = -1;//记录下标
for (int i = 0; i < arr.length; i++) {
if(insertNum <= arr[i]){
index = i;
break;
}
}
if(index == -1){//如果是最大的，则index=arr.length
index = arr.length;
}
//扩容,i是arrNew下标，j是arr下标,拷贝arr数组到arrNew数组，跳过index位置的数
int j = 0;
for (int i = 0; i < arrNew.length; i++) {
if(i == index) //跳过index位置的数
continue;
arrNew[i] = arr[j++];
}
arrNew[index] = insertNum;
arr = arrNew;//
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
10）随机生成10个整数（1-100的范围）保存到数组，并倒序打印以及求平均值、求最大值和最大值的下标，并查找里面是否有8
public class rhombus{
public static void mian(){
/*思路分析
一个循环输入随机数保存到数组
一个循环倒序输出
一个循环记录最大值和最大值下标，判断是否有8*/
Scanner scanner = new Scanner(System.in);
Random random = new Random();
int arr[] = new int[10];
double avg = 0;//平均值
int indexmax = 0;//最大值下标
int maxnum = arr[0]; //最大值
int index = -1; //记录是否有8，默认没有index = -1
for (int i = 0; i < arr.length; i++) {//随机数保存到数组
arr[i] = random.nextInt(100)+1;
avg += arr[i];
}
for (int i = arr.length -1; i >= 0; i--) {//倒序输出
System.out.print(arr[i] + "\t");
if(i % 10 == 0)//十个一换行
System.out.println();
}
for (int i = 0; i < arr.length; i++) {//判断8，最大值
if(maxnum < arr[i]){
indexmax = i;
maxnum = arr[i];
}
if(arr[i] == 8)
index = i;
}
System.out.println("平均值为 " + avg/10.0);
System.out.println("最大值为 " + maxnum + " 最大值下标为 " + indexmax);
if(index == -1)
System.out.println("数组没有8");
else
System.out.println("数组有8");
}
}
11）选择题
杨辉三角
public class rhombus{
public static void mian(){
/*
* 杨辉三角
* 1 规律：每行输出行数个数,行首和行尾都为1,
* 1 1 ：例如2=1+1，当前数=上一行对应列的数+上一行前一列的数
* 1 2 1
* 1 3 3 1
* 1 4 6 4 1
* 使用二维数组int a[][]，需要根据行数进行数组扩容，
* 定义一个变量 int hang代表行数
* 外循环从0 - hang，行首行尾为1，
* 内循环从 0 - i，列扩充 给每个一维数组(行) 开空间 yangHui[i] = new int[i+1];
*
* */
int hang = 4;
int[][] a = new int[hang][];
int i;//行数
for(i = 0;i < a.length;i++){//遍历行
a[i] = new int[i+1];//每一行的列a[i]扩充成a[i+1]
for(int j = 0;j < a[i].length;j++){//06
if(j == 0 || j == a[i].length - 1)//行首行尾（可以理解为：二维数组对角线i == j）
a[i][j] = 1;
else
a[i][j] = a[i-1][j] + a[i-1][j-1];
}
}
//输出验证
for(i = 0;i < a.length;i++){
for(int j = 0;j < a[i].length;j++)
System.out.print(a[i][j] + "\t");
System.out.println();
}
}
}
打印空心金字塔
/*化繁为简
*****
*****
*****
*****
*****
五行五列
for(int i = 1;i <= 5;i++){
for (int j = 1; j <= 5 ; j++) {
System.out.print("*");//不换行
}
System.out.println("*");//每五个换行
}
* 第一行输出第一个
** 第二行输出第二个
*** ..
**** ..
***** 第五行输出第五个
下三角
for(int i = 1;i <= 5;i++){
for(int j = 1;j <= i;j++)
System.out.print("*");//不换行
System.out.println();//每五个换行
}
* 第一行输出1个 前面有3个空格
*** 第一行输出3个 前面有2个空格
***** 第三行输出5个 前面有1个空格 空格 总行数 - 当前行数
******* 第四行输出7个 前面有0个空格 输出 2 * 当前行数 -1
int sumline = 4;//总行数
int i;//当前行
int k;//记录空格
int j;//记录*
for(i = 1;i <= sumline;i++){
for(k = 1;k <= sumline - i;k++)
System.out.print(" ");
for(j = 1;j <= 2 * i - 1;j++)
System.out.print("*");
System.out.println();//换行
}
* 第一行输出1个 前面有3个空格，中间0个空格
* * 第一行输出2个 前面有2个空格，中间1个空格
* * 第三行输出2个 前面有1个空格，中间3个空格
******* 第四行输出7个 前面有0个空格，中间0个空格 输出 2 * 当前行数 -1
1）前面的空格 总行数 - 当前行数
2）输出*中加上判断
第一行是1个，最好一行2 * 当前行数 - 1
对于每行的行首行尾输出*，中间为空格
3）中间的空格 2 * 当前行数 - 3
int sumline = 4;//总行数
int i;//当前行
int k;//记录空格
int j;//记录*
for(i = 1;i <= sumline;i++){
for(k = 1;k <= sumline - i;k++)//前空格
System.out.print(" ");
for(j = 1;j <= 2 * i - 1;j++){//输出*
if(j == 1 || i == sumline || j == 2 * i - 1)
//第一行(i==1,可不写因为当i=1是对应的j=1循环一次输出一个*)和最后一行(i==sumline)
//每行的行首(j==1),行尾(j==2*i-1)
System.out.print("*");
else //其余情况输出空格1
System.out.print(" ");
}
System.out.println();//换行
}
*/
public class pyramid{
public static void mian(){
int sumline = 4;//总行数
int i;//当前行
int k;//记录空格
int j;//记录*
for(i = 1;i <= sumline;i++){
for(k = 1;k <= sumline - i;k++)//前空格
System.out.print(" ");
for(j = 1;j <= 2 * i - 1;j++){//输出*
if(j == 1 || i == sumline || j == 2 * i - 1)
//第一行(i==1,可不写因为当i=1是对应的j=1循环一次输出一个*)和最后一行(i==sumline)
//每行的行首(j==1),行尾(j==2*i-1)
System.out.print("*");
else //其余情况输出空格1
System.out.print(" ");
}
System.out.println();//换行
}
}
}
打印空心菱形
/*
化繁为简
1.实心菱形
1)上三角
* 第一行输出1个 前面空格3个
*** 第二行输出3个 前面空格2个
***** 第三行输出5个 前面空格1个
******* 第三行输出7个 前面空格0个
一个循环输出空格 总行数 - 当前行数
一个循环输出* 2 * 当前行数 - 1
int sumline = 4;
int i;//行数
int k;//空格
int j;//*
for(i = 1;i <= sumline;i++){//行数
for(k = 1;k <= sumline - i;k++)//输出空格
System.out.print(" ");
for(j = 1;j <= 2 * i - 1;j++)//输出*
System.out.print("*");
System.out.println("");//换行
}
2)下三角
***** 第一行输出5个 前面空格1个
*** 第二行输出3个 前面空格2个
* 第三个输出1个 前面空格3个
一个循环输出空格 当前行数
一个循环输出* 2 * 当前行数 - 1
int lastline = sumline -1;//下三角
for(i = lastline;i >= 1;i--){//行数
for(k = lastline;k >= i;k--)//空格 因为是从1到lastline 空格数=行数
System.out.print(" ");
for(j = 1;j <= 2 * i - 1;j++)//输出*
System.out.print("*");
System.out.println("");//换行
}
2.空心菱形
1)上三角
* 第一行输出1个 前面空格3个 中间空格0个
* * 第二行输出3个 前面空格2个 中间空格1个
* * 第三行输出5个 前面空格1个 中间空格3个
* * 第三行输出7个 前面空格0个 中间空格5个
一个循环输出空格 总行数 - 当前行数
一个循环输出*
第一行输出一个* 判断 行数 == 1
其他行输出首位一个* 首 末尾列==2*i-
输出中间空格
int sumline = 4;//总行数
int i;//当前行
int k;//记录空格
int j;//记录*
for(i = 1;i <= sumline;i++){
for(k = 1;k <= sumline - i;k++)//前空格
System.out.print(" ");
for(j = 1;j <= 2 * i - 1;j++){//输出*
if(j == 1 || j == 2 * i - 1)
//第一行(i==1,可不写因为当i=1是对应的j=1循环一次输出一个*)
//每行的行首(j==1),行尾(j==2*i-1)
System.out.print("*");
else //其余情况输出空格1
System.out.print(" ");
}
System.out.println();//换行
}
2)下三角
* * 第一行输出5个 前面空格1个 中间空格3个
* * 第二行输出3个 前面空格2个 中间空格1个
* 第三个输出1个 前面空格3个 中间空格0个
输出空格 i个
输出中间2*i-1个，行首和行尾是*，其余为空格
int lastline = sumline -1;//下三角
for(i = lastline;i >= 1;i--){//行数
for(k = lastline;k >= i;k--)//空格 因为是从1到lastline 空格数=行数
System.out.print(" ");
for(int j = 1;j <= 2 * i - 1;j++){//输出*
//每行的行首j == 1 行尾j == 2*i-1
if(j == 1 || j == 2 * i -1)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println("");//换行
}
*/
public class rhombus{
public static void mian(){
//上三角
int sumline = 4;//总行数
int i;//当前行
int k;//记录空格
int j;//记录*
for(i = 1;i <= sumline;i++){
for(k = 1;k <= sumline - i;k++)//前空格
System.out.print(" ");
for(j = 1;j <= 2 * i - 1;j++){//输出*
if(j == 1 || j == 2 * i - 1)
//第一行(i==1,可不写因为当i=1是对应的j=1循环一次输出一个*)
//每行的行首(j==1),行尾(j==2*i-1)
System.out.print("*");
else //其余情况输出空格1
System.out.print(" ");
}
System.out.println();//换行
}
//下三角
int lastline = sumline -1;//下三角
for(i = lastline;i >= 1;i--){//行数
for(k = lastline;k >= i;k--)//空格 因为是从1到lastline 空格数=行数
System.out.print(" ");
for(j = 1;j <= 2 * i - 1;j++){//输出*
//每行的行首j == 1 行尾j == 2*i-1
if(j == 1 || j == 2 * i -1)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println("");//换行
}
}
}
递归练习
老鼠走迷宫
public class Test {
public static void main(String[] args) {
/*老鼠找出迷宫
数组a[8][7]
初始化时；0为可以走，1为障碍
将第一行第一列最后一行最后一列 赋值为 1
将a[3][1]和a[3][2] 赋值为1 其余为0
*/
int a[][] = new int[8][7];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if(i == 0 || j == 0 || i == a.length - 1 || j == a[i].length - 1){
a[i][j] = 1;
}else
a[i][j] = 0;
a[3][1] = 1;
a[3][2] = 1;
}
}
System.out.println("==============输出当前地图=============");
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + "\t");
}
System.out.println();
}
Way way = new Way();
// a[2][2] = 1; //验证回溯问题
way.findWay(a,2,1);
System.out.println("==============输出寻找路线=============");
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + "\t");
}
System.out.println();
}
}
}
class Way{
/*findWay寻找路线
a数组，i行，j列 ａ［ｉ］［ｊ］为初始化位置
1 障碍 0 可以走 2 正在走 3 走过不能走通
路径规则为：下－＞右－＞上－＞左
终点ａ[6][5]＝２时到终点，否则继续找 找到返回true，否则返回false。
* */
public boolean findWay(int a[][],int i,int j){
if (a[6][5] == 2){//输入的位置为终点，到达终点
return true;
}else {
if (a[i][j] == 0) {//0可以走
a[i][j] = 2; //设置为2正在走
//下－＞右－＞上－＞左
if (findWay(a, i + 1, j)) {//下
return true;
} else if (findWay(a, i, j + 1)) {//右
return true;
} else if (findWay(a, i - 1, j)) {//上
return true;
} else if (findWay(a, i, j - 1)) {//左
return true;
} else {
a[i][j] = 3;
return false;
}
}else //a[i][j] = 1,2,3都不可以走
return false;
}
}
}
汉诺塔传说
汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子， 在一根柱子上从下往上按照大小顺序摞着 64 片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一 根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
public class Test {
public static void main(String[] args) {
/*汉落塔
思路分析：分为最下面一个和上面的两部分
定义一个变量记录所有盘子个数int num
定义变量三个塔ａ，ｂ，ｃ
*/
Way way = new Way();
way.tool(5,'A','B','C');
}
}
class Way{
/*num 等于1时直接从ａ到ｃ 利用递归*/
public void tool(int num,char a,char b,char c){
if(num == 1){
System.out.println(a + " -> " + c);
}else {
//分为两部分最下面一个和最上面所有的(num - 1)
//先移动最上面所有的从a到b,借助c
tool(num - 1, a, c, b);
//后移动最下面从a到c
System.out.println(a + " -> " + c);
//再将b盘上的移动到c,借助a
tool(num - 1, b, c, a);
}
}
}
八皇后
八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于 1848 年 提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同 一斜线上，问有多少种摆法。 
public class Test {
/*思路分析
数组arr存放每行的列下标，n为行(第n个皇后)
定义一个方法print进行解法数count++，输出
定义一个方法check检查皇后个数是否满足==max，
满足则调用print输出
不满足则进行循环将i存放到arr[n]位置中再调用judge()方法判断是否在同一列，同一行，同一斜线，如果位置合法则判断n+1(下一行）的情况
如果位置不合适则i++（下一列）继续存放到arr[n]中再判断
* */
//定义一个max表示一共有多少个皇后
int max=8;
//定义数组Array，保存皇后放置位置的结果，比如arr={0,4,7,5,2,6,1,3}
int []arr=new int[max];
static int count=0;
public static void main(String[] args) {
Test queen8=new Test();
queen8.check(0);
System.out.printf("一共有%d种解法",count);
}
//编写一个方法，放置第n个皇后
private void check(int n){
if(n==max){//n=8，其实8个皇后就已经放好
print();
return;
}
else{
//依次放入皇后，判断是否有冲突
for (int i = 0; i < max; i++) {
//先把这个皇后放到这一行的第一列
arr[n]=i;
//判断当前放置第n个皇后到第i列时，是否冲突
if(judge(n)){
//接着放第i+1个皇后，即开始递归
check(n+1);
}
//如果冲突就继续执行arr[n]=i;即将第n个皇后，放置到本行的后移的一个位置
}
}
}
//查看当我们放置第n个皇后，就去检测该皇后是否和前面已经摆放的皇后冲突
private boolean judge(int n)
{
for (int i = 0; i < n; i++) {
//说明：
//1.arr[i]==arr[n]表示判断第n个皇后是否和前面n-1个皇后在同一列
//2.Math.abs(n-i)==Math.abs(arr[n]-arr[i])表示判断第n个皇后是否和第i个皇后在同一斜线上
//3.判断是否在同一行，没有必要，n每次都在递增
if(arr[i]==arr[n]||Math.abs(n-i)==Math.abs(arr[n]-arr[i]))
{
return false;
}
}
return true;
}
//写一个方法，可以将皇后摆放的位置输出
private void print()
{
count++;
for (int i = 0; i < arr.length; i++) {
System.out.printf(arr[i]+" ");
}
System.out.println();
}
}
斐波那契数列
public class Test {
public static void main(String[] args) {
int num = 0;
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
tool tool = new tool();
num = tool.fibonacci(n);
if(n != -1)
System.out.println("第" + n + "天有" + num + "个桃子");
}
}
class tool{
//斐波那契数 1，1，2，3，5，8，13给你一个整数n,求出它的值是多少
/*思路分析
n = 1 ,斐波那契 是1
n = 2 ,斐波那契 是1
n = 3 , 斐波那契 是3
使用递归思路
*/
public int fibonacci(int n){
if(n >= 1) {//斐波那契数列为>=1的整数
if (n == 1 || n == 2) {
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}else{
System.out.println("请输入正确数字");
return -1;
}
}
}
猴子吃桃
public class Test {
public static void main(String[] args) {
int num = 0;
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
tool tool = new tool();
num = tool.peach(n);
System.out.println(num);
}
}
class tool{
/*
猴子吃桃问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃一个！
以后每天猴子都吃其中的一半，然后再多吃一个，当到第十天想再吃时（即还没吃）
发现只有一个桃子了。问题：最初共多少个桃子？
思路分析 逆推法
day = 10 只有一个桃子
day = 9 有 (day10 + 1 )*2个桃子
----规律，假设day = 9时，有桃子sum个，平分两个a = sum/2, 吃了a + 1个,这个1是从一个a中取的
a = sum / 2;//对day9时吃一半
sum = a + a;
= [(a-1)+1] + a; a-1是剩下的桃子数量也就是day10的总数， a+1是day9吃的数量
= [(a-1)+1] + [(a-1)+1];
= [(a-1)+1] * 2;
= [ (day10) +1 ]*2
day = 8 有（day9 + 1) *2个桃子
递归 ---规律 当天的桃子 = （后一天的桃子 + 1 ） * 2
*/
public int peach(int day){
if(day == 10){//第十天一个桃子
return 1;
}else if(day >= 1 && day <= 9){
return (peach(day + 1) + 1) * 2;
}else {
System.out.println("请输入1-10的数字");
return -1;
}
}
}
17万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
