Java 数组相关的经典题目举例详解

内容目录：

• 数组逆序
• 数组插入
• 杨慧三角
• 顺序查找法
• 查找最大数
• 二分查找法
• 两个数组的交集
• 寻找缺失的数字

1. 数组逆序

如何把数组中的元素逆序？

思路：逆序 就是把数组的元素前后倒置。

我们可以把前后两个数 i 和 arr.length-1-i 位置上的数进行交换

但是一定注意交换次数是长度的一半

举例如下：

 *  0-3  1-2
 * {3,8,6,2}---i----
 * {2,6,8,3}
 * 
 * 0-4 1-3 2-2 3-1 4-0  ---i-length-1-i
 * {1,2,3,4,5}

	public static void reverse(){
		int[] arr = {3,6,8,9,1};
		System.out.println(Arrays.toString(arr));
		for (int i = 0; i < arr.length/2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length-1-i];
			arr[arr.length-1-i] = temp;
		}

		System.out.println(Arrays.toString(arr));
	}

2.数组插入

把一个数插入有序数组，保持数组依然有序：

思路：

把这个数依次和数组的第一个开始的每个数进行比较，找到第一个比自己大的数的位置即是要插入的位置。

但是从后向前找位置，其实效率更高，因为在查找过程中就可以完成后移动的操作。

/**
	 * 数组插入
	 * {3,5,6,2,9,8,0}  最后一位保留位置
	 * index = 3;插入数7
	 * {3,5,6,7,2,9,8}
	 * 
	 */
	public static void insert(){
		int[] arr = {3,5,6,2,9,8,0};
		int index = 3;
		int num = 7;
		System.out.println(">>>=="+Arrays.toString(arr));
		int i = arr.length-1;
		for (; i>index; i--) {
			arr[i] = arr[i-1];
		}
		arr[i] = num;
		System.out.println(">>>=="+Arrays.toString(arr));
	}

3.杨慧三角：

思路：

杨辉三角，是二项式系数在三角形中的一种几何排列

在二维数组中的第一列和中间对等列为1，其余元素的值为

上一行前两个元素之和 ： arr[i][j] = arr[i-1][j]+arr[i-1][j-1]

public static void yanghui2(){
		int[][] arr = new int[6][];
		
		for (int i = 0; i < arr.length; i++) {
			arr[i] = new int[i+1];
			for (int j = 0; j < arr[i].length; j++) {
               //对角线和第一列初始为1
				if(i==j||j==0){					
					arr[i][j] = 1;
				}else{
                  	//上一行
					arr[i][j] = arr[i-1][j]+arr[i-1][j-1];
				}
			}
		}
		
		print(arr);
	}
	
	/**
	 * 打印二维数组
	 * @param arr
	 */
	public static void print(int[][] arr){
		for (int i = 0; i < arr.length; i++) {
			System.out.println(Arrays.toString(arr[i]));
		}
	}

4.顺序查找法

给定数字，在数组中查找所在的下标，没有找到则返回-1.

思路：

顺序查找是按照序列原有顺序对数组进行遍历比较查询的基本查找算法，只需要按数组下标索引一次对比即可。

根据题目要求找不到返回-1,所以可以假设找不到，设置变量标志位 int index = -1。然后依次查找，找到则替换标志为位置索引。index = i ;

/**
	 * 在指定的数组中查找指定值num
	 * 如果找到了，则返回次数在数组中的下标
	 * 如果找不到，则返回-1
	 * 
	 */
	public static void findNum(int num){
		int[] arr = {6,9,3,8,20,11};
		int index = -1;
		
		for (int i = 0; i < arr.length; i++) {
          //如果找到 则跳出 且记录下标位置
			if(arr[i]==num){
				index = i;
				break;
			}
		}
		
		System.out.println("下标为："+index);
	}

5.查找最大数

解题思路：

题目要求实现，在一个数组序列中找出其中最大那个数。

我们可以使用一个变量存放第一个数，然后后面取出每个数进行比较，大于此变量的数则替换掉此变量。

直到查找结束，留在变量中的值即为最大数

	public static void findMax(){
		int[] arr = {7,3,9,11,1};
      	//用于保存最大数
		int max = 0;
		for (int i = 0; i < arr.length; i++) {
			//和max比较 大的数留下
			if(arr[i]>max){
				max = arr[i];
			}
		}
		System.out.println(">>>>----"+max);
	}

6.二分查找法

前提是所查找的数组必须是有序的。

思路：

思路：在有顺序的序列中，每次取出查找范围内的中间数进行比较

如果大于中间数，则说明要找的数在后面，否则在前面。

依次调整开始范围和结束范围即可

private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
  		//记录查找的开始位置
		int low = fromIndex;
  		//记录查找的结束位置
		int high = toIndex;
		//如果结束位置不大于开始位置 则可以继续查找
		while (low <= high) {
          //除以2 找出中间位置的数
			int mid = (low + high) >>> 1;

			if (a[mid] < key)
				low = mid + 1;//如果要找的数大于了中间数，则下次查找的开始位置调整为中间数的下一个数
			else if (a[mid] > key)
				high = mid - 1;//如果找的数小于中间数，则下次查找的结束位置为中间数的上一个位置
			else
				return mid; // key found
		}
		return -(low + 1); // key not found.
	}

7.两个数组的交集

给定两个数组，找出它们的交集元素

下面是一个简单的 Java 实现，用于找出两个整数数组的交集：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class ArrayIntersection {

    public static List<Integer> findIntersection(int[] array1, int[] array2) {
        // 使用HashSet来存储第一个数组的元素并去重
        Set<Integer> set1 = new HashSet<>();
        for (int num : array1) {
            set1.add(num);
        }

        // 创建一个列表来存储交集结果
        List<Integer> intersection = new ArrayList<>();

        // 遍历第二个数组，检查元素是否在第一个数组的集合中
        for (int num : array2) {
            if (set1.contains(num)) {
                // 如果包含，则添加到交集列表中
                intersection.add(num);
                // 并从集合中移除，防止重复添加（如果数组中有重复元素）
                set1.remove(num);
            }
        }

        return intersection;
    }

    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {4, 5, 6, 7, 8};

        List<Integer> result = findIntersection(array1, array2);

        System.out.println("Intersection of the two arrays is:");
        for (Integer num : result) {
            System.out.print(num + " ");
        }
    }
}

上述代码首先将第一个数组转换为哈希集合，这样我们可以利用集合的O(1)时间复杂度查找功能快速判断元素是否存在。然后遍历第二个数组，将存在与第一个数组中的元素添加到结果列表中，并从集合中移除以避免重复添加。最后，返回交集元素的列表。注意，这种方法假设数组中的元素是整数，且处理的是非重复元素的交集。对于包含重复元素且需要考虑重复次数的情况，需要稍作修改。

8. 寻找缺失的数字

思路：

这个问题可以通过使用异或运算（XOR）来解决。在二进制逻辑运算中，任何数与0异或还是本身，任何数与自身异或的结果是0，相同两个数异或也是0。

因此，当我们对数组中的所有元素进行异或运算时，成对出现的数字将会相互抵消为0，最后剩下的就是只出现一次的那个数字。

下面是Java实现：

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 3, 4, 4, 5, 5, 6, 7}; // 示例数组，其中数字7只出现一次
        int singleNumber = findSingleNumber(numbers);
        System.out.println("The number that appears only once is: " + singleNumber);
    }

    public static int findSingleNumber(int[] nums) {
        int result = 0;
        for (int num : nums) {
            result ^= num; // 异或运算
        }
        return result;
    }
}

在这段代码中，我们遍历整个数组并对每个元素执行异或运算。最后的结果就是数组中唯一出现一次的数字。这个算法的时间复杂度为O(n)，空间复杂度为O(1)。