Java数组练习题

1、两数之和

要求：给定一个整数数组，nums 和目标值 target ,再给数组中找出和为目标值的两个整数，并返回他们的下标。

示例：

给定nums={2,7,11,19}

因为nums[0]+nums[1]=9

返回[0,1]

思路：双重循环 i（从第一个元素起） 先不动 j （从i之后起）动，找到符合条件nums[i]+nums[j]=target,找到返回i,j，未找到i++, j （从i之后起),继续++ 找，找到返回，未找到返回-1，-1。

代码：

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] nums = {2, 7, 11,19};
        int target=9;
        int[] arr=twoSum(nums,target);
        System.out.println(Arrays.toString(arr));
    }
    public static int[] twoSum(int[] nums,int t){
        int[] ret=new int[]{-1,-1};
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if(nums[i]+nums[j]==t){
                    return new int[]{i,j};
                }
            }
        }
        return null;
    }
}
//运行结果：[0, 1]

2、主要元素

要求：数组中占比超过一般的元素称之为主要元素。给定一个整数数组，找到她的主要元素。若没有，返回-1.

示例：

输入[1,2,5,9,9,5,5,5]

输出：5

思路：控制  i  和  j  字节的距离大于数组长度的一半，观察arr[i] 与arr[j] 是否相等，若相等说明arr[i]是关键元素。

代码：

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,5,9,5,9,5,5,5};
        int ret=majorityEle(arr);
        System.out.println(ret);
    }
    public static int majorityEle(int[] arr){
        Arrays.sort(arr);
        int len=arr.length;
        for (int i = 0; i <=len/2 ; i++) {
            for (int j = i+len/2; j < len; j++) {
                if(arr[i]==arr[j]){
                    return arr[i];
                }
            }
        }
        return -1;
    }
}
//运行结果：5

3、找数组中的最大元素

public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,5,9,5,9,5,5,5};
        int max=max(arr);
        System.out.println(max);
    }
    public static int max(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

4、求数组中元素的平均值

public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,5,9,5,9,5,5,5};
        System.out.println(avg(arr));
    }
    public static double avg(int[] arr) {
        int sum = 0;
        for (int x : arr) {
            sum += x;
        }
        return (double)sum / (double)arr.length;
    }
}

5、二分查找

基于一个有序数组的查找

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,18,16,4,59,9};
        Arrays.sort(arr);
        System.out.println(binarySearch(arr,9));
    }
    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;
    }
}

也可以直接使用工具

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr={1,2,18,16,4,59,9};
        Arrays.sort(arr);
        System.out.println(Arrays.binarySearch(arr,9));
    }
}

6、冒泡排序及优化

优化：设置一个标志位，如果在一次扫描中未发现交换，则代表数组已经有序了，直接退出。

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 18, 16, 4, 59, 9};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void bubbleSort(int[] arr) {
        boolean f;
        for (int i = 0; i < arr.length-1; i++) {
            f=false;
            for (int j = 0; j <arr.length-1-i ; j++) {
              if(arr[j]>arr[j+1]) {
                  int t=arr[j];
                  arr[j]=arr[j+1];
                  arr[j+1]=t;
                  f=true;
              }
            }
            if(f==false){
                return;
            }
        }
    }
}

 

7、数组逆序

思路 ：设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素. 然后让前一个下标自增, 后一个下标自减, 循环继续即可.（就地逆置 ）

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 18, 16, 4, 59, 9};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void reverse(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
    }
}

8、数组数字排列

给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分

基本思路： 设定两个下标分别指向第一个元素和最后一个元素. 用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素. 依次循环即可。

import java.util.Arrays;
public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 18, 16, 4, 59, 9};
        transform(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void transform(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            while (left < right && arr[left] % 2 == 0) {
                left++;
            }
            while (left < right && arr[right] % 2 != 0) {
                right--;
            }
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
        }
    }
}

 交换两个数组：

import java.util.Arrays;
public class Test{
    public static void main(String[] args) {
        int[] a= {1,2,3,4,5,6};
        int[] b= {4,5,6};
        System.out.println("a:"+Arrays.toString(a));
        System.out.println("b:"+Arrays.toString(b));
        swap(a,b);
        System.out.println("交换后：");
        System.out.println("a:"+Arrays.toString(a));
        System.out.println("b:"+Arrays.toString(b));
    }
    public static void swap(int[] a,int[] b) {
        int len = a.length < b.length ? a.length : b.length;
        for (int i = 0; i < len; i++) {
            int t = a[i];
            a[i] = b[i];
            b[i] = t;
        }
         if (a.length > b.length) {
            System.out.println("b数组长度不足");
            for (int i = len; i <a.length; i++) {
                a[i]=0;
            }
        }else{
            System.out.println("a数组长度不足");
            for (int i = len; i <b.length; i++) {
                b[i] = 0;
            }
        }
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

9、