Java中数组常见操作实战：反转、求最值与折半查找

1. 数组元素反转

数组反转通常采用双指针思想，从两端向中间靠拢并交换元素。只需遍历数组长度的一半即可。

第1步：定义辅助方法进行内部反转

为了避免修改外部对象时的复杂性，可以封装一个静态方法。注意：Arrays.toString() 可用于打印查看结果。

import java.util.Arrays;

public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        reverse(arr);
        System.out.println("反转后的数组：" + Arrays.toString(arr));
    }

    public static void reverse(int[] 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;
        }
    }
}

完成状态：执行后数组顺序完全颠倒，且直接作用于原内存地址。

2. 寻找数组的最值

在遍历中寻找最大值或最小值时，初始化变量至关重要。不能将其初始化为 0，因为数组可能全部由负数组成，导致结果错误。

第1步：正确初始化极值变量

应使用数组的第一个元素 a[0] 作为初始参考点，然后从第二个元素开始遍历对比。

class ZuiZhi {
    public static void main(String[] args) {
        int[] a = {2, 92, 34, 54, 28};
        minMethod(a);
        maxMethod(a);
    }

    // 求最小值
    public static void minMethod(int[] a) {
        int min = a[0]; // 正确初始化
        for (int i = 0; i < a.length; i++) {
            if (a[i] < min) {
                min = a[i];
            }
        }
        System.out.println("数组内最小的元素是：" + min);
    }

    // 求最大值
    public static void maxMethod(int[] a) {
        int max = a[0]; // 正确初始化
        for (int i = 0; i < a.length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        System.out.println("数组内最大的元素是：" + max);
    }
}

完成状态：控制台输出准确的极值数值。

3. 折半查找（Binary Search）

折半查找仅适用于已经排序的数组。其核心在于不断缩小搜索范围，直到找到目标或区间无效。

第1步：理解边界收缩逻辑

设最小索引为 min，最大索引为 max，中间位置 mid。若中间值大于目标，则最大索引移至 mid-1；反之则最小索引移至 mid+1。

第2步：处理整数溢出风险

计算中点时，推荐使用位运算 (min + max) >> 1 或者 min + (max - min) / 2，避免直接使用 (min + max) / 2 导致的大数溢出问题。

class BinarySearch {
    public static void main(String[] args) {
        int[] a = {3, 5, 7, 9, 10, 14};
        // 测试两种写法的效果
        System.out.println(binarySearch_2(a, 7)); // 输出: 2
        System.out.println(binarySearch_2(a, 14)); // 输出: 5
    }

    /**
     * 推荐写法：标准的 while (min <= max) 循环结构
     */
    public static int binarySearch_2(int[] a, int key) {
        int min = 0, max = a.length - 1, mid;
        while (min <= max) {
            mid = (max + min) >> 1; // 防止溢出的求中点公式
            if (a[mid] > key) {
                max = mid - 1;
            } else if (a[mid] < key) {
                min = mid + 1;
            } else {
                return mid; // 找到目标，返回索引
            }
        }
        return -1; // 未找到
    }

    /**
     * 另一种写法：在循环内部判断不等式
     */
    public static int binarySearch_1(int[] a, int key) {
        int min = 0, mid, max = a.length - 1;
        mid = (min + max) / 2;
        
        while (key != a[mid]) {
            if (a[mid] > key) {
                max = mid - 1;
            } else if (a[mid] < key) {
                min = mid + 1;
            }
            // 如果区间不再有效，说明查找失败
            if (max < min) {
                return -1;
            }
            mid = (min + max) / 2;
        }
        return mid;
    }
}

完成状态：在已排序数组中高效定位特定元素索引。

以上就是Java中数组反转、求最值及折半查找的详细内容，更多关于Java基础算法的资料请关注本站其它相关文章！