数组练习题
1.求数组的平均值：
实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
public class Test{
public static void main(String[] args) {
int[] arr=new int[]{2,3,4,5,6,7,8,9};
System.out.println(avg(arr));
}
public static double avg(int[] arr){
int sum=0;
for(int i=0;i<arr.length;i++){
sum+=arr[i];
}
return (double)sum/arr.length;
}
}
2.数组所有元素之和：
实现一个方法 sum, 以数组为参数, 求数组所有元素之和。
public class Test{
public static void main(String[] args) {
int[] arr=new int[]{1,2,3,4,5,6,7,8,9,10};
System.out.println(sum(arr));
}
public static int sum(int[] arr){
int sum=0;
for(int i=0;i<arr.length;i++){
sum +=arr[i];
}
return sum;
}
}
3.改变原有数组元素的值：
实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
class Test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
transform(arr);
printArray(arr);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void transform(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] * 2;
}
}
}
4.打印数组：
实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.
public class Test{
public static void main(String[] args) {
int[] arr=new int[]{1,2,3,4,5};
printArray(arr);
}
public static void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
5.创建的数组，并且赋初始值：
创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
public class Test{
public static void main(String[] args) {
int[] arr=new int[100];
print(arr);
}
public static void print(int[] arr){
for(int i=0;i<arr.length;i++){
arr[i]=i;
System.out.print(arr[i]+" ");
}
}
}
6.存在连续三个奇数的数组：
给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
示例 1：
输入：arr = [2,6,4,1]
输出：false
解释：不存在连续三个元素都是奇数的情况。
示例 2：
输入：arr = [1,2,34,3,4,5,7,23,12]
输出：true
解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。
(1)方法一：
public class Test{
public static void main(String[] args) {
int[] arr1=new int[]{2,6,4,1};
int[] arr2=new int[]{1,2,34,3,4,5,7,23,12};
System.out.println(threeConsecutiveOdds(arr1));
System.out.println(threeConsecutiveOdds(arr2));
}
public static boolean threeConsecutiveOdds(int[] arr){
if(arr.length <=2){
return false;
}
int i=0;
int count=0;
while(i<arr.length){
if((arr[i]&1) ==1 ){
count++;
if(count == 3){
return true;
}
}else{
count=0;
}
i++;
}
return false;
}
}
（2）方法二：
public class Test {
public static void main(String[] args) {
int[] arr1 = new int[]{2, 6, 4, 1};
int[] arr2 = new int[]{1, 2, 34, 3, 4, 5, 7, 23, 12};
System.out.println( consecutiveOdds(arr1));
System.out.println( consecutiveOdds(arr2));
}
public static boolean consecutiveOdds(int[] num) {
// for-each 遍历数组(不修改原数组)
// 记录当前数组中出现连续奇数的个数
int count = 0;
for (int i : num) {
// 此时i是个奇数
if (i % 2 != 0) {
count++;
} else {
// 此时i是偶数,重置count变量
count = 0;
}
if (count == 3) {
return true;
}
}
return false;
}
}
7.多数元素：
给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例一：
输入：[3,2,3]
输出：3
示例二：
输入：[2,2,1,1,1,2,2]
输出：2
(1)方法一：
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr1=new int[]{3,2,3};
int[] arr2=new int[]{2,2,1,1,1,2,2};
System.out.println(manyNum(arr1));
System.out.println(manyNum(arr2));
}
public static int manyNum(int[] num) {
// JDK内置了排序方法
Arrays.sort(num);
return num[num.length / 2];
}
}
(2)方法二：哈希表法
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test{
public static void main(String[] args) {
int[] arr1=new int[]{3,2,3};
int[] arr2=new int[]{2,2,1,1,1,2,2};
System.out.println(manyNum(arr1));
System.out.println(manyNum(arr2));
}
//哈希表方法 映射存储出现元素以及该元素出现的次数
public static int manyNum(int[] num) {
// JDK的哈希表用法
HashMap<Integer,Integer> hashMap = new HashMap<>();
// 遍历数组的过程中将不重复的元素以及其出现的次数存储到映射中
for (int i = 0; i < num.length; i++) {
// 若此时映射中存在元素
if (hashMap.containsKey(num[i])) {
// 此时只需要将出现次数+1
int value = hashMap.get(num[i]);
hashMap.put(num[i],value + 1);
}
else {
// 此时映射中还没有该元素
// 哈希表的存储方法put(不重复的元素，value)
hashMap.put(num[i],1);
}
}
// 在数据集中查找出现次数 > n/2的元素
// 哈希表的遍历
Set<Map.Entry<Integer,Integer>> set = hashMap.entrySet();
for (Map.Entry<Integer,Integer> entry : set) {
// 取出每个元素的value值(出现的次数)
if (entry.getValue() > num.length / 2) {
return entry.getKey();
}
}
return -1;
}
}
8.只出现一次的数字:
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
示例一：
输入: [2,2,1]
输出: 1
示例二：
输入: [4,1,2,1,2]
输出: 4
(1)方法一：
public class Test{
public static void main(String[] args) {
int[] arr1=new int[]{2,2,1};
int[] arr2=new int[]{4,1,2,1,2};
System.out.println(singleNum(arr1));
System.out.println(singleNum(arr2));
}
public static int singleNum(int[] num) {
// 将所有数组元素进行一次异或+
// 结果一定是出现一次的元素
int ret = 0;
for (int i :num) {
ret = ret ^ i;
}
return ret;
}
}
(2)方法二：
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test{
public static void main(String[] args) {
int[] arr1=new int[]{2,2,1};
int[] arr2=new int[]{4,1,2,1,2};
System.out.println(singleNum(arr1));
System.out.println(singleNum(arr2));
}
public static int singleNum(int[] num) {
Map<Integer,Integer> map = new HashMap<>();
for (int i = 0; i < num.length; i++) {
// 判断一下数组元素在映射中是否存在
if (map.containsKey(num[i])) {
map.put(num[i],2);
}else {
map.put(num[i],1);
}
}
// 遍历该映射，找到出现次数等1的元素key
Set<Map.Entry<Integer,Integer>> set = map.entrySet();
for (Map.Entry<Integer,Integer> entry : set) {
if (entry.getValue() == 1) {
return entry.getKey();
}
}
return -1;
}
}
9.两数之和：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
Test test=new Test();
int[] arr=new int[]{2,7,11,15};
int target=9;
System.out.println(Arrays.toString(Test.twoSum(arr,9)));
}
public static int[] twoSum(int[] num, int target) {
int[] ret = new int[2];
// 双引用法
// 从头给后遍历集合,边遍历边从后给前找是否有num[j] = target - num[i]
for (int i = 0; i < num.length; i++) {
for (int j = num.length - 1; j > i; j--) {
if (num[i] + num[j] == target) {
ret[0] = i;
ret[1] = j;
}
}
}
return ret;
}
}
10.冒泡排序：
给定一个整型数组, 实现冒泡排序(升序排序)
(1)方法一：
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr=new int[]{3,4,6,9,2};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[] arr){
for (int i = 0; i <arr.length-1; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j] > arr[j+1]){
int tmp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
}
}
}
}
}
(2)方法二：优化后
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr=new int[]{3,4,5,6,7,8};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[] num) {
// 未排序的数组 [0.....num.length-1]
// 已排序的数组 []
// 需要比较多少趟
// 每当一趟走完(两两交换元素，把大元素扔到后面),最大的元素一定出现在最后位置
// 当最后一趟只有一个元素时，此时整个数组已经有序了，不再需要交换
for (int i = 0; i < num.length - 1; i++) {
// 两两元素做交换处理
// 真正需要比较的元素个数
// 优化(若内层循环没有交换元素，说明此时数组已经有序了！！)
boolean swapFlag = true;
for (int j = 0; j < num.length - i - 1; j++) {
if (num[j] > num[j + 1]) {
// swap
int tmp = num[j];
num[j] = num[j + 1];
num[j + 1] = tmp;
swapFlag = false;
}
}
if (swapFlag) {
System.out.println("若此时没有元素做交换，此时数组已经有序");
break;
}
}
}
}
11.数组是否有序：
给定一个整型数组, 判定数组是否有序（递增）
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr1=new int[]{53,12,45,65,76,89,76};
System.out.println("数组为: "+Arrays.toString(arr1));
System.out.println("数组是否有序："+judgeSort(arr1));
int[] arr2=new int[]{1,2,3,4,5,6,7,8,9};
System.out.println("数组为: "+Arrays.toString(arr2));
System.out.println("数组是否有序: "+judgeSort(arr2));
}
public static boolean judgeSort(int[] arr){
for (int i = 0; i <arr.length-1 ; i++) {
if(arr[i]>=arr[i+1]){
return false;
}
}
return true;
}
}
12.二分查找：
给定一个有序整型数组, 实现二分查找
(1)方法一：
public class Test{
public static void main(String[] args) {
int[] arr=new int[]{1,2,3,4,5,6,7,8};
System.out.println(binarySearch(arr,6));
}
public static int binarySearch(int[] arr,int toFind){
int left=0;
int right=arr.length-1;
while(left<=right){
int mid=(left+right)/2;
if(toFind<arr[mid]){
right=mid-1;
}else if(toFind>arr[mid]){
left=mid+1;
} else{
return mid;
}
}
return -1;
}
}
(2)方法二：递归法解决二分查找
public class Test{
public static void main(String[] args) {
int[] arr=new int[]{1,2,3,4,5,6,7,8};
System.out.println(binarySearch(arr,6));
}
public static int binarySearch(int[] num, int toFind) {
return binarySearchInternal(num,toFind,0,num.length - 1);
}
// 递归
public static int binarySearchInternal(int[] num, int toFind, int left, int right) {
// 此时num为空区间
if (left > right) {
return -1;
}
int mid = (left + right) >> 1;
if (num[mid] == toFind) return mid;
else if (toFind < num[mid]) {
// 在←半区间查找
return binarySearchInternal(num,toFind,left,mid - 1);
}else {
// 在右半区间找
return binarySearchInternal(num,toFind,mid + 1,right);
}
}
}
13.数组的拷贝：
实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr=new int[]{11,21,32,43,23,46,76,87};
System.out.println("数组1为: "+Arrays.toString(arr));
System.out.println("拷贝后，数组2为："+Arrays.toString(copyOf(arr)));
}
public static int[] copyOf(int[] arr){
int[] brr=new int[arr.length];
for (int i = 0; i <brr.length ; i++) {
brr[i]=arr[i];
}
return brr;
}
}
14.数组转字符串：
实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 “[1, 2, 3]”, 注意 逗号 的位置和数量.
public class Test {public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3};
System.out.println(toString(arr));
}
public static String toString(int[] arr) {
String ret = "[";
for (int i = 0; i < arr.length; i++) {
ret += arr[i];
if (i != arr.length - 1) {
ret += ",";
}
}
ret += "]";
return ret;
}
}
952
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
