更多答案也可以关注我的GitHub算法仓库——Algorithm

(大家可以根据我每道题打的星来衡量这道题的难易,星越少越难)

所有代码都是在力扣上提交通过的,保证代码的正确无误

基础数据结构:

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 TreeNode {
       int val;
       TreeNode left;
       TreeNode right;
       TreeNode() {}
       TreeNode(int val) { this.val = val; }
       TreeNode(int val, TreeNode left, TreeNode right) {
           this.val = val;
           this.left = left;
           this.right = right;
       }
    }

8.字符串转换整数 (atoi)

自动机
我的代码就是根据题意一步一步判断的,所以非常臃肿,但是根据官方给的自动机解法暂时还没看懂

public int myAtoi(String s) {
    int j = 0;
    for (; j < s.length();) {
        if (s.charAt(j) == ' ') {
            j++;
        }else {
            break;
        }
    }
    s = s.substring(j);
    if (s.length() <= 0) {
        return 0;
    }
    boolean isNegative = false;
    int i = 0, res = 0;
    if (s.charAt(0) == '-' || s.charAt(0) == '+') {
        if (s.charAt(0) == '-') {
            isNegative = true;
        }
        i = 1;
    }
    for (; i < s.length();) {
        if (s.charAt(i) == '0') {
            i++;
        }else {
            break;
        }
    }
    StringBuilder sb = new StringBuilder("");
    for (; i < s.length(); i++) {
        if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
            sb.append(s.charAt(i));
        }else {
            break;
        }
    }
    String str = sb.toString();
    if (str.length() != 0) {
        if (str.length() > 10) {
            if (isNegative) {
                return Integer.MIN_VALUE;
            }
            return Integer.MAX_VALUE;
        }else {
            long l = Long.valueOf(str);
            if (l > Integer.MAX_VALUE) {
                if (isNegative) {
                    return Integer.MIN_VALUE;
                }
                return Integer.MAX_VALUE;
            }else {
                if (isNegative) {
                    return -1*Integer.valueOf(str);
                }
                return Integer.valueOf(str);
            }
        }
    }
    return res;
}

2.两数相加

话说真快被链表题搞懵了呀,这个我也是按照纯模拟加法的思路写的,先去判断哪个链表长,然后哦就把短的依次加到长的上面,还要注意进位问题。

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode cul1 = l1;
    ListNode cul2 = l2;
    int l1_len = 0;
    int l2_len = 0;
    while (cul1 != null || cul2 != null) {
        if (cul1 != null) {
            l1_len++;
            cul1 = cul1.next;
        }
        if (cul2 != null) {
            l2_len++;
            cul2 = cul2.next;
        }
    }
    ListNode lon = l1;
    ListNode shor = l2;
    if (l2_len > l1_len) {
        lon = l2;
        shor = l1;
    }
    int yu = 0;
    while (shor != null) {
        lon.val += (shor.val+yu);
        if (lon.val >= 10) {
            yu = 1;
            lon.val -=10;
        }else {
            yu = 0;
        }
        shor = shor.next;
        if (lon.next == null && yu == 1) {
            lon.next = new ListNode(0);
        }
        lon = lon.next;
    }
    while (yu == 1) {
        lon.val += 1;
        if (lon.val >= 10) {
            yu = 1;
            lon.val -= 10;
            if (lon.next == null) {
                lon.next = new ListNode(0);
            }
            lon = lon.next;
        }else {
            yu = 0;
        }
    }
    if (l2_len > l1_len) {
        return l2;
    }
    return l1;
}

82.删除排序链表中的重复元素 II

判断当前节点的下一个节点与下下一个节点的值,相等则不断调整当前节点的next,不相等则向后移动;这里引入头节点方便对首元节点的操作。

public ListNode deleteDuplicates(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode fake = new ListNode();
    fake.next = head;
    ListNode cur = fake;
    while (cur.next != null && cur.next.next != null) {
        if (cur.next.val == cur.next.next.val) {
            int x = cur.next.val;
            while (cur.next != null && cur.next.val == x) {
                cur.next = cur.next.next;
            }
        }else {
            cur = cur.next;
        }
    }
    return fake.next;
}

144.二叉树的前序遍历

class Solution {
    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        dfs(root);
        return list;
    }
    public void dfs (TreeNode root) {
        if (root != null) {
            list.add(root.val);
            dfs(root.left);
            dfs(root.right);
        }
    }
}

148.排序链表

这道题思路是归并,但是有两个归并思路:

  • 递归着归并,先找中点(使用快慢指针),一次分一半,递归,一次分一半,递归....然后两两合并并返回
  • 先设归并长度为1,第一波归并完再把归并长度乘2,再归并,以此类推

(本体采用自顶向下的递归方式)

class Solution {

    public ListNode sortList(ListNode head) {
        return sort(head, null);
    }

    private ListNode sort(ListNode start, ListNode end) {
        if (start == end) {
            return start;
        }
        ListNode fast = start, slow = start;
        while (fast != end && fast.next != end) {
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode l2 = sort(slow.next, end);
        slow.next = null;
        ListNode l1 = sort(start, slow);
        return mergeTwoLists(l1, l2);
    }

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null || l2 == null) {
            return l1 == null ? l2 : l1;
        }
        if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        }else {
            l2.next = mergeTwoLists(l2.next, l1);
            return l2;
        }
    }
}

31.下一个排列

  • 倒着遍历第一次找到第一个值变小的,记录坐标为i
  • 倒着遍历第二次找到刚好比nums[i]大的坐标j
  • 交换i,j并翻转i+1到结尾的数字
class Solution {
    public void nextPermutation(int[] nums) {
        int i = nums.length - 2;
        while (i >= 0 && nums[i] >= nums[i+1]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.length - 1;
            while (j > i && nums[j] <= nums[i]) {
                j--;
            }
            swap(nums, i, j);
        }
        for (int x = i+1, y = nums.length-1; x < y;) {
            swap(nums, x, y);
            x++;
            y--;
        }
    }

    private void swap (int[] nums, int i, int j) {
        int swap = nums[i];
        nums[i] = nums[j];
        nums[j] = swap;
    }
}

76.最小覆盖子串

思路:滑动窗口(左右指针l,r),用两个常量数组判断当前字符串是否包含模式串('a'~'Z'可以用长度60存下)

  • 不包含,r++;包含,l++,并更新结果
    (这道题虽然是困难,但是思路还是比较容易懂的)
public String minWindow(String s, String t) {
    String res = "";
    int[] sarr = new int[60];
    int[] tarr = new int[60];
    for (int i = 0; i < t.length(); i++) {
        tarr[t.charAt(i) - 'A']++;
    }
    int l = 0, r = 0;
    while (l <= r) {
        boolean isHave = true;
        for (int j = 0; j < 60; j++) {
            if (sarr[j] < tarr[j]) {
                isHave = false;
                break;
            }
        }
        if (isHave) {
            String temp = s.substring(l, r);
            if (res.length() == 0) {
                res = temp;
            }else {
                res = temp.length() < res.length() ? temp:res;
            }
            sarr[s.charAt(l) - 'A']--;
            l++;
        }else if (r < s.length()) {
            sarr[s.charAt(r) - 'A']++;
            r++;
        }else {
            break;
        }
    }
    return res;
}

151.翻转字符串里的单词

常规字符串算法题,比较简单,借助java的trim()split()函数,使用StringBuilder快速追加

public String reverseWords(String s) {
    StringBuilder sb = new StringBuilder("");
    s = s.trim();
    String[] arr = s.split(" ");
    for (int i = arr.length - 1; i > 0; i--) {
        if (arr[i].length() != 0) {
            sb.append(arr[i] + " ");
        }
    }
    sb.append(arr[0]);
    return sb.toString();
}

72. 编辑距离

这里提供了两种方法:自底向上的递归和自顶向下的动规,但是递归会超时,动规就是记录了子问题的结果避免重复计算。

  • dp[i][j]的意思是word1.subString(0, i)变为word2.subString(0, j)所需的步数
  • 根据题目中给的三种操作我们可以推出核心的动态转移方程为:
    dp[i+1][j+1] = 1 + Math.min(Math.min(dp[i][j+1], dp[i+1][j]), dp[i][j]);
    这里由于下标从1开始到length,避免数组越界所以使下一个用当前的值
    这是一道经典的动态规划题目,值得反复练习
class Solution {
    public int minDistance(String word1, String word2) {
        int l1 = word1.length();
        int l2 = word2.length();
        int[][] dp = new int[l1 + 1][l2 + 1];
        for (int i = 0; i < l1 + 1; i++) {
            dp[i][0] = i;
        }
        for (int i = 0; i < l2 + 1; i++) {
            dp[0][i] = i;
        }
        for (int i = 0; i < l1; i++) {
            for (int j = 0; j < l2; j++) {
                if (word1.charAt(i) == word2.charAt(j)) {
                    dp[i+1][j+1] = dp[i][j]; //一样则无需多余操作步数
                }else {
                    dp[i+1][j+1] = 1 + Math.min(Math.min(dp[i][j+1], dp[i+1][j]), dp[i][j]);
                }
            }
        }
        return dp[l1][l2];
    }
    //递归(超时)
    public int minDistance_recursion(String word1, String word2) {
        if (word1.length() == 0 || word2.length() == 0) {
            return Math.max(word1.length(), word2.length());
        }
        if (word1.charAt(word1.length()-1) == word2.charAt(word2.length()-1)) {
            return minDistance_recursion(word1.substring(0, word1.length()-1),
                    word2.substring(0, word2.length()-1));
        }
        return 1 + Math.min(Math.min(minDistance_recursion(word1, word2.substring(0, word2.length()-1)),
                minDistance_recursion(word1.substring(0, word1.length()-1), word2)),
                minDistance_recursion(word1.substring(0, word1.length()-1),word2.substring(0, word2.length()-1)));
    }
}

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

这道题目有两个思路:

  • 合并两个有序数组,再直接输出中位数,时间复杂度O(m+n),空间复杂度O(m+n)
  • 划分数组+推导,时间复杂度O(logmin(m,n))),空间复杂度O(1),但是这个暂时还没搞懂
class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int l1 = nums1.length;
        int l2 = nums2.length;
        int l3 = l1+l2;
        int[] arr = new int[l3];
        for (int i = 0; i < l1; i++) {
            arr[i] = nums1[i];
        }
        merge(arr, l1, nums2, l2);
        if (l3 % 2 == 1) {
            return arr[l3/2];
        }
        return ((float)(arr[l3/2-1]+arr[l3/2]))/2;
    }

    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int n1 = m -1;
        int n2 = n -1;
        while (n2 >= 0) {
            if (n1 >= 0 && nums1[n1] >= nums2[n2]) {
                nums1[n1+n2+1] = nums1[n1];
                n1--;
            }else {
                nums1[n1+n2+1] = nums2[n2];
                n2--;
            }
        }
    }
}

129.求根节点到叶节点数字之和

深度优先搜索,使用StringBuilder记录路径上节点的值,再判断左右孩子为空时,将其转换成Integer。递归返回前去除 StringBuilder的最后一个字符

class Solution {
    private StringBuilder sb = new StringBuilder();
    private int res = 0;
    public int sumNumbers(TreeNode root) {
        if (root != null) {
            sb.append(root.val);
            if (root.left == null && root.right == null) {
                res += Integer.valueOf(sb.toString());
            }else {
                sumNumbers(root.left);
                sumNumbers(root.right);
            }
            sb.deleteCharAt(sb.length()-1);
        }
        return res;
    }
}

104.二叉树的最大深度

二叉树必需掌握的题,数据结构教材上的原题

public int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    } else {
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

105.从前序与中序遍历序列构造二叉树

前序遍历和中序遍历的概念这里就不说了,其实推的时候很容易发现是一个递归的过程,有关于递归下标的计算如图:

class Solution {

    private HashMap<Integer, Integer> map = new HashMap<>();

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i], i);
        }
        return buildTree(preorder, 0, preorder.length - 1, 0, inorder.length - 1);
    }

    public TreeNode buildTree(int[] preorder, int preLeft, int preRight, int inLeft, int inRight) {
        if (preLeft > preRight || inLeft > inRight) {
            return null;
        }
        int val = preorder[preLeft];
        TreeNode node = new TreeNode(val);
        int pIndex = map.get(val);
        node.left = buildTree(preorder, preLeft+1, pIndex - inLeft + preLeft, inLeft, pIndex - 1);
        node.right = buildTree(preorder, pIndex - inLeft + preLeft + 1, preRight, pIndex + 1, inRight);
        return node;
    }
}

239.滑动窗口最大值

这道题一开始很容易想到使用优先队列来解决,但是写完检测却发现超时了,看题解是使用的单调队列(递增、递减的队列)

  • 定义一个双端队列,存储数组下标,那么队首的值就是nums[queue.peekFirst()],存下标主要就是为了方便判断队列队首元素是否已经在滑动窗口外:queue.peekFirst() < left,队首元素对应数组值最大,依次递减。
  • 定义右指针right从 0 到nums.length()-1,就很容易计算窗口的左指针leftright - k + 1
  • 如果一个元素入队(入队都是从队尾入),则说明它在窗口内,那么队列内比该值小的则永远不会加入到最终答案res内,直到该元素出窗口,所以我们把队列内比该元素小的值出队。保证队列的一个单调递减。
  • 最后一个right + 1 >= k是因为这时最初的窗口才刚刚形成,满足长度为k,才能添加。
    class Solution {
        //单调队列
        public int[] maxSlidingWindow(int[] nums, int k) {
            int[] res = new int[nums.length-k+1];
            ArrayDeque<Integer> queue = new ArrayDeque<>();
            for (int right = 0; right < nums.length; right++) {
                while (queue.size() > 0 && nums[right] > nums[queue.peekLast()]) {
                    queue.pollLast();
                }
                queue.offerLast(right);
                int left = right - k + 1;
                if (left > queue.peekFirst()) {
                    queue.pollFirst();
                }
                if (right + 1 >= k) {
                    res[left] = nums[queue.peekFirst()];
                }
            }
            return res;
        }
        //优先队列(超时)
        public int[] maxSlidingWindow_PriorityQueue(int[] nums, int k) {
            PriorityQueue<Integer> queue = new PriorityQueue<>((a,b)-> b-a);
            int[] res = new int[nums.length-k+1];
            for (int i = 0; i < k; i++) {
                queue.offer(nums[i]);
            }
            res[0] = queue.peek();
            for (int i = k, j = 0; i < nums.length; i++,j++) {
                queue.offer(nums[i]);
                queue.remove(nums[j]);
                res[j+1] = queue.peek();
            }
            return res;
        }
    }

93.复原 IP 地址

一个字符串,分成四部分,我就懒省事直接暴力dfs了,枚举出来所有分割情况再做判断

class Solution {
    private List<String> res = new ArrayList<>();
    private String param;
    public List<String> restoreIpAddresses(String s) {
        param = s;
        dfs("", 0, 1);
        return res;
    }
    public void dfs (String s, int index, int count) {
        if (count >= 4) {
            if (judge(index, param.length())) {
                res.add(s + param.substring(index));
            }
        }else {
            for (int i = 1; i <= 3; i++) {
                if ((index + i) <= param.length() && judge(index, index+i)) {
                    dfs(s+param.substring(index, index+i)+".", index+i, count + 1);
                }
            }
        }
    }
    public boolean judge (int start, int end) {
        String temp = param.substring(start, end);
        if (temp.length() <= 3 && temp.length() != 0) {
            int val = Integer.valueOf(temp);
            if (String.valueOf(val).length() == temp.length() && val <= 255) {
                return true;
            }
        }
        return false;
    }
}

113.路径总和 II

这道题和前面的 129.求根节点到叶节点数字之和 基本一致,都是dfs+回溯即可

class Solution {
    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> cur = new ArrayList<>();
    private int sum = 0;
    private int target = 0;

    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        target = targetSum;
        dfs(root);
        return res;
    }

    public void dfs (TreeNode root) {
        if (root != null) {
            sum += root.val;
            cur.add(root.val);
            if (root.left == null && root.right == null) {
                if (sum == target) {
                    List<Integer> temp = new ArrayList<>();
                    for (int i = 0; i < cur.size(); i++) {
                        temp.add(cur.get(i));
                    }
                    res.add(temp);
                }
            }else {
                dfs(root.left);
                dfs(root.right);
            }
            sum -= root.val;
            cur.remove(cur.size()-1);
        }
    }
}

110.平衡二叉树

平衡二叉树的定义本身就是一个递归的定义:左右子树深度只差的绝对值不超过1,并且左右子树也是平衡的

class Solution {
    public boolean isBalanced(TreeNode root) {
        if (root != null) {
            return Math.abs(height(root.left) - height(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
        }
        return true;
    }

    public int height (TreeNode root) {
        if (root == null) {
            return 0;
        } else {
            return Math.max(height(root.left), height(root.right)) + 1;
        }
    }
}

1143.最长公共子序列

典型的二维动规,dp[i][j]代表text[0...i]text[0...j]的最长公共子序列,所以可以推导出动态转移方程为:


其实到这里我们可以发现有关于两个字符串之间的动态规划题目,基本都是一个二维数组dp,两个for循环里面一个状态转移方程,更新数组,最后返回数组的最后一个值,这就是动规模板。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] dp = new int[text1.length()+1][text2.length()+1];
        for (int i = 1; i <= text1.length(); i++) {
            for (int j = 1; j <= text2.length(); j++) {
                if (text1.charAt(i-1) == text2.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1]+1;
                }else {
                    dp[i][j] = Math.max(dp[i][j-1], dp[i-1][j]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }
}

470.用 Rand7() 实现 Rand10()

古典概型

  • 第一次rand7限定[1,2],判断奇偶性,概率是1/2,其实first的作用就是生成概率为1/2的奇偶。
    (我们还可以通过限定[1,3],再取模3进行概率为1/3的操作)
  • 第二次rand7限定[1,5],概率是1/5,加上5为[6,10],概率也是1/5
  • 二者结合可以得出10种概率相同的结果

借助这个思路我们也可以构造出其他的

/**
 * The rand7() API is already defined in the parent class SolBase.
 * public int rand7();
 * @return a random integer in the range 1 to 7
 */
class Solution extends SolBase {
    public int rand10() {
        int first,second;
        while ((first = rand7()) > 2);
        while ((second = rand7()) > 5);
        return first%2 == 0 ? second : second+5;
    }
}

543.二叉树的直径

这道题跟计算二叉树的深度还不太一样,是求任意两个节点的最大路径,可以不过根节点。递归的同时对结果更新要注意:

class Solution {
    private int res = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        height(root);
        return res-1;
    }
    public int height (TreeNode root) {
        if (root != null) {
            int l = height(root.left);
            int r = height(root.right);
            res = Math.max(res, l+r+1);
            return Math.max(l,r)+1;
        }
        return 0;
    }
}
最后修改:2021 年 11 月 20 日