力扣爆刷第110天之CodeTop100五连刷36-40

力扣爆刷第110天之CodeTop100五连刷36-40

一、94. 二叉树的中序遍历

题目链接：https://leetcode.cn/problems/binary-tree-inorder-traversal/description/
思路：基础中序遍历。

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

二、1143. 最长公共子序列

题目链接：https://leetcode.cn/problems/longest-common-subsequence/description/
思路：定义dp[i][j]表示以text1[i]和text2[j]为结尾的最长公共子序列，利用这个定义，进行状态推导，如果结尾元素相等，自然各由上一个位置推出，dp[i][j] = dp[i-1][j-1] + 1。不等，考虑的是这两个子序列各减一个位置，找最长的。dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
       int m = text1.length(), n = text2.length();
       int[][] dp = new int[m+1][n+1];
       for(int i = 1; i <= m; i++) {
           for(int j = 1; j <= n; 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-1][j], dp[i][j-1]);
               }
           }
       }
       return dp[m][n];
    }
}

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

题目链接：https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii/description/
思路：删除重复元素，使用三个指针，分别是pro、p、pre，其中pro记录要删除节点的前一个节点，p第一个节点，pre用于向后遍历。整体逻辑就是遇到相等的就找到下一个不等的元素，然后删除相等元素，遇到不等的三指针同步前进。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null) return head;
        ListNode root = new ListNode(-1, head);
        ListNode p = head, pre = head.next, pro = root;
        while(pre != null) {
            if(p.val == pre.val) {
                while(pre != null && pre.val == p.val) {
                    pre = pre.next;
                }
                pro.next = pre;
                p = pre;
                if(pre != null) pre = pre.next;
            }else{
                pro = p;
                p = pre;
                pre = pre.next;
            }
        }
        return root.next;
    }
}

四、199. 二叉树的右视图

题目链接：https://leetcode.cn/problems/binary-tree-right-side-view/description/
思路：记录一个全局参数即最大深度，既然是右视图，自然遍历顺序是右、中、左，然后向下递归深度大于最大深度，说明是第一次到达，记录数据，然后更新深度。

class Solution {
    int max = -1;
    List<Integer> list = new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
       traverse(root, 0);
       return list;
    }
    
    void traverse(TreeNode root, int deep) {
        if(root == null) return;
        if(max < deep) {
            list.add(root.val);
            max = deep;
        }
        traverse(root.right, deep+1);
        traverse(root.left, deep+1);
    }

}

五、704. 二分查找

题目链接：https://leetcode.cn/problems/binary-search/description/
思路：二分查找典型题目没什么好说的。

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length-1;
        while(left <= right) {
            int mid = left + (right - left) / 2;
            if(nums[mid] == target) {
                return mid;
            }else if(nums[mid] > target) {
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }    
        return -1;
    }
}