• Java数组编程练习题(面试题)

    目录

    1. 输入10位同学的java成绩：(1)求平均成绩，最高成绩、最低成绩；(2)对10的成绩按照从低到高的顺序排列（选做）

    2. 给定一个数组，判断某个元素是否在该数组中

    3. 给定一个数组，大小为10，输入十个同学的成绩，求这些成绩的总分数；某一天转入2个新同学，请再次求12个同学的平均成绩（尝试着使用扩容的形式做）

    4. 有一堆硬币，每次只能拿一个或者两个，求最少多少次可以拿完硬币

    5. 将数组中的重复数据去重

    6. 如何将10个0-10随机存入数组中

    7. 存在整数数组nums，将该数组中的所有偶数元素排列到奇数元素前

    8. 执行下列程序的输出结果为: ( D )

    9. 某个人进入如下一个棋盘中，要求从左上角开始走，最后从右下角出来（要求只能前进，不能后退），问题：共有多少种走法？

    1. 输入10位同学的java成绩：(1)求平均成绩，最高成绩、最低成绩；(2)对10的成绩按照从低到高的顺序排列（选做）

    1. import java.util.Arrays;
    2. import java.util.Scanner;
    3.  
    4. /*
    5.  * 请输入10位同学的java成绩，
    6.  *  1、求平均成绩，最高成绩、最低成绩
    7.  *  2、对10的成绩按照从低到高的顺序排列（选做）
    8.  */
    9. public class Test1 {
    10. 	public static void main(String[] args) {
    11. 		Scanner scanner = new Scanner(System.in);
    12. 		System.out.println("请依次输入10位同学的java成绩：");
    13. 		int[] arr = new int[10];
    14. 		for (int i = 0; i < arr.length; i++) {
    15. 			arr[i] = scanner.nextInt();
    16. 		}
    17. 		// 68 75 58 71 89 77 88 91 49 66
    18. 		System.out.print("十位同学的java成绩为：");
    19. 		System.out.println(Arrays.toString(arr));
    20. 		float averScore = findAverScore(arr);
    21. 		System.out.println("平均成绩为：" + averScore); // 73.2
    22. 		int maxScore = findMaxScore(arr);
    23. 		System.out.println("最大成绩为：" + maxScore); // 91
    24. 		int minScore = findMinScore(arr);
    25. 		System.out.println("最小成绩为：" + minScore); // 49
    26. 		
    27. 		// 定义一个排序函数：对10的成绩按照从低到高的顺序排列
    28. //		bubbleSort(arr); // 冒泡排序
    29. //		selectSort(arr); // 选择排序
    30. 		insertSort(arr); // 插入排序
    31. 		System.out.println(Arrays.toString(arr));
    32. 	}
    33.  
    34. 	public static void insertSort(int[] arr) {
    35. 		// TODO Auto-generated method stub
    36. 		for (int i = 0; i < arr.length - 1; i++) {
    37. 			for (int j = i + 1; j > 0; j--) {
    38. 				if (arr[j] < arr[j - 1]) {
    39. 					swap(arr, j, j - 1);
    40. 				}
    41. 			}
    42. 		}
    43. 	}
    44.  
    45. 	public static void selectSort(int[] arr) {
    46. 		// TODO Auto-generated method stub
    47. 		for (int i = 0; i < arr.length - 1; i++) {
    48. 			for (int j = i + 1; j < arr.length; j++) {
    49. 				if (arr[j] < arr[i]) {
    50. 					swap(arr, j, j - 1);
    51. 				}
    52. 			}
    53. 		}
    54. 	}
    55.  
    56. 	public static void bubbleSort(int[] arr) {
    57. 		// TODO Auto-generated method stub
    58. 		for (int i = 0; i < arr.length - 1; i++) {
    59. 			for (int j = 0; j < arr.length - 1; j++) {
    60. 				if (arr[j] > arr[j + 1]) {
    61. 					swap(arr, j, j + 1);
    62. 				}
    63. 			}
    64. 		}
    65. 	}
    66.  
    67. 	public static void swap(int[] arr, int i, int j) {
    68. 		// 异或法交互两个变量
    69. 		arr[i] = arr[i] ^ arr[j];
    70. 		arr[j] = arr[i] ^ arr[j];
    71. 		arr[i] = arr[i] ^ arr[j];
    72. 	}
    73.  
    74. 	public static int findMinScore(int[] arr) {
    75. 		// TODO Auto-generated method stub
    76. 		int minScore = arr[0];
    77. 		for (int i = 0; i < arr.length; i++) {
    78. 			if (arr[i] < minScore) {
    79. 				minScore = arr[i];
    80. 			}
    81. 		}
    82. 		return minScore;
    83. 	}
    84.  
    85. 	public static int findMaxScore(int[] arr) {
    86. 		// TODO Auto-generated method stub
    87. 		int maxScore = arr[0];
    88. 		for (int i = 1; i < arr.length; i++) {
    89. 			if (arr[i] > maxScore) {
    90. 				maxScore = arr[i];
    91. 			}
    92. 		}
    93. 		return maxScore;
    94. 	}
    95.  
    96. 	public static float findAverScore(int[] arr) {
    97. 		// TODO Auto-generated method stub
    98. 		float averScore;
    99. 		float sum = 0;
    100. 		for (int i = 0; i < arr.length; i++) {
    101. 			sum += arr[i];
    102. 		}
    103. 		averScore = sum / arr.length;
    104. 		return averScore;
    105. 	}
    106. }

    结果：

    2. 给定一个数组，判断某个元素是否在该数组中

    1. import java.util.Arrays;
    2. import java.util.Scanner;
    3.  
    4. public class Test2 {
    5. 	public static void main(String[] args) {
    6. 		/*
    7. 		 * 给定一个数组，判断某个元素是否在该数组中
    8. 		 */
    9. 		int[] arr = {68, 75, 58, 71, 89, 77, 88, 91, 49, 66};
    10. 		Scanner scanner = new Scanner(System.in);
    11. 		System.out.print("请输入一个要查找的数：");
    12. 		int target = scanner.nextInt();
    13. 		int index = binarySearch(arr, 0, arr.length - 1, target);
    14. 		if (index == -1) {
    15. 			System.out.println("很遗憾，你要找的数不在数组中！");
    16. 		}else {
    17. 			System.out.println("你要找的数在数组中！");
    18. 		}
    19. 	}
    20.  
    21. 	public static int binarySearch(int[] arr, int start, int end, int target) {
    22. 		// 二分查找前提是要让arr有序
    23. 		Arrays.sort(arr);
    24. 		int mid = (start + end) >> 1;
    25. 		if (start <= end) {
    26. 			if (arr[mid] == target) {
    27. 				return mid;
    28. 			}else if (arr[mid] < target) {
    29. 				start = mid + 1;
    30. 				return binarySearch(arr, start, end, target);
    31. 			}else {
    32. 				end = mid - 1;
    33. 				return binarySearch(arr, start, end, target);
    34. 			}
    35. 		}
    36. 		return -1;
    37. 	}
    38. }

    结果：

    3. 给定一个数组，大小为10，输入十个同学的成绩，求这些成绩的总分数；某一天转入2个新同学，请再次求12个同学的平均成绩（尝试着使用扩容的形式做）

    1. import java.util.Arrays;
    2. import java.util.Scanner;
    3.  
    4. public class Test3 {
    5. 	/*
    6. 	 * 给定一个数组，大小为10，输入十个同学的成绩，求这些成绩的总分数；
    7. 	 * 某一天转入2个新同学，请再次求12个同学的平均成绩（尝试着使用扩容的形式做）
    8. 	 */
    9. 	public static void main(String[] args) {
    10. 		Scanner scanner = new Scanner(System.in);
    11. 		System.out.println("请输入10个同学的成绩：");
    12. 		int[] arr = new int[10];
    13. 		for (int i = 0; i < arr.length; i++) {
    14. 			arr[i] = scanner.nextInt();
    15. 		}
    16. 		int sum = sumScore(arr);
    17. 		System.out.println("总成绩为：" + sum);
    18. 		// 新转来两个，数组扩容
    19. 		arr = expandCapacity(arr);
    20. 		System.out.println(Arrays.toString(arr));
    21. 		sum = sumScore(arr);
    22. 		float aver = sum / arr.length;
    23. 		System.out.println("平均值为：" + aver);
    24. 	}
    25.  
    26. 	public static int[] expandCapacity(int[] arr) {
    27. 		// 数组扩容
    28. 		Scanner scanner = new Scanner(System.in);
    29. 		System.out.print("请输入两个新同学的成绩：");
    30. 		int[] arr1 = new int[arr.length + 2];
    31. 		for (int i = 0; i < arr1.length; i++) {
    32. 			if (i < arr.length) {
    33. 				arr1[i] = arr[i];
    34. 			}else {
    35. 				arr1[i] = scanner.nextInt();
    36. 			}
    37. 		}
    38. 		return arr1;
    39. 	}
    40.  
    41. 	public static int sumScore(int[] arr) {
    42. 		// 求和
    43. 		int sum = 0;
    44. 		for (int i = 0; i < arr.length; i++) {
    45. 			sum += arr[i];
    46. 		}
    47. 		return sum;
    48. 	}
    49. }

    结果：

    4. 有一堆硬币，每次只能拿一个或者两个，求最少多少次可以拿完硬币

           桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。(LeetCode)

    1. public class Test4 {
    2. 	/*
    3. 	 * ·有一堆硬币，每次只能拿一个或者两个，求最少多少次可以拿完硬币
    4. 	 * {10, 8, 5, 3, 27, 99}
    5. 	 */
    6. 	public static void main(String[] args) {
    7. 		int[] coins = {10, 8, 5, 3, 27, 99};
    8. 		int result = minCount(coins);
    9. 		System.out.println("最少" + result + "次可以拿完硬币");
    10. 	}
    11. 	
    12. 	public static int minCount(int[] coins) {
    13. 		int count = 0;
    14.         for(int i = 0; i < coins.length; i++) {
    15.             if(coins[i] % 2 == 0) {
    16.                 count += (coins[i] / 2);
    17.             }else{
    18.                 count += (coins[i] / 2 + 1);
    19.             }
    20.         }
    21.         return count;
    22.     }
    23. }

    结果：

    5. 将数组中的重复数据去重

    笨方法，双层循环

    1. package com.openlab.day09.exer;
    2.  
    3. import java.util.Arrays;
    4.  
    5. public class Test5 {
    6. 	// 将数组中的重复数据去重
    7. 	public static void main(String[] args) {
    8. 		int[] arr = {5, 4 ,9, 5, 2, 5, 8, 4};
    9. 		arr = removeRepeat(arr);
    10. 		System.out.println(Arrays.toString(arr));
    11. 	}
    12.  
    13. 	public static int[] removeRepeat(int[] arr) {
    14. 		// 将数组中的重复元素去除
    15. 		int[] temp = new int[arr.length];
    16. 		int count = 0;
    17. 		boolean isFlag = true;
    18. 		for (int i = 0; i < temp.length; i++) {
    19. 			for (int j = 0; j < temp.length; j++) {
    20. 				if (temp[j] == arr[i]) {
    21. 					isFlag = false;
    22. 				}
    23. 			}
    24. 			if (isFlag) {
    25. 				temp[count++] = arr[i];
    26. 			}
    27. 			isFlag = true;
    28. 		}
    29. 		int[] newArr = new int[count];
    30. 		for (int i = 0; i < newArr.length; i++) {
    31. 			newArr[i] = temp[i];
    32. 		}
    33. 		return newArr;
    34. 	}
    35. }

    结果：

    6. 如何将10个0-10随机存入数组中

    1. public class Test6 {
    2. 	// 如何将10个0-10随机存入数组中
    3. 	public static void main(String[] args) {
    4. 		int[] arr = new int[10];
    5. 		putRandomArray(arr);
    6. 		for (int i = 0; i < arr.length; i++) {
    7. 			System.out.print(arr[i] + "\t");
    8. 		}
    9. 	}
    10.  
    11. 	private static void putRandomArray(int[] arr) {
    12. 		// 随机存入数组
    13. 		for (int i = 0; i < arr.length; i++) {
    14. 			int randomNum = (int)(Math.random() * 11);
    15. 			arr[i] = randomNum;
    16. 		}
    17. 	}
    18. }

    结果：

    7. 存在整数数组nums，将该数组中的所有偶数元素排列到奇数元素前

    1. import java.util.Arrays;
    2.  
    3. public class Test7 {
    4. 	public static void main(String[] args) {
    5. 		int[] nums = {1, 4, 5, 3, 6, 7, 10};
    6. 		exchange(nums);
    7. 		System.out.println(Arrays.toString(nums));
    8. 	}
    9. 	
    10. 	public static void exchange(int[] nums) {
    11. 		int i = 0, j = nums.length - 1;
    12. 		while(i < j) {
    13. 			while(nums[i] % 2 == 0) {
    14. 				i++;
    15. 			}
    16. 			while(nums[j] % 2 == 1) {
    17. 				j--;
    18. 			}
    19. 			if (i < j) {
    20. 				swap(nums, i, j);
    21. 			}
    22. 		}
    23.     }
    24.  
    25. 	public static void swap(int[] nums, int i, int j) {
    26. 		// 交换数组中两个元素的值
    27. 		nums[i] = nums[i] ^ nums[j];
    28. 		nums[j] = nums[i] ^ nums[j];
    29. 		nums[i] = nums[i] ^ nums[j];
    30. 	}
    31. }

    结果：

    8. 执行下列程序的输出结果为: ( D )

    1. public class Test {
    2. 	public static void main(String[] args) {
    3. 		String s1 = "HelloWorld";
    4. 		String s2 = new String("HelloWorld");
    5. 		if (s1 == s2) {
    6. 			System.out.println("s1 == s2");
    7. 		}else {
    8. 			System.out.println("s1 != s2");
    9. 		}
    10. 		if (s1.equals(s2)) {
    11. 			System.out.println("s1 equals s2");
    12. 		} else {
    13. 			System.out.println("s1 not equals s2");
    14. 		}
    15. 	}
    16. }

        A. s1 == s2
            s1 not equals s2
        B. s1 == s2
            s1 equals s2
        C. s1 != s2
            s1 not equals s2
        D. s1 != s2
            s1 equals s2

    解析：字符串是一个对象，在java中 == 判断的是值是否相等，不能用来判断字符串，因为字符串的创建方式有多种，不同的创建方式，地址(指针) 可能不一致。在java中 == 判断的是值是否相等，不能用来判断字符串，字符串中 == 判断的字符串的地址，equals判断是字符串的值；s1和s2是两个不同的字符串对象，所以地址不一样，所以s1 ！= s2；s1 equals s2，故选D。

    9. 某个人进入如下一个棋盘中，要求从左上角开始走，最后从右下角出来（要求只能前进，不能后退），问题：共有多少种走法？

        0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0

    暂时不会

  • 相关阅读:
    Effectively Learning Spatial Indices(VLDB)
    codeforces （C++ Simple Design）
    基于智能反射面的MIMO系统波束赋形算法代码
    Polar SI9000阻抗计算
    11月业务安全月报 | 台湾2300万人信息泄露；黑客两分钟即可破解安卓锁屏；乌克兰“IT军团”入侵俄罗斯中央银行
    Fortify-设置中文语言
    【FreeSwitch开发实践】外呼线路电话收不到回铃音问题的解决
    【每日一题】补档 CF1792C. Min Max Sort | 思维 | 简单
    手绘地图制作实例详解：如何从0到功能丰富的智慧导览系统
    【C++ 学习】库文件和头文件编写
  • 原文地址：https://blog.csdn.net/weixin_51612062/article/details/125868899