【详解】使用Java解决 - 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组

public class ArraySwap {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 2, 7, 4};
        
        // 打印原始数组
        System.out.println("原始数组: " + java.util.Arrays.toString(arr));
        
        // 调用方法进行交换
        swapMaxMin(arr);
        
        // 打印处理后的数组
        System.out.println("处理后的数组: " + java.util.Arrays.toString(arr));
    }

    public static void swapMaxMin(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        
        int maxIndex = 0; // 最大值的索引
        int minIndex = arr.length - 1; // 最小值的索引
        
        // 遍历数组，找到最大值和最小值的索引
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i;
            }
            if (arr[i] < arr[minIndex]) {
                minIndex = i;
            }
        }
        
        // 交换最大值与第一个元素
        int temp = arr[0];
        arr[0] = arr[maxIndex];
        arr[maxIndex] = temp;
        
        // 交换最小值与最后一个元素
        temp = arr[arr.length - 1];
        arr[arr.length - 1] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

原始数组: [5, 3, 8, 6, 2, 7, 4]
处理后的数组: [8, 3, 5, 6, 2, 7, 2]

public class ArraySwap {
    public static void main(String[] args) {
        int[] array = {3, 1, 4, 1, 5, 9, 2, 6}; // 示例输入数组
        swapMaxMin(array);
        for (int num : array) {
            System.out.print(num + " ");
        }
    }

    public static void swapMaxMin(int[] array) {
        if (array == null || array.length < 2) {
            return; // 如果数组为空或长度小于2，则不需要交换
        }

        int maxIndex = 0;
        int minIndex = array.length - 1;

        // 找到最大值和最小值的索引
        for (int i = 0; i < array.length; i++) {
            if (array[i] > array[maxIndex]) {
                maxIndex = i;
            }
            if (array[i] < array[minIndex]) {
                minIndex = i;
            }
        }

        // 交换最大值和第一个元素
        int temp = array[0];
        array[0] = array[maxIndex];
        array[maxIndex] = temp;

        // 交换最小值和最后一个元素
        temp = array[array.length - 1];
        array[array.length - 1] = array[minIndex];
        array[minIndex] = temp;

        // 特殊情况处理：如果最大值和最小值是同一个元素（即数组中有重复的最大或最小值）
        if (maxIndex == 0 && minIndex == array.length - 1) {
            // 需要再次交换，因为第一次交换后最大值和最小值的位置已经改变
            temp = array[0];
            array[0] = array[array.length - 1];
            array[array.length - 1] = temp;
        }
    }
}

import java.util.Arrays;

public class ArraySwap {
    public static void main(String[] args) {
        // 示例数组
        int[] array = {3, 1, 4, 1, 5, 9, 2, 6};
        
        System.out.println("原始数组: " + Arrays.toString(array));
        
        // 调用方法进行交换
        swapMaxMin(array);
        
        System.out.println("处理后的数组: " + Arrays.toString(array));
    }

    /**
     * 交换数组中的最大值和第一个元素，最小值和最后一个元素
     * @param array 输入的数组
     */
    public static void swapMaxMin(int[] array) {
        if (array == null || array.length < 2) {
            return; // 数组为空或长度小于2时，无需交换
        }
        
        int maxIndex = 0;
        int minIndex = array.length - 1;
        int firstElement = array[0];
        int lastElement = array[array.length - 1];
        
        // 找到最大值和最小值的索引
        for (int i = 0; i < array.length; i++) {
            if (array[i] > array[maxIndex]) {
                maxIndex = i;
            }
            if (array[i] < array[minIndex]) {
                minIndex = i;
            }
        }
        
        // 交换最大值和第一个元素
        array[maxIndex] = firstElement;
        array[0] = array[maxIndex];
        
        // 交换最小值和最后一个元素
        array[minIndex] = lastElement;
        array[array.length - 1] = array[minIndex];
        
        // 特殊情况处理：如果最大值和最小值是同一个元素
        if (maxIndex == minIndex) {
            array[0] = firstElement;
            array[array.length - 1] = lastElement;
        }
    }
}

import java.util.Arrays;

public static void main(String[] args) {
    int[] array = {3, 1, 4, 1, 5, 9, 2, 6};
    System.out.println("原始数组: " + Arrays.toString(array));
    swapMaxMin(array);
    System.out.println("处理后的数组: " + Arrays.toString(array));
}

public static void swapMaxMin(int[] array) {
    if (array == null || array.length < 2) {
        return;
    }
    
    int maxIndex = 0;
    int minIndex = array.length - 1;
    int firstElement = array[0];
    int lastElement = array[array.length - 1];
    
    for (int i = 0; i < array.length; i++) {
        if (array[i] > array[maxIndex]) {
            maxIndex = i;
        }
        if (array[i] < array[minIndex]) {
            minIndex = i;
        }
    }
    
    array[maxIndex] = firstElement;
    array[0] = array[maxIndex];
    
    array[minIndex] = lastElement;
    array[array.length - 1] = array[minIndex];
    
    if (maxIndex == minIndex) {
        array[0] = firstElement;
        array[array.length - 1] = lastElement;
    }
}