LeetCode刷题中

最新推荐文章于 2024-12-14 16:07:01 发布

快乐的一只小喵喵

最新推荐文章于 2024-12-14 16:07:01 发布

阅读量209

点赞数

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/qq_34801169/article/details/103392043

版权

leetcode 专栏收录该内容

3 篇文章

订阅专栏

Leetcode

1. 两数之和

3、无重复字符的最长子串

53. 最大子序和

1. 两数之和

public class SumTwoNums {
    /**
     * 方法一：暴力法
     * 暴力法很简单，遍历每个元素 xx，并查找是否存在一个值与 target - xtarget−x 相等的目标元素。
     *
     * 复杂度分析：
     * 时间复杂度：O(n^2)，
       对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n)的时间。
     *空间复杂度：O(1)。
     *
     */
    public static int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                if (target == nums[i] + nums[j]) {
                    return new int[]{i, j};
                }
            }

        }
        throw new IllegalArgumentException("No two sum solution");
    }
    /**
     * 方法二：优化法
     * 在暴力法上进行了优化，遍历每个元素 x，并查找是否存在一个值与 target - x相等的目标元素。
     *
     * 复杂度分析：
     * 时间复杂度：O(n)，对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n)的时间。
     *空间复杂度：O(1)。
     *
     */
    public static int[] twoSum2(int[] arr, int target) {
        int i = arr.length - 1;//初始时,最后位置保持不变　　
        while (i > 0) {
            for (int j = 0; j < i; j++) {
                if (arr[i] + arr[j] == target) {
                    return new int[]{j, i};
                }
            }
            i--;
        }
        return null;
    }

    /**
     * 方法三：一遍哈希表
     * 事实证明，我们可以一次完成。在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。
     * 如果它存在，那我们已经找到了对应解，并立即将其返回。
     *
     * 复杂度分析：
     * 时间复杂度：O(n)，
     * 我们只遍历了包含有 nn 个元素的列表一次。在表中进行的每次查找只花费 O(1)O(1) 的时间。
     *
     * 空间复杂度：O(n)，
     * 所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 nn 个元素。
     */
    public static int[] twoSum3(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int j = target - nums[i];
            if (map.containsKey(j)) {
                return new int[]{map.get(j), i};
            }
            map.put(nums[i],i);
        }

        throw new IllegalArgumentException("No two sum solution");
    }

    //测试
    public static void main(String[] args) {
        int[] nums = {3, 2, 4};
        int target = 6;
        System.out.println(Arrays.toString(twoSum(nums, target)));
        System.out.println(Arrays.toString(twoSum2(nums, target)));
        System.out.println(Arrays.toString(twoSum3(nums, target)));
    }
}

3、无重复字符的最长子串

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> map = new HashMap<>();
        for (int end = 0, start = 0; end < n; end++) {
            char alpha = s.charAt(end);
            if (map.containsKey(alpha)) {
                start = Math.max(map.get(alpha), start);
            }
            ans = Math.max(ans, end - start + 1);
            map.put(s.charAt(end), end + 1);
        }
        return ans;
    }
}

4. 寻找两个正序数组的中位数

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    double mid  = 0.00000;
    int i=0;int j =0;int k=0;
    int[] c = new int[nums1.length + nums2.length];
    while (i < nums1.length && j < nums2.length) {
        if (nums1[i] <nums2[j]) {
             c[k++] = nums1[i++];
        } else {
             c[k++] = nums2[j++];
            }
        }
        while (i < nums1.length) {
            c[k++] = nums1[i++];
        }
        while (j < nums2.length) {
            c[k++] = nums2[j++];
        }
        mid  = c[c.length/2];
        if (c.length % 2 == 0) {
            mid =(c[c.length/2-1]+c[c.length/2])/2.00000;
        }
       return mid;
    }

}

53. 最大子序和

class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length==0){
          return 0;
        }
        int max =nums[0];
        for (int i =1;i<nums.length;i++){
            nums[i] +=Math.max(nums[i-1],0);
            max =Math.max(nums[i],max);
        }
        return max;
    }
}