投稿
  1. 首页
  2. 随笔

数组练习题

南航金城学院教务处 • 2022-11-8 • 随笔 • 阅读 1

数组练习题,第1张

数组练习题

数组练习题
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 


 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 


 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 


 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 


 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 


 （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 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> set = hashMap.entrySet();
        for (Map.Entry 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 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> set = map.entrySet();
        for (Map.Entry 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[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[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(toFindarr[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  


 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;
    }
}

 

					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/4744469.html
赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
南航金城学院教务处 南航金城学院教务处 一级用户组
0 0
上一篇 2022-11-08
下一篇 2022-11-08

发表评论

登录后才能评论

评论列表（0条）

保存