基于分治法的Java数组最值查找代码错误排查请求

我编写了一段基于分治法的Java代码，用于获取用户输入数组的最大值和最小值，但运行后结果始终显示数组第一个元素为最大值和最小值。为保持代码简洁，我未使用Integer.MIN_VALUE等方法，多次尝试仍未找到错误所在，恳请帮助排查。

原代码如下：

import java.util.Scanner;

public class MinMaxDivideConquer {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the number of elements: ");
        int n = scanner.nextInt();
        int[] arr = new int[n];
        System.out.println("Enter the elements: ");
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        // Initialize parameters
        int i = 0;
        int j = n - 1;
        int min = arr[0];
        int max = arr[0];
        // Call the divide and conquer function
        findMinMax(arr, i, j, min, max);
        System.out.println("Minimum: " + min);
        System.out.println("Maximum: " + max);
    }

    public static void findMinMax(int[] arr, int i, int j, int min, int max) {
        if (i == j) {
            min = max = arr[i];
        } else if (i == j - 1) {
            if (arr[i] < arr[j]) {
                min = arr[i];
                max = arr[j];
            } else {
                min = arr[j];
                max = arr[i];
            }
        } else {
            int mid = (i + j) / 2;
            int min1 = 0;
            int max1 = 0;
            findMinMax(arr, i, mid, min, max);
            findMinMax(arr, mid + 1, j, min1, max1);
            if (min1 < min) {
                min = min1;
            }
            if (max1 > max) {
                max = max1;
            }
        }
    }
}

核心错误原因 #

• Java值传递特性：int是基本数据类型，方法参数传递的是值的副本。findMinMax方法内对min和max的修改只会改变方法内的局部变量，不会影响main方法中定义的原始变量，这就是输出始终为数组第一个元素的根本原因。
• 递归逻辑漏洞：
  1. 递归调用左半区间时，未接收返回的最值结果，直接传递原始min和max，导致左半部分的计算结果完全丢失。
  2. min1和max1初始化为0，若数组中无0元素，会导致合并阶段的比较逻辑出错（比如数组全为负数时，min1的初始0会比所有负数大，无法得到正确最小值）。

修正方案 #

由于Java无法直接返回多个基本类型值，我们可以通过自定义结果类封装最值，让递归方法返回该类对象，确保每一层的计算结果能正确传递到上层：

修正后的代码 #

import java.util.Scanner;

public class MinMaxDivideConquer {
    // 自定义结果类，封装min和max
    static class Result {
        int min;
        int max;
        Result(int min, int max) {
            this.min = min;
            this.max = max;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the number of elements: ");
        int n = scanner.nextInt();
        int[] arr = new int[n];
        System.out.println("Enter the elements: ");
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }

        Result result = findMinMax(arr, 0, n - 1);
        System.out.println("Minimum: " + result.min);
        System.out.println("Maximum: " + result.max);
        scanner.close();
    }

    public static Result findMinMax(int[] arr, int i, int j) {
        // 单个元素的情况
        if (i == j) {
            return new Result(arr[i], arr[i]);
        }
        // 两个元素的情况
        else if (i == j - 1) {
            if (arr[i] < arr[j]) {
                return new Result(arr[i], arr[j]);
            } else {
                return new Result(arr[j], arr[i]);
            }
        }
        // 分治处理
        else {
            int mid = (i + j) / 2;
            Result leftResult = findMinMax(arr, i, mid);
            Result rightResult = findMinMax(arr, mid + 1, j);
            // 合并左右结果
            int overallMin = Math.min(leftResult.min, rightResult.min);
            int overallMax = Math.max(leftResult.max, rightResult.max);
            return new Result(overallMin, overallMax);
        }
    }
}

关键改进点 #

1. 用Result类封装最值，递归方法直接返回当前区间的计算结果，避免了值传递带来的结果丢失问题。
2. 去掉冗余参数传递，逻辑更清晰，每一层递归的职责明确：计算当前区间的最值并返回。
3. 完全依赖数组元素初始化最值，无需使用Integer.MIN_VALUE等固定值，符合你保持代码简洁的需求。

内容的提问来源于stack exchange，提问作者Aridra