LeetCode数组入门

题目一:

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

思路：取出数组的第一个元素，依次和数组内其他元素比较看相加是否为Target,取出数组第二个元素依次和除了第一个元素比较看相加是否为Target,以此内推......... 我也是我想到的O()的笨办法.....

public static ArrayList<Integer> find(int arr[], int target){
        ArrayList<Integer> result=new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            for (int j=i+1; j < arr.length; j++) {  //j的下表永远比i大1
                if (arr[i] + arr[j] == target) {
                    result.add(i);
                    result.add(j);
                    return  result;
                }
            }
        }
        return  result;
    }

同时题目要求给出时间复杂度为O(n)的方法

思路：可以使用一个字典（哈希表）来存储已经遍历过的元素及其索引，以便在内层循环中快速查找差值是否存在于字典中，从而将时间复杂度降低到O(n) 

import java.util.ArrayList;
import java.util.HashMap;

public static ArrayList<Integer> find(int arr[], int target) {
    // 创建一个ArrayList用于存储结果
    ArrayList<Integer> result = new ArrayList<>();
    // 创建一个HashMap，用于存储数组元素及其索引
    HashMap<Integer, Integer> numIndices = new HashMap<>();

    // 遍历整数数组
    for (int i = 0; i < arr.length; i++) {
        // 计算当前元素与目标值之间的差值
        int complement = target - arr[i];
        
        // 检查差值是否在HashMap中存在，如果存在，说明找到了两个元素的和等于目标值
        if (numIndices.containsKey(complement)) {
            // 将两个元素的索引加入结果ArrayList
            result.add(numIndices.get(complement)); // 存储第一个元素的索引
            result.add(i); // 存储第二个元素的索引
            break; // 找到答案后，退出循环
        }
        
        // 将当前元素及其索引添加到HashMap中
        numIndices.put(arr[i], i);
    }

    // 返回包含两个元素索引的结果ArrayList，如果没有找到答案，则ArrayList为空
    return result;
}

         使用HashMap来存储已经遍历过的数组元素以及它们的索引，以便在内层循环中快速查找差值是否存在于HashMap中。如果找到满足条件的索引，就将这两个索引加入结果ArrayList中并返回。如果没有找到满足条件的索引，返回一个空的ArrayList。

 

 题目二

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

具体思路如下：

1. 确保 nums1 数组的长度小于等于 nums2 数组的长度，如果不是，则交换它们，以确保总是对较短的数组进行二分查找。

2. 使用二分查找在较短的数组中选择一个分割点，将较短的数组分为两部分，使得左边部分的元素都小于等于右边部分的元素。

3. 在较长的数组中找到一个对应的分割点，使得左边部分的元素都小于等于右边部分的元素，同时要保证左边部分的元素个数等于右边部分的元素个数或多一个（当总元素个数为奇数时）。

4. 计算中位数：如果总元素个数是偶数，则取两个分割点的右侧部分的最小值和左侧部分的最大值的平均值；如果总元素个数是奇数，则取两个分割点中的较大值。

 

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    // 确保 nums1 数组的长度小于等于 nums2 数组的长度，如果不是，则交换它们
    if (nums1.length > nums2.length) {
        int[] temp = nums1;
        nums1 = nums2;
        nums2 = temp;
    }
    
    int m = nums1.length; // nums1 数组的长度
    int n = nums2.length; // nums2 数组的长度
    int left = 0, right = m; // 二分查找的左边界和右边界

    while (left <= right) {
        int partitionX = (left + right) / 2; // 在 nums1 中选择的分割点
        int partitionY = (m + n + 1) / 2 - partitionX; // 在 nums2 中对应的分割点

        // 计算四个关键值，分别是分割点左侧的最大值 (maxX)、分割点左侧的最大值 (maxY)、
        // 分割点右侧的最小值 (minX)、分割点右侧的最小值 (minY)
        int maxX = (partitionX == 0) ? Integer.MIN_VALUE : nums1[partitionX - 1];
        int maxY = (partitionY == 0) ? Integer.MIN_VALUE : nums2[partitionY - 1];
        int minX = (partitionX == m) ? Integer.MAX_VALUE : nums1[partitionX];
        int minY = (partitionY == n) ? Integer.MAX_VALUE : nums2[partitionY];

        // 检查是否找到了合适的分割点，使得左侧部分的元素都小于等于右侧部分的元素
        if (maxX <= minY && maxY <= minX) {
            if ((m + n) % 2 == 0) {
                // 总元素个数为偶数时，返回左侧部分的最大值和右侧部分的最小值的平均值
                return (Math.max(maxX, maxY) + Math.min(minX, minY)) / 2.0;
            } else {
                // 总元素个数为奇数时，返回左侧部分的最大值
                return Math.max(maxX, maxY);
            }
        } else if (maxX > minY) {
            // 如果 maxX 大于 minY，说明分割点在 nums1 中太靠右，需要左移
            right = partitionX - 1;
        } else {
            // 否则，分割点在 nums1 中太靠左，需要右移
            left = partitionX + 1;
        }
    }

    // 如果执行到这里，说明输入数组没有按照升序排列，抛出异常
    throw new IllegalArgumentException("Input arrays are not sorted.");
}

这段代码使用二分查找来在两个已排序数组中找到中位数，同时处理了奇数和偶数个元素的情况

值得思考！