01-数组练习

public static int[] findMinAndMax(int[] nums) {
    // 初始化最大值和最小值为数组的第一个元素
    int max = nums[0];
    int min = nums[0];

    // 遍历数组
    for (int num : nums) {
        // 如果当前值大于最大值，更新最大值
        if (num > max) {
            max = num;
        }
        // 如果当前值小于最小值，更新最小值
        if (num < min) {
            min = num;
        }
    }
    // 返回最大值和最小值
    return new int[]{min, max};
}

public class ArraySolutions {
    public static int[] findMinAndMax(int[] nums) {
        int min = nums[0]; // 初始化最小值为第一个元素
        int max = nums[0]; // 初始化最大值为第一个元素
        for (int num : nums) { // 遍历数组
            if (num < min) min = num; // 更新最小值
            if (num > max) max = num; // 更新最大值
        }
        return new int[]{min, max}; // 返回包含最小值和最大值的数组
    }

    public static void main(String[] args) {
        int[] nums = {3, 5, 1, 9, 2};
        int[] result = findMinAndMax(nums);
        System.out.println("Min: " + result[0] + ", Max: " + result[1]);
    }
}

import java.util.ArrayList;
import java.util.List;

public class ArraysIntersection {
    public static void main(String[] args) {
        int[] nums1 = {1, 2, 2, 3};
        int[] nums2 = {2, 2, 3, 4};
        List<Integer> intersection = new ArrayList<>();

        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                if (nums1[i] == nums2[j] && !intersection.contains(nums1[i])) {
                    intersection.add(nums1[i]);
                }
            }
        }
        System.out.println(intersection);
    }
}

public class MaxSubArray {
    // 定义方法，输入一个整数数组，返回具有最大和的连续子数组的和
    public static int maxSubArraySum(int[] nums) {
        // 如果输入数组为空或长度为0，返回0（边界条件）
        if (nums == null || nums.length == 0) {
            return 0; // 空数组情况下返回0
        }
        
        // 初始化最大子数组和，初始值设为最小的整数，因为最小值可能是最优解
        int maxSum = Integer.MIN_VALUE;
        
        // 当前子数组的和，初始化为0
        int currentSum = 0;
        
        // 遍历数组中的每个元素
        for (int num : nums) {
            // 判断当前子数组和是否应继续累加当前元素
            // 如果 `currentSum + num` 大于 `num`，说明继续将当前元素加入子数组更合适
            if (currentSum + num > num) {
                currentSum = currentSum + num;  // 累加当前元素到子数组和
            } else {
                currentSum = num;  // 否则，从当前元素重新开始子数组
            }
            
            // 更新最大子数组和
            // 如果当前子数组和 `currentSum` 大于记录的最大子数组和 `maxSum`，就更新 `maxSum`
            if (currentSum > maxSum) {
                maxSum = currentSum;  // 更新最大子数组和
            }
        }
        
        // 返回最大子数组和
        return maxSum;
    }
    
    // 主方法，用于测试
    public static void main(String[] args) {
        // 测试数组
        int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        
        // 调用 maxSubArraySum 方法，输出结果
        System.out.println(maxSubArraySum(nums)); // 输出 6
    }
}

import java.util.Arrays;

public class SelectionSort {
    public static void selectionSort(int[] array) {
        int n = array.length;

        // 遍历数组的每一个元素
        for (int i = 0; i < n - 1; i++) {
            // 假设当前元素是最小值
            int minIndex = i;

            // 找到未排序部分的最小值
            for (int j = i + 1; j < n; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }

            // 如果最小值不是当前值，则交换
            if (minIndex != i) {
                int temp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {64, 25, 12, 22, 11};
        System.out.println("排序前的数组: " + Arrays.toString(array));

        selectionSort(array);

        System.out.println("排序后的数组: " + Arrays.toString(array));
    }
}