leetcode刷题（1~5）

东心十

已于 2022-11-06 23:33:08 修改

阅读量656

点赞数

分类专栏： # leetcode刷题文章标签： leetcode 算法职场和发展

于 2022-10-25 23:06:37 首次发布

本文链接：https://blog.csdn.net/chekongfu/article/details/127523929

版权

leetcode刷题专栏收录该内容

17 篇文章 1 订阅

订阅专栏

前言：学生时代参加过ACM训练队，校招时也刷过leetcode，年轻时做事情没有定性，每次都是遇到问题了，挑一些相关的题目练手。
也没有持续坚持下来。工作多年，反思个人专业素养需要持续提高，这样才能应对更具挑战的任务。先定下一阶段目标，持续20周（共140天计划），每周刷5道题。为了防止以后遇到与刷过的同类型题目不能在短时间内找到思路，每次刷完5道题目，将学习成果沉淀下来，方便自己未来查缺补漏。

1 两数之和 [简单]

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

思路：使用Map<Integer, List> map 将nums数组重新存储，map中的key是数组每个元素的值，value是一个list，存储相同值得index,使用一个list是为了应对数据具有多个相同值得情况。

package leetcode.lc001;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        /**
         * key : 数组元素值
         * value: 元素下标list
         */
        Map<Integer, List<Integer>> map = new HashMap();
        for (int i = 0; i < nums.length; i++) {
            if (map.get(nums[i]) == null) {
                ArrayList<Integer> is = new ArrayList<>();
                is.add(i);
                map.put(nums[i], is);
            } else {
                map.get(nums[i]).add(i);
            }
        }

        for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
            int add1 = entry.getKey();
            int add2 = target - add1;
            if (map.get(add2) != null) {
                int[] result = new int[2];
                // 两个加数相等
                if (add1 == add2) {
                    if (map.get(add2).size() > 1) {
                        result[0] = map.get(add2).get(0);
                        result[1] = map.get(add2).get(1);
                    }
                } else {
                    int idx1 = map.get(add1).get(0);
                    int idx2 = map.get(add2).get(0);
                    result[0] = Math.min(idx1, idx2);
                    result[1] = Math.max(idx1, idx2);
                }

                return result;
            }
        }
        return null;
    }
}

2 两数相加 [简单]

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
在这里插入图片描述
思路：本题是一个简单地单链表操作，首先将两个单链表的同等地位的节点值相加，注意进位，最终将有多余高位的单链表节点值拷贝到结果链表中。

package leetcode.lc002;

class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode result = new ListNode(); // 结果链表
        ListNode cur_node = result; // 游动节点
        ListNode pre_node = cur_node;   // 当前节点的前一个节点,方便当结果链表最后一个节点值为null时，删除最后一个节点

        int flag = 0;   // 进位值
        int sum = 0;    // 同位置上的相加和
        while (l1 != null && l2 != null) {
            sum = l1.val + l2.val + flag;

            cur_node.val = sum > 9 ? sum - 10 : sum;
            flag = sum > 9 ? 1 : 0;

            l1 = l1.next;
            l2 = l2.next;

            ListNode temp = new ListNode();
            cur_node.next = temp;
            pre_node = cur_node;
            cur_node = temp;
        }

        while (l1 != null) {
            sum = l1.val + flag;

            cur_node.val = sum > 9 ? sum - 10 : sum;
            flag = sum > 9 ? 1 : 0;

            l1 = l1.next;

            ListNode temp = new ListNode();
            cur_node.next = temp;
            pre_node = cur_node;
            cur_node = temp;
        }

        while (l2 != null) {
            sum = l2.val + flag;

            cur_node.val = sum > 9 ? sum - 10 : sum;
            flag = sum > 9 ? 1 : 0;

            l2 = l2.next;

            ListNode temp = new ListNode();
            cur_node.next = temp;
            pre_node = cur_node;
            cur_node = temp;
        }

        if (flag > 0) {
            cur_node.val = flag;
        } else { // 将空节点删除
            pre_node.next = null;
        }
        return result;
    }
}

3 无重复字符的最长子串 [中等]

给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。

示例1:
输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

示例 2:
输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。

示例 3:
输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是"wke"，所以其长度为 3。
请注意，你的答案必须是子串的长度，"pwke"是一个子序列，不是子串。

思路：
1、可以穷举字符串中的每一个子字符串，然后判断每一个子字符串的长度和是否有重复字符，然后将最长的没有重复字符的字符串返回。
2、在字符长上搞一个滑动窗口，如果新添加进来的字符不和已存在的字符相同，则滑动窗口的right向右边移动一位，如果造成重复，则当前字符串就不满足了，需要将left向右边移动一位（去掉最最左边字符）。

package leetcode.lc003;

import java.util.LinkedHashMap;
import java.util.Map;

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s == null || s == "") {
            return 0;
        }

        int maxLen = 0;
        /**
         * key: 字符串中每个位置上的值
         * value: 值对应的索引位
         */
        Map<Character, Integer> map = new LinkedHashMap<>();
        int end = 0; // 记录尝试添加到新字符串中的字符位置，如果添加之后有重复，下一个字符串从新尝试添加该索引位的字符
        for (int left = 0; left < s.length(); left++) {
            for (int right = end; right < s.length(); right++) {
                map.put(s.charAt(right), right);
                end = right;

                // 添加新字符之后，与之前添加的字符有重复 或者 添加到最后一个字符
                if (map.size() != (right - left + 1) || end == s.length() - 1) {
                    if (maxLen < map.size()) {
                        maxLen = map.size();
                    }
                    break;
                }
            }

            // map 中第一个字符没有被新添加的字符覆盖
            if (map.get(s.charAt(left)) == left) {
                map.remove(s.charAt(left));
            }
        }
        return maxLen;
    }
}

4. 寻找两个正序数组的中位数【困难】

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。
算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

思路：本题的难点在于时间复杂度限制在O(log (m+n)) ，很容易联想到二分法。

一组数有x数字，如果将该x个数字切分成两部分，共有x种切分方法，分别是{}|{m₁…m_x},{m₁},{m₂…m_x},…{m₁,m_x-1}|{m_x},{m₁,m_x}|{}，上例表示分别在0,1,2…x处进行分割。

针对两组有序数组m,n,将两组数分别分割成两部分，分别表示m_left, m_right, n_left, n_right,要求左半部分和右半部分相等，或者左半部分比有半部分多一个，即|m_left + n_left| - |m_right + n_right| <=1。(1)

假设m是在i处分割，n在j处分割，还需要满足m_i-1<=n_j, n_j-1<=m_i

工式（1）分为两种情况，当|m| + |n|为奇数时，有
$i + j = ∣ m ∣ - i + ∣ n ∣ - j + 1$ 即 $i+j=\frac{|m|+|n|+1}{2}$

当|m| + |n|为偶数时
有 $i + j = ∣ m ∣ - i + ∣ n ∣ - j$ 即 $i+j=\frac{|m|+|n|}{2}$
按条件|m| + |n|为偶数，为了和|m| + |n|为奇数情况统一，有 $i+j=\frac{|m|+|n|}{2}=\frac{|m|+|n|+1}{2}$

为了满足（1）的同时满足（2），假设在满足（1）的情况下找到一个最大的i满足 m_i-1<=n_j,
按上述假设在i+1处分割m，就不会满足m_i<=n_j-1,必有 n_j-1 < m_i

综上，使用二分法，找到最大的i满足公式（1）、公式（2）即可

package leetcode.lc004;


class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len1 = nums1.length;
        int len2 = nums2.length;

        int[] temp = null;

        if (len1 > len2) {
            return findMedianSortedArrays(nums2, nums1);
        }

        int i = 0;
        int j = 0;
        int start = 0, end = len1;
        int left_max = 0;
        int right_min = 0;

        // 二分查找的目的是为了找一个最大的i满足
        // nums1_left_right <= nums2_right_left
        // nums2_left_right <= nums1_right_left
        while (start <= end) {
            // 不写成 (start+end)/2是为了防止内存溢出
            i = start + (end - start) / 2;
            j = len1 + (len2 + 1 - len1) / 2 - i;

            // nums1 左半部分最右边的数
            int nums1_left_right = (i == 0 ? Integer.MIN_VALUE : nums1[i - 1]);

            // nums1 右半部分最左边的数
            int nums1_right_left = (i == len1 ? Integer.MAX_VALUE : nums1[i]);

            // nums2 左半部分最右边的数
            int nums2_left_right = (j == 0 ? Integer.MIN_VALUE : nums2[j - 1]);

            // nums2 右半部分最左边的数
            int nums2_right_left = (j == len2 ? Integer.MAX_VALUE : nums2[j]);

            // nums1 最左边数比nums2 最右边数大
            if (nums1_left_right <= nums2_right_left) {
                left_max = Math.max(nums1_left_right, nums2_left_right);
                right_min = Math.min(nums1_right_left, nums2_right_left);
                start = i + 1;
            } else {
                end = i - 1;
            }
        }
        return (len1 + len2) % 2 == 0 ? (left_max + right_min) / 2.0 : left_max;
    }
}

测试用例

package leetcode.lc004;

import org.junit.Test;

public class Main {
    Solution s = new Solution();

    @Test
    public void test01() {
        int[] nums1 = {1, 3};
        int[] nums2 = {2};
        System.out.println(s.findMedianSortedArrays(nums1, nums2));
    }

    @Test
    public void test02() {
        int[] nums1 = {1, 2};
        int[] nums2 = {3, 4};
        System.out.println(s.findMedianSortedArrays(nums1, nums2));
    }

    @Test
    public void test03() {
        int[] nums1 = {1, 2};
        int[] nums2 = {4, 5, 9};
        System.out.println(s.findMedianSortedArrays(nums1, nums2));
    }

    @Test
    public void test04() {
        int[] nums1 = {2};
        int[] nums2 = {};
        System.out.println(s.findMedianSortedArrays(nums1, nums2));
    }
}

5 最长回文子串 [中等]

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：
输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。

示例 2：
输入：s = “cbbd”
输出：“bb”

思路：动态规划，关键是找到状态转移方程，P(i,j)表示index起始点为i,结束点为j的子串是回文串。
那么有p(i,j) = p (i+1, j-1) && s[i] == s[j]
注意边界条件，当s[i] == s[j]，s_i,j长度为2或者3时，直接判定时回文串，也就是j-i+1<=3,j-i<=2
当j-i>2时，则需要使用状态转移方程判断

以下是具体判断BABADABAC字符串回文状态表：
在这里插入图片描述

package leetcode.lc005;

class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }

        int maxLen = 1;
        int begin = 0;

        boolean[][] dp = new boolean[len][len];
        char[] charArray = s.toCharArray();

        for (int i = 0; i < len; i++) {
            dp[i][i] = true;
        }

        // 右边界
        for (int right_index = 0; right_index < len; right_index++) {
            // 左边界
            for (int left_index = right_index; left_index >= 0; left_index--) {
                if (charArray[left_index] == charArray[right_index]) {
                    if (right_index - left_index + 1 > 3 && !dp[left_index + 1][right_index - 1]) {
                        dp[left_index][right_index] = false;
                    } else {
                        dp[left_index][right_index] = true;

                        if (right_index - left_index + 1 > maxLen) {
                            begin = left_index;
                            maxLen = right_index - left_index + 1;
                        }
                    }

                } else {
                    dp[left_index][right_index] = false;
                }
            }
        }

        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < dp[0].length; j++) {
                System.out.print(dp[i][j] + "\t");
            }
            System.out.println();
        }
        return s.substring(begin, begin + maxLen);
    }
}

package leetcode.lc005;

import org.junit.Test;

public class Main {

    Solution s = new Solution();

    @Test
    public void test01() {
        String str = "babad";
        System.out.println(s.longestPalindrome(str));
    }

    @Test
    public void test02() {
        String str = "cbbd";
        System.out.println(s.longestPalindrome(str));
    }

    @Test
    public void test03() {
        String str = "aaaa";
        System.out.println(s.longestPalindrome(str));
    }
}