文章目录
- 1、题目：两数之和
- 2、题目：输出所有水仙花数
- 3、题目：输入两个数m, n 求最大公约数和最小公倍数
- 4、题目：找出100以内所有的素数（质数）？100000以内呢？
- 5、题目：使用二维数组打印一个10行杨辉三角
- 6、题目：评委打分
- 7、题目：创建一个长度为6的int型数组，要求数组元素的值都在1-30之间。且是随机赋值，且是随机赋值。同时，要求元素的值各不相同
- 8、题目：回形数
- 9、题目：数组的扩容
- 10、题目：数组的缩容
- 11、题目：线性查找
- 12、题目：二分查找
- 13、题目：冒泡排序
- 14、题目：Arrays库的使用
- 15、题目：求数组的最大子序列和
- 16、题目：OOP小练习
- 17、题目：对象数组
- 18、题目：递归函数应用
- 19、题目：不死神兔
- 21、题目：
- 22、题目：
1、题目：两数之和
题目描述：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例：
输入：nums = [3,2,4], target = 6
输出：[1,2]
题目解答
方法一：暴力枚举
class Solution {
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (nums[i] + nums[j] == target) {
return new int[]{i, j};
}
}
}
return new int[0];
}
}
方法二：哈希表
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
for (int i = 0; i < nums.length; ++i) {
if (hashtable.containsKey(target - nums[i])) {
return new int[]{hashtable.get(target - nums[i]), i};
}
hashtable.put(nums[i], i);
}
return new int[0];
}
}
2、题目：输出所有水仙花数
// 输出所有水仙花数，各个位数的数字立方和等于其本身
// 153 = 1*1*1 + 3*3*3 + 5*5*5
for (int i = 100; i < 1000; i++) {
int ge = i % 10;
int shi = (i / 10) % 10;
int bai = i / 100;
if (i == bai * bai * bai + ge * ge * ge + shi * shi * shi) {
System.out.println(i);
}
}
3、题目：输入两个数m, n 求最大公约数和最小公倍数
//最大公约数
int m = 12;
int n = 20;
int min = (m > n) ? m : n;
for (int i = min; i >= 1; i--) {
if (m % i == 0 && n % i == 0) {
System.out.println("最大公倍数：" + i);
break;
}
}
//最小公倍数
int max = (m > n) ? m : n;
for (int i = max; i < m * n; i++) {
if (i % m == 0 && i % n == 0) {
System.out.println("最小公约数：" + i);
break;
}
}
4、题目：找出100以内所有的素数（质数）？100000以内呢？
方法一：
// 找出100以内所有的素数（质数）？100000以内呢？
//什么是质数？ 除了1和它本身能整除的自然数。例如：2、3、5、7、11、13、17……
for (int i = 2; i < 100; i++) {
//记录i的约束的个数（从2开始，到i-1为止）
int number = 0;
for (int j = 2; j < i; j++) {
if (i%j==0){
number++;
}
}
if (number==0){
System.out.println(i);
}
}
方法二：
// 找出100以内所有的素数（质数）？100000以内呢？
//什么是质数？ 除了1和它本身能整除的自然数。例如：2、3、5、7、11、13、17……
//标记
boolean isFlag = true;
for (int i = 2; i < 100; i++) {
for (int j = 2; j < i; j++) {
if (i%j==0){
isFlag=false;
}
}
if (isFlag==true){
System.out.println(i);
}
// 重置标记
isFlag = true;
}
100000以内的质数个数，体会不同的算法实现，其性能差别。
方式一：
// 找出100以内所有的素数（质数）？100000以内呢？
//什么是质数？ 除了1和它本身能整除的自然数。例如：2、3、5、7、11、13、17……
//标记
boolean isFlag = true;
int count = 0; // 记录质数的个数
//获取当前系统的时间
long start = System.currentTimeMillis();
for (int i = 2; i < 100000; i++) {
for (int j = 2; j < i; j++) {
if (i % j == 0) {
isFlag = false;
}
}
if (isFlag == true) {
count++;
}
// 重置标记
isFlag = true;
}
long end = System.currentTimeMillis();
System.out.println("质数总共有：" + count);
System.out.println("花费的时间为：" + (end - start));
结果：
质数总共有：9592
花费的时间为：6726
方式二：
对方式一进行优化
//标记
boolean isFlag = true;
int count = 0; // 记录质数的个数
//获取当前系统的时间
long start = System.currentTimeMillis();
for (int i = 2; i < 100000; i++) {
for (int j = 2; j < i; j++) {
if (i % j == 0) {
isFlag = false;
break; //针对非质数有效果
}
}
if (isFlag == true) {
count++;
}
// 重置标记
isFlag = true;
}
long end = System.currentTimeMillis();
System.out.println("质数总共有：" + count);
System.out.println("花费的时间为：" + (end - start));
结果：
质数总共有：9592
花费的时间为：722
方式三：对方式二进行优化
//标记
boolean isFlag = true;
int count = 0; // 记录质数的个数
//获取当前系统的时间
long start = System.currentTimeMillis();
for (int i = 2; i < 100000; i++) {
for (int j = 2; j <= Math.sqrt(i); j++) {
if (i % j == 0) {
isFlag = false;
break; //针对非质数有效果
}
}
if (isFlag == true) {
count++;
}
// 重置标记
isFlag = true;
}
long end = System.currentTimeMillis();
System.out.println("质数总共有：" + count);
System.out.println("花费的时间为：" + (end - start));
结果：
质数总共有：9592
花费的时间为：7
5、题目：使用二维数组打印一个10行杨辉三角
package com.aiguigu.oneArray;
/**
* ClassName: YangHuiTest
* Description:
* 案例：使用二维数组打印一个10行杨辉三角
* 提示：
* 1、第一行有一个元素，第n行有第n个元素
* 2、每一行的第一个元素和最后一个元素都是1
* 3、从第三个元素开始，对于非第一个元素和最后一个元素的元素。即：
* yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
*/
public class YangHuiTest {
public static void main(String[] args) {
// 1、创建二维数组
int[][] yanghui = new int[10][];
//2、使用循环结构，初始化外层数组元素
for (int i = 0; i < yanghui.length; i++) {
yanghui[i] = new int[i + 1];
//3、给数组的元素赋值
// (1)将首末元素初始化为 1
yanghui[i][0] = yanghui[i][i] = 1;
//(2)计算杨辉三角
for (int j = 1; j < yanghui[i].length - 1; j++) {
yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j];
}
}
// 遍历二维数组
for (int i = 0; i < yanghui.length; i++) {
for (int j = 0; j < yanghui[i].length; j++) {
System.out.print(yanghui[i][j] + "\t");
}
System.out.println();
}
}
}
结果：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
6、题目：评委打分
- 案例：评委打分
- （1）在编程比赛中，10位评委为参赛选手打分，分数分别为：5, 4, 6, 8, 9, 0, 1, 2, 7, 3
- （2）求选手最后得分（去除掉以恶最低分和一个最高分之后其余8位评委打分的平均值）
package com.aiguigu.oneArray;
/**
* ClassName: OneArrayExer02
* Description:
* 案例：评委打分
* （1）在编程比赛中，10位评委为参赛选手打分，分数分别为：5, 4, 6, 8, 9, 0, 1, 2, 7, 3
* （2）求选手最后得分（去除掉以恶最低分和一个最高分之后其余8位评委打分的平均值）
*/
public class OneArrayExer02 {
public static void main(String[] args) {
int[] score = {5, 4, 6, 8, 9, 0, 1, 2, 7, 3};
int max = score[0];
int min = score[0];
int sum = 0;
for (int i = 0; i < score.length; i++) {
// 求最低分
if (score[i] < min) {
min = score[i];
}
//求最高分
if (max < score[i]) {
max = score[i];
}
// 求总和
sum += score[i];
}
System.out.println("max = " + max);
System.out.println("min = " + min);
System.out.println("sum = " + sum);
// 评委的平均分（去除最高分和一个最低分）
sum = sum - min - max;
double avgValue = sum / 8.0;
System.out.println("评委得分平均值为：" + avgValue);
}
}
7、题目：创建一个长度为6的int型数组，要求数组元素的值都在1-30之间。且是随机赋值，且是随机赋值。同时，要求元素的值各不相同
方法一：常规思路
package com.aiguigu.oneArray;
public class OneArrayExer03 {
public static void main(String[] args) {
int[] arry = new int[6];
int tmp = 0;
for (int i = 0; i < arry.length; i++) {
// 给第i个赋值
arry[i] = (int) (Math.random() * (30 - 1 + 1) + 1);
// 设置标记，表示是否重复
boolean flag = false;
while (true){
// 判断新加入元素是否重复
for (int j = 0; j < i; j++) {
if (arry[i] == arry[j]){
// 如果重复，flag变为true
flag = true;
break; // 不在判断以后的元素
}
}
// 若重复重新赋值
if (flag){
arry[i] = (int) (Math.random() * (30 - 1 + 1) + 1);
flag = false;
// 继续判断
continue;
}
break;
}
}
// 展示数组
for (int i = 0; i < arry.length; i++) {
System.out.print(arry[i]+"\t");
}
}
}
方法二：打开思维
package com.aiguigu.oneArray;
/**
* ClassName: OneArrayExer03
* Description:
* 创建一个长度为 6 的int型数组，要求数组元素的值都在1-30之间。且是随机赋值，且是随机赋值。同时，要求元素的值各不相同
*
*/
public class OneArrayExer03 {
public static void main(String[] args) {
int[] arry = new int[20];
int tmp = 0;
for (int i = 0; i < arry.length; i++) {
// 给第i个赋值
arry[i] = (int) (Math.random() * (30 - 1 + 1) + 1);
// 判断新加入元素是否重复
for (int j = 0; j < i; j++) {
if (arry[i] == arry[j]){
// 如果重复，重新赋值
i--;
break;
}
}
}
// 展示数组
for (int i = 0; i < arry.length; i++) {
System.out.print(arry[i]+"\t");
}
}
}
8、题目：回形数
从键盘输入一个整数（1~20） ，则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。
例如： 输入数字2，则程序输出：
1 2
4 3
输入数字3，则程序输出：
1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
//方式1
public class RectangleTest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个数字");
int len = scanner.nextInt();
int[][] arr = new int[len][len];
int s = len * len;
/*
* k = 1:向右
* k = 2:向下
* k = 3:向左
* k = 4:向上
*/
int k = 1;
int i = 0,j = 0;
for(int m = 1;m <= s;m++){
if(k == 1){
if(j < len && arr[i][j] == 0){
arr[i][j++] = m;
}else{
k = 2;
i++;
j--;
m--;
}
}else if(k == 2){
if(i < len && arr[i][j] == 0){
arr[i++][j] = m;
}else{
k = 3;
i--;
j--;
m--;
}
}else if(k == 3){
if(j >= 0 && arr[i][j] == 0){
arr[i][j--] = m;
}else{
k = 4;
i--;
j++;
m--;
}
}else if(k == 4){
if(i >= 0 && arr[i][j] == 0){
arr[i--][j] = m;
}else{
k = 1;
i++;
j++;
m--;
}
}
}
//遍历
for(int m = 0;m < arr.length;m++){
for(int n = 0;n < arr[m].length;n++){
System.out.print(arr[m][n] + "\t");
}
System.out.println();
}
}
}
方式二：
//方式2
/*
01 02 03 04 05 06 07
24 25 26 27 28 29 08
23 40 41 42 43 30 09
22 39 48 49 44 31 10
21 38 47 46 45 32 11
20 37 36 35 34 33 12
19 18 17 16 15 14 13
*/
public class RectangleTest1 {
public static void main(String[] args) {
int n = 7;
int[][] arr = new int[n][n];
int count = 0; //要显示的数据
int maxX = n-1; //x轴的最大下标
int maxY = n-1; //Y轴的最大下标
int minX = 0; //x轴的最小下标
int minY = 0; //Y轴的最小下标
while(minX<=maxX) {
for(int x=minX;x<=maxX;x++) {
arr[minY][x] = ++count;
}
minY++;
for(int y=minY;y<=maxY;y++) {
arr[y][maxX] = ++count;
}
maxX--;
for(int x=maxX;x>=minX;x--) {
arr[maxY][x] = ++count;
}
maxY--;
for(int y=maxY;y>=minY;y--) {
arr[y][minX] = ++count;
}
minX++;
}
for(int i=0;i<arr.length;i++) {
for(int j=0;j<arr.length;j++) {
String space = (arr[i][j]+"").length()==1 ? "0":"";
System.out.print(space+arr[i][j]+" ");
}
System.out.println();
}
}
}
9、题目：数组的扩容
现有数组 int[] arr = new int[]{1,2,3,4,5}; ，现将数组长度扩容1倍，并将10,20,30三个数据添加到arr数组中，如何操作？
package com.study.search_sort;
/**
* ClassName: ArrayExpansion
* Package: com.study.search_sort
* Description: 案例： 数组扩容
* 现有数组 int[] arr = new int[]{1,2,3,4,5}; ，现将数组长度扩容1倍，并将10,20,30三个数据添加到arr数组中，如何操作？
*
* @Author ShiQiFei
* @Create 2023/6/9 16:31
* @Version 1.0
*/
public class ArrayExpansion {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4,5};
// 扩容一倍
// int[] newArr = new int[arr.length * 2];
// or
// 左移一位
int[] newArr = new int[arr.length << 1];
// 将原有数组元素赋值到新数组中
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
// 将新元素赋值
newArr[arr.length] = 10;
newArr[arr.length+1] = 20;
newArr[arr.length+2] = 30;
// 将新数组地址赋给原有数组变量
arr = newArr;
// show
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
}
}
10、题目：数组的缩容
现有数组 int[] arr={1,2,3,4,5,6,7}。现需删除数组中索引为4的元素。
package com.study.search_sort;
/**
* ClassName: ArrayScaling
* Package: com.study.search_sort
* Description:
* 现有数组 int[] arr={1,2,3,4,5,6,7}。现需删除数组中索引为4的元素。
*
* @Author ShiQiFei
* @Create 2023/6/10 10:01
* @Version 1.0
*/
public class ArrayScaling {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7};
int deleteIndex = 4;
// 方法一：修改原有数组
// 删除元素，后面的元素向前移
for (int i = deleteIndex; i < arr.length-1; i++) {
arr[i] = arr[i+1];
}
// 将最后一个元素设为默认值
arr[arr.length-1] = 0;
// 结果：1 2 3 4 6 7 0
// 方法二：创建新数组
// 删除元素，创建一个新数组，将剩余元素存放到新数组中
int[] newArr = new int[arr.length - 1];
for (int i = 0; i < arr.length; i++) {
// 索引为4删除
if (i == deleteIndex) {
continue;
}
// 赋值
if (i > deleteIndex) {
newArr[i - 1] = arr[i];
} else {
newArr[i] = arr[i];
}
}
// 将新地址赋值给arr
arr = newArr;
// 结果：1 2 3 4 6 7
// show
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
11、题目：线性查找
- 定义数组：int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67};
- 查找数组元素 5 是否在上述数组中出现过？若出现，数组对应的索引值。
package com.study.search_sort;
/**
* ClassName: LinearSearch
* Package: com.study.search_sort
* Description: 线性查找
* 定义数组：int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67};
* 查找数组元素 5 是否在上述数组中出现过？若出现，数组对应的索引值。
*
* @Author ShiQiFei
* @Create 2023/6/10 10:32
* @Version 1.0
*/
public class LinearSearch {
public static void main(String[] args) {
int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67};
int target = 5;
// 线性查找：从第一个元素挨个查找数组中的元素，若有存在即返回当前元素的索引值。
// 方式一：根据标志判断又没找到
// boolean isFlag = false;
// for (int i = 0; i < arr.length; i++) {
// if (target == arr[i]){
// System.out.println("找到了，索引为 "+i);
// isFlag = true;
// break;
// }
// }
// if (!isFlag){
// System.out.println("未找到了！！！");
// }
// 方式二：根据数组长度判断是否找到
int i = 0;
for (; i < arr.length; i++) {
if (target == arr[i]){
System.out.println("找到了，索引为 "+i);
break;
}
}
if (i==arr.length){
System.out.println("未找到了！！！");
}
}
}
12、题目：二分查找
- 前提：数组内元素必须是有序的！！！
- 定义数组：int[] arr = {2, 4, 5, 8, 12, 15, 19, 26, 37, 49, 51, 66, 89, 100};
- 查找数组元素 5 是否在上述数组中出现过？若出现，数组对应的索引值。
- 实现逻辑：
- 实现代码
package com.study.search_sort;
/**
* ClassName: BinarySearch
* Package: com.study.search_sort
* Description:
* 定义数组：int[] arr = {2, 4, 5, 8, 12, 15, 19, 26, 37, 49, 51, 66, 89, 100};
* 查找数组元素 5 是否在上述数组中出现过？若出现，数组对应的索引值。
*
* @Author ShiQiFei
* @Create 2023/6/10 10:57
* @Version 1.0
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {2, 4, 5, 8, 12, 15, 19, 26, 37, 49, 51, 66, 89, 100};
int target = 5;
// 默认首索引
int head = 0;
// 默认尾索引
int end = arr.length - 1;
// 设置标志。判断是都找到
boolean isFlag = true;
while (head <= end) {
// 中间索引
int middle = (head + end) / 2;
//判断目标值与数组中间值是否相等
if (target == arr[middle]) {
System.out.println("找到了，索引为 " + middle);
isFlag = false;
break;
} else if (target < arr[middle]) { //查找左边元素
end = middle - 1;
} else { //查找右边元素
head = middle + 1;
}
}
if (isFlag){
System.out.println("么有找到了!!! ");
}
}
}
13、题目：冒泡排序
对现有数组进行排序：
int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67, 100};
package com.study.search_sort;
/**
* ClassName: BubbleSort
* Package: com.study.search_sort
* Description: 冒泡排序
* 思想：每一次比较“相邻（位置相邻）”元素，如果它们不符合目标顺序（例如：从小到大），
* 就交换它们，经过多轮比较，最终实现排序。
* （例如：从小到大） 每一轮可以把最大的沉底，或最小的冒顶。
*
* @Author ShiQiFei
* @Create 2023/6/10 12:47
* @Version 1.0
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67, 100};
// 遍历
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
// 比较
for (int i = 0; i < arr.length - 1; i++) {
boolean flag = true; //假设数组是有序的
// 交换一次，将最大的元素一直到了最右边
// 小优化：可知已将最大的放到了最左边，可以就不用与最后一个相比即：第一轮结束后 arr.length - 1 - 1
for (int j = 0; j < arr.length - 1 - i; j++) {
// 判断大小，若大就后移。
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = false; // 如果元素发生了交换，说明数组没有排好序
}
}
if (flag){
break;
}
}
// 排序后数组
System.out.println();
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
14、题目：Arrays库的使用
package com.study.arrays;
import java.util.Arrays;
/**
* ClassName: ArraysTest
* Package: com.study.search_sort
* Description: 数组工具类的使用
*
* @Author ShiQiFei
* @Create 2023/6/10 15:58
* @Version 1.0
*/
public class ArraysTest {
public static void main(String[] args) {
int[] arr1 = new int[]{1, 4, 7, 10, -30};
int[] arr2 = new int[]{1, 4, 7, 10, -30};
// int[] arr2 = new int[]{1, 4, 7, 10, -30}; // false
// 1、 boolean equals(int[] a, int[] b); 比较数组元素是否依次相等
boolean isEquals = Arrays.equals(arr1, arr2); // 注意 if(arr1==arr2)判断的是地址是否相等
System.out.println(isEquals); // true
// 2、String toString(int[] a): 输出数组元素信息
System.out.println(arr1); //[I@4eec7777
System.out.println(Arrays.toString(arr1)); // [9, -16, 30, 23, -30, -49, 25, 21, 30]
// 3、void fill(int[] a, int val):将指定值填充到数组之中
Arrays.fill(arr1, 33);
System.out.println(Arrays.toString(arr1)); // [33, 33, 33, 33, 33]
// 4、void sort(int[] a): 使用快速排序算法实现的排序
int[] arr3 = new int[]{1, 4, 7, 10, -30};
Arrays.sort(arr3);
System.out.println(Arrays.toString(arr3)); // [-30, 1, 4, 7, 10]
// 5、int binarySearch(int[] a, int key): 二分查找
int index = Arrays.binarySearch(arr3, 5);
System.out.println(index); // -4 负数代表没找到, 若大于等于0则找到了
}
}
15、题目：求数组的最大子序列和
- 输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
- 求所有子数组的和的最大值。要求时间复杂度为O(n)。
例如：输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，
因此输出为该子数组的和18。
public class ArrDemo {
public static void main(String[] args) {
int[] arr = new int[]{1, -2, 3, 10, -4, 7, 2, -5};
int i = getGreatestSum(arr);
System.out.println(i);
}
public static int getGreatestSum(int[] arr){
int greatestSum = 0;
if(arr == null || arr.length == 0){
return 0;
}
int temp = greatestSum;
for(int i = 0;i < arr.length;i++){
temp += arr[i];
if(temp < 0){
temp = 0;
}
if(temp > greatestSum){
greatestSum = temp;
}
}
if(greatestSum == 0){
greatestSum = arr[0];
for(int i = 1;i < arr.length;i++){
if(greatestSum < arr[i]){
greatestSum = arr[i];
}
}
}
return greatestSum;
}
}
16、题目：OOP小练习
- 案例：
- （1）声明一个MyDate类型，有属性：年year 月month 日day
- （2）声明一个Employee类型，包含属性:编号、姓名、年龄、薪资、生日（MyDate类型）
- （3）在EmployeeTest测试类中的main（）中，创建两个员工对象，并为他们的姓名和生日赋值、并显示。
MyDate类
package com.study.field.Exer01;
/**
* ClassName: MyDate
* Package: com.study.field.Exer01
* Description:
*
* @Author ShiQiFei
* @Create 2023/6/10 20:40
* @Version 1.0
*/
public class MyDate {
String year;
String month;
String day;
}
Employee类
package com.study.field.Exer01;
/**
* ClassName: Employee
* Package: com.study.field.Exer01
* Description:
*
* @Author ShiQiFei
* @Create 2023/6/10 20:31
* @Version 1.0
*/
public class Employee {
MyDate birthday;
int id;
String name;
int age;
double salary;
}
EmployeeTest类
package com.study.field.Exer01;
/**
* ClassName: EmployeeTest
* Package: com.study.field.Exer01
* Description: OOP
* 案例：
* （1）声明一个MyDate类型，有属性：年year 月month 日day
* （2）声明一个Employee类型，包含属性:编号、姓名、年龄、薪资、生日（MyDate类型）
* （3）在EmployeeTest测试类中的main（）中，创建两个员工对象，并为他们的姓名和生日赋值、并显示。
*
* @Author ShiQiFei
* @Create 2023/6/10 20:31
* @Version 1.0
*/
public class EmployeeTest {
public static void main(String[] args) {
Employee employee = new Employee();
employee.id = 123;
employee.name = "tom";
employee.age = 12;
employee.salary = 10000;
employee.birthday = new MyDate();
employee.birthday.year = "2022";
employee.birthday.month = "12";
employee.birthday.day = "01";
Employee employee1 = new Employee();
employee1.id = 1223;
employee1.name = "som";
employee1.age = 18;
employee1.salary = 20000;
employee1.birthday = new MyDate();
employee1.birthday.year = "2002";
employee1.birthday.month = "22";
employee1.birthday.day = "06";
System.out.println(employee.id + " " + employee.name + " " + employee.age + " " + employee.salary
+ " " + employee.birthday.year+":"+ employee.birthday.month+":"+ employee.birthday.day);
System.out.println(employee1.id + " " + employee1.name + " " + employee1.age + " " + employee1.salary
+ " " + employee1.birthday.year+":"+ employee1.birthday.month+":"+ employee1.birthday.day);
}
}
17、题目：对象数组
案例
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
- 生成随机数：Math.random()，返回值类型double;
- 四舍五入取整：Math.round(double d)，返回值类型long。
代码：
Student
package com.study.field.Exer05;
/**
* ClassName: Student
* Package: com.study.field.Exer05
* Description:
*
* @Author ShiQiFei
* @Create 2023/6/11 18:37
* @Version 1.0
*/
public class Student {
//学号
int number;
// 年级
int state;
// 成绩
int score;
// 声明一个方法打印属性
public String show(){
return "学号：" + number + " 年级：" + state + " 成绩：" + score;
}
}
StudentTest
package com.study.field.Exer05;
/**
* ClassName: StudentTest
* Package: com.study.field.Exer05
* Description:
*
* @Author ShiQiFei
* @Create 2023/6/11 18:38
* @Version 1.0
*/
public class StudentTest {
public static void main(String[] args) {
// 对象数组
Student[] students = new Student[20];
// 为学生赋值
for (int i = 0; i < students.length; i++) {
// 创建第一个学生对象
students[i] = new Student();
students[i].number = i + 1;
// 学生随机分到1-6年级
students[i].state = (int) (Math.random() * 6 + 1);
// 分数随机[0,100]
students[i].score = (int) (Math.random() * 101);
}
// 打印出三年级的学生
for (int i = 0; i < students.length; i++) {
Student stu = students[i];
if (stu.state == 3) {
// System.out.println("学号：" + stu.number + " 年级：" + stu.state + " 成绩：" + stu.score);
//System.out.println(stu.show());
}
}
// 冒泡排序按学生成绩，遍历所有学生成绩
// for (int i = 0, j = 1; i < students.length-1, j < (students.length-1-i); i++, j++) {
//
// }
for (int i = 0; i < students.length - 1; i++) {
for (int j = 0; j < students.length - 1 - i; j++) {
if (students[j].score > students[j + 1].score) {
// 注意！！！ 此处交换的为对象，而不是对象的成绩
Student temp = students[j];
students[j] = students[j + 1];
students[j + 1] = temp;
}
}
}
for (int i = 0; i < students.length; i++) {
System.out.println(students[i].show());
}
//System.out.println(Arrays.toString());
//System.out.println(Arrays.toString(student));
}
}
18、题目：递归函数应用
要求：利用递归函数实现
public class RecursionTest {
public static void main(String[] args) {
RecursionTest rt = new RecursionTest();
// 1-100的和
System.out.println(rt.getSum(100)); // 5050
// 10！
System.out.println(rt.getFactorial(10)); // 3628800
// 斐波那契数列 第10个数为多少
System.out.println(rt.f(10)); // 55
System.out.println(rt.f2(10)); // -3771
System.out.println(rt.f3(10)); // 89
}
/*
* 举例1；计算1-100内自然数的总和
*
* */
public int getSum(int num) {
if (num == 1) {
return 1;
}
return num + getSum(num - 1);
}
/*
* 举例2：计算n的阶乘
*
* */
public int getFactorial(int num) {
if (num == 1) {
return 1;
}
return num * getFactorial(num - 1);
}
/*
* 举例3：斐波那契数列
* 1 1 2 3 5 8 13 21
* 从第三个开始，第三个数 = 第一个数+第二个数
*
* */
public int f(int n) {
if (n == 1) {
return 1;
} else if (n == 2) {
return 1;
} else {
return f(n - 1) + f(n - 2);
}
}
/*
* 举例4：已知一个数列：f(20) = 1, f(21) = 4, f(n+2) = 2*f(n+1)+f(n)
* 其中n是大于0的整数，求f(10)的值。
*
* */
public int f2(int n) {
if (n == 20) {
return 1;
} else if (n == 21) {
return 4;
} else {
return f2(n + 2) - 2 * f2(n + 1); // 注意方程式要朝着已知的方向去推断
}
}
/*
* 举例5：已知一个数列：f(0) = 1, f(1) = 4, f(n+2) = 2*f(n+1)+f(n)
* 其中n是大于0的整数，求f(10)的值。
*
* */
public int f3(int n) {
if (n == 0) {
return 1;
} else if (n == 1) {
return 4;
} else {
return 2 * f(n - 1) + f(n - 2); // 注意方程式要朝着已知的方向去推断
}
}
}
19、题目：不死神兔
案例:不死神兔
用递归实现不死神兔:故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契(Fibonacci)。
在他的一部著作中提出了一个有趣的问题:假设一对刚出生的小兔一个月后就能长成大兔，
再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，没有发生死亡，
问:现有一对刚出生的兔子2年后(24个月)会有多少对兔子?
package com.study.field.Exer06;
/**
* ClassName: RabbitExer
* Package: com.study.field.Exer06
* Description:
* 案例:不死神兔
* 用递归实现不死神兔:故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契(Fibonacci)。
* 在他的一部著作中提出了一个有趣的问题:假设一对刚出生的小兔一个月后就能长成大兔，
* 再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，没有发生死亡，
* 问:现有一对刚出生的兔子2年后(24个月)会有多少对兔子?
* <p>
* 推断：
* 月份 1 2 3 4 5
* 兔子(对)数 1 1 2 3 5
*
* 可以发现本质就是斐波那契数列！！！
*
* @Author ShiQiFei
* @Create 2023/6/12 21:21
* @Version 1.0
*/
public class RabbitExer {
public static void main(String[] args) {
RabbitExer rabbit = new RabbitExer();
int month = 24;
System.out.println("兔子的对数为："+rabbit.getRabbitNumber(month));
}
public int getRabbitNumber(int month) {
if (month == 1) {
return 1;
} else if (month == 2) {
return 1;
}
return getRabbitNumber(month - 1) + getRabbitNumber(month - 2);
}
}
拓展：走台阶问题
假如有10阶台阶，小朋友每次只能向上走1阶或者2阶，请问有几种走法？
推断：
阶数 1 2 3 4 ……
走法 1 2 3 5 ……
从n为3开始：
f（n）= f（n-1）+f（n-2）
【奇妙的属性】随着数列的增加，斐波那契数列前一个数与后一个数的比值越来越逼近黄金分割比例0.618。
21、题目：
22、题目：
待更新！！！！！
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
