leetcode mt simple

Leetcode-MT-Simple

文章实际写于2021年，那个炎热的夏天。

Leet Code 美团题库简单类总结，题目按照解法可大致分为数学法、计数法、位运算、双指针法、字符串、哈希表、栈、递归/迭代、排序法、匹配法、记忆化法、二分法、分治法、摩尔投票法、前缀和、模拟法、动态规划几大类。大部分题目可以有多种解法。

数学法、计数法、位运算、双指针法、字符串、哈希表、栈、递归/迭代、排序法、匹配法、记忆化法、二分法、分治法、摩尔投票法、前缀和、模拟法、动态规划

数学法： 即利用 +、-、*、/、% 等数学思想来解决，一般结合递归/迭代使用。
计数法： 即通过统计元素个数来解决。如字符串中的字母个数，数组中的元素个数。
位运算： 即通过 &、|、^、<<、>> 等位运算来解决。
双指针法： 即通过两个指针来解决。两个指针可以同时从前往后，也可以从后往前，也可以一个双向奔赴，还有快慢指针法。
字符串： 即利用字符串相关类的相关函数来解决。如 String 中的 substring()、replace()、split() 等方法；StringBuilder 的 reverse() 等方法。
哈希表： 即利用哈希表的相关特性来解决。如 map key 的唯一性、set 的去重及其 contains() 方法等功能。
栈：即利用栈先进后出的特性来解决。
递归/迭代： 递归/迭代可以配合大部分解法使用，在链表、树等数据结构中最常用。
排序法： 即利用排序或排序的某些特性来解决。如归并排序中的合并功能，快排思想等。
匹配法： 即字符串匹配。
记忆化法： 记忆化搜索与动态规划类似。
二分法： 即二分法。
分治法： 即分治法，分而治之。
摩尔投票法： 类似于计数法，一换一的思想。
前缀和： 就是前缀和。
模拟法： 那也就是模拟法。
动态规划： 遇事不决，动态规划。

1、数学法

1.1、整数

9、回文数
回文数指一个整数，正序读和倒序读都是一样的整数。

// 数学法、双指针法、哈希表
// 数学法
public static boolean isPalindrome(int n) {
    if (n < 0) {
        return false;
    }
    if (n < 10) {
        return true;
    }
    int temp = 0, m = n;
    while ( m != 0) {
        temp = temp * 10 + m % 10;
        m /= 10;
    }
    return temp == n;
}

202、快乐数
对于一个整数，每一次都将其替换为其每个位置上的数字的平方和，直到变为 1，则说明其是快乐数，也有可能便不到 1，一直无限循环。

// 数学法、双指针法、哈希表
// 数学法 + 哈希表
public static boolean isHappy(int n) {
    List<Integer> list = new ArrayList<>();
    while (true) {
        if (n == 1) {
            return true;
        }
        if (list.contains(n)) {
            return false;
        }
        list.add(n);
        int sum = 0;
        while (n > 0) {
            sum += Math.pow(n % 10, 2);
            n /= 10;
        }
        n = sum;
    }
}

interview-16-05、阶乘尾数
给定一个整数 n，求其 n 阶乘有多少个尾随零。

// 数学法、递归/迭代
// 数学法 + 迭代
// 只有 2 和 5 相乘等于 10，也就是只有 2 和 5 的乘积结果会出现 0，0 ~ 10 以内 5 不可以作为任何树的因数，所以化解为求 n 由多少个 5 组成
public static int trailingZeroes(int n) {
    int temp = 0;
    while (n > 0) {
        n /= 5;
        temp += n;
    }
    return temp;
}

1.2、字符串

415、字符串相加；二进制相加、链表相加
给定两个字符串形式的数，求其和。

// 数学法
// 字符串相加、二进制相加、链表相加 都可以用此方法求解
public static String add(String a, String b) {
    char[] m = a.toCharArray();
    char[] n = b.toCharArray();
    StringBuilder sb = new StringBuilder();
    int i = m.length - 1, j = n.length - 1, carry = 0;
    while (i >= 0 || j >= 0 || carry != 0) {
        carry += i >= 0 ? m[i--] - '0' : 0;
        carry += j >= 0 ? n[j--] - '0' : 0;
        sb.append(carry % 10);
        carry /= 10;
    }
    return sb.reverse().toString();
}

461、汉明距离
汉明距离是值两个整数，其对应二进制的值的位不同的个数。

// 数学法、动态规划
// 数学法
public static int hanmingDistance(int m, int n) {
    int length = 0;
    while (m != 0 || n != 0) {
        if (m % 2 != n % 2) {
            length++;
        }
        m /= 2;
        n /= 2;
    }
    return length;
}

1.3、数组

Offer61、扑克牌顺子
在若干副扑克牌中，随意抽取五张，判断其是不是顺子，即是不是连续。其中 A 用 1 表示，J、Q、K 分别用 11、12、13 表示，大小王用 0 表示，且可以代表任意数字。

// 数学法、哈希表
// 数学法 + 哈希表/集合
public static boolean isStraight(int[] nums) {
    List<Integer> list = new ArrayList<>(5);
    int max = 0, min = 13;
    for (int item : nums) {
        if (item == 0) {
            continue;
        }
        if (list.contanins(item)) {
            return false;
        }
        list.add(item);
        max = Math.max(max, item);
        min = Math.min(min, item);
    }
    return max - min <= 4;
}

Offer62、约瑟夫环
圆圈中最后一个数字，给定 n 个数，0 ~ n - 1，从 0 开始，删除第 m 个数字，然后从下一个元素开始，再删除第 m 个数字，求最后剩下的那个数字。即约瑟夫环。

// 数学法、递归/迭代
// 数学法
// f(n, m) = (f(n - 1, m) + m) % n 表示 再 n 个数字中，删除第 m 个数字最后剩下的数字
public static boolean lastRemaining(int n, int m) {
    int temp = 0;
    for (int i = 2; i <= n; i++) {
        temp = (temp + m) % i;
    }
    return temp;
}

2、计数法

2.1、字符串

409、最长回文串
给定一个由大小写字母构成的字符串 s，求由这些字母构成的最长回文串的长度。

// 计数法、哈希表
// 计数法
public static int longestPalindrome(String s) {
    char[] c = s.toCharArray();
    int[] temp = new int[58];   // ASCII 码表中 A ~ z 的长度
    for (char item : c) {
        temp[item - 'A']++;
    }
    int length = 0;
    for (int item : temp) {
        if (item != 0) {
            length = (item / 2) * 2;
        }
    }
    return length < c.length ? length + 1 : length;
}

2.2、数组

645、错误的集合
设定一个数据集 nums，其中包含了 1 ~ n 的元素，但由于复制错误导致其中一个元素重复，一个元素丢失，求重复的元素和丢失的元素。

// 计数法、位运算、哈希表、排序法
// 计数法
public static int[] findErrorNums(int[] nums) {
    int[] temp = new int[nums.length + 1];
    int[] res = new int[2];
    for (int item : nums) {
        temp[item]++;
    }
    for (int item : temp) {
        if (item == 2) {
            res[0] = item;
        }
        if (item == 0) {
            res[1] = item;
        }
        if (res[0] > 0 && res[1] > 0) {
            break;
        }
    }
    return res;
}

997、小镇法官
小镇有 n 个人，分别用 1 ~ n 表示，传言称小镇里有一个法官，法官不信任任何人，但其他人都信任这个法官，请找出他。trust[2, 4] 表示 2 信任 4。

// 计数法、哈希表
// 计数法
public static int findJudge(int n, int[][] trust) {
    int[] temp = new int[n + 1];
    for (int[] item : trust) {
        temp[item[0]]--;
        temp[item[1]]++;
    }
    for (int i = 1; i < temp.length; i++) {
        if (temp[i] == n - 1) {
            return i;
        }
    }
    return -1;
}

1207、独一无二的出现次数
给定一个整数数组 nums，请统计数组中元素的出现次数，若每个元素的出现次数都是独一无二的，则返回 true，否则返回 false。

// 计数法、哈希表
// 哈希表
public static boolean uniqueOccurrences(int[] nums) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int item : nums) {
        map.put(item, map.getOrDefault(item, 0) + 1);
    }
    return map.size() == new HashSet<>(map.values()).size();
}

Offer03、数组中重复的数字
给定一个长度为 n 的数组，数组元素为 0 ~ n - 1，数组中某些数字是重复的，请找出任意一个重复的元素。

// 计数法、哈希表、排序法
// 剑指 offer 原解
// 1、若要求低时间，则用集合法（也就是字典法）
// 2、若要求低空间，则用排序法（冒泡、选择、插入等空间复杂度为 O(1)的）或如下示例法
// 3、若要求低空间且不能修改原数组，则使用二分法
public static int findRepeatNumber(int[] nums) {
    int length = nums.length;
    for (int i = 0; i < length; i++) {
        int k = nums[i];
        if (k < 0) {
            k += length;
        }
        if (nums[k] < 0) {  
            return k;
        }
        nums[k] -= length;
    }
    return -1;
}

3、位运算

231、2 的幂
给定一个整数，判断其是否为 2 的幂次方。

// 数学法、位运算
// 位运算 2^n & (2^n - 1) == 0
public static boolean isPowerOfTwo(int n) {
    if (n <= 0) {
        return false;
    }
    return (n & n - 1) == 0;
}

Offer65、不用 +、-、*、/ 做加法
不使用 +、-、*、/ 实现加法功能。

// 数学法、位运算
// 位运算
// a ^ b 异域：表示 a 和 b 的无进位求和，如 23 ^ 7 = 10；a & b 与：表示 a 和 b 的和进位，如 23 & 7 = 3
public static int add(int a, int b) {
    int m = a ^ b, n = a & b;
    if (n == 0) {
        return m;
    }
    return add(m, n << 1);
}

4、双指针法

4.1、字符串

125、回文串
给定一个字符串，验证其是否为回文串，只考虑字母数字，忽略大小写。

// 双指针法、哈希表
// 双指针法
public static boolean isPalindrome(String s) {
    String temp = s.replaceAll("[A-Za-z0-9]", "");
    for (int i = 0, j = temp.length() - 1; i < j; i++, j--) {
        if (temp.charAt(i) != temp.charAt(j)) {
            return false;
        }
    }
    return true;
}

344、反转字符串
给定一个字符串，将其中的字符串反转过来。

// 双指针法
public static void reverseString(char[] c) {
    for (int i = 0, j = c.length - 1; i < j; i++, j--) {
        char temp = c[i];
        c[i] = c[j];
        c[j] = temp;
    }
}

459、重复的子字符串
给定一个字符串 s，判断其是否可以由其某个子字符串重复多次构成。

// 双指针、匹配
// 双指针
public static boolean repeatedSubstringPattern(String s) {
    char[] c = s.toCharArry();
    for (int i = 1; i < c.length / 2; i++) {
        if (c.length % i != 0) {
            continue;
        }
        int m = 0, n = m + i;
        while (n < c.length) {
            if (c[m] != c[n]) {
                break;
            }
            m++;
            n++;
        }
        if (n == c.length) {
            return true;
        }
    }
    return false;
}

1047、删除字符串中所有的相邻重复项
给定一个字符串，删除其中所有相邻重复项。

// 双指针法、栈
// 双指针
public static String removeDuplicates(String s) {
    char[] c = s.toCharArray();
    int index = -1;
    for (int i = 0; i < c.length; i++) {
        if (index != -1 && c[index] == c[i]) {
            index--;
        } else {
            c[++index] = c[i];
        }
    }
    return String.copyValueOf(c, 0, index + 1);
}

4.2、数组

26、移除有序数组中的重复项
给定一个升序数组 nums，请原地移除重复出现的元素，且使元素的相对顺序保持一致。若最终结果为 k 个，则不考虑 k 及之口的元素。

// 双指针法
public static int removeDuplicates(int[] nums) {
    int i = 0;
    for (int j = 1; j < nums.length; ) {
        if (nums[i] == nums[j]) {
            j++;
        } else {
            i++;
            if (i != j) {
                nums[i] = nums[j];
            }
            j++;
        }
    }
    return i + 1;
}

27、移除指定元素
给定一个数组及一个值，原地移除该元素。

// 双指针法
public static int removeElement(int[] nums, int n) {
    int index = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] != n) {
            nums[index++] = nums[i];
        }
    }
    return index;
}

283、移动数组元素零
给定一个数组，将元素 0 移至末尾。

// 双指针法
public static void moveZeroes(int[] nums) {
    int index = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] != 0) {
            if (index != i) {
            	nums[index] = nums[i];
            	nums[i] = 0;
            }
            index++;
        }
    }
}

350、数组交集
给定两个数组，返回数组交集，若元素出现多次，则以出现次数较小的为准。

// 双指针法、哈希表、排序法
// 双指针法
public static int[] intersect(int[] m, int[] n) {
    Arrays.sort(m);
    Arrays.sort(n);
    List<Integer> list = new ArrayList<>();
    for (int i = 0, j = 0; i < m.length && j < n.length; ) {
        if (m[i] < n[j]) {
            i++;
        } else if (m[i] > n[j]) {
            j++;
        } else {
            list.add(m[i]);
            i++;
            j++;
        }
    }
    int[] temp = new int[list.size()];
    int index = 0;
    for (int item : list) {
        temp[index++] = item;
    }
    return temp;
}

557、反转字符串中的单词
给定一个字符串，反转字符串中每个单词的字母顺序。

// 双指针
public static String reverseWords(String s) {
    char[] c = s.toCharArray();
    int i, j;
    for (i = 0, j = 0; j < c.length(); ) {
        if (c[j] != ' ') {
            j++;
        } else {
            reverse(c, i, j);
            i = j + 1;
            j = i;
        }
    }
    reverse(c, i, j - 1);
    return new String(c);
}

public static void reverse(char[] c, int start, int end) {
    while (start < end) {
        char temp = c[start];
        c[start] = c[end];
        c[end] = temp;
        start++;
        end--;
    }
}

1470、重新排列数组
重新排列数组x1x2x3…xn y1y2y3…yn => x1y2x2y2x3yy3…xnyn。

// 双指针
public static int[] shuffle(int[] nums, int n) {
    int[] temp = new int[n * 2];
    int index = 0;
    for (int i = 0, j = n; j < nums.length; i++, j++) {
        temp[index++] = nums[i];
        temp[index++] = nums[j];
    }
    return temp;
}

Offer21调整数组元素使奇数在偶数前面
嗯，就像题目那样。

// 双指针
public static int[] exchange(int[] nums) {
    for (int i = 0, j = nums.length - 1; i < j;) {
        if (nums[i] % 2 != 0) {
            i++;
        }
        if (nums[j] % 2 == 0) {
            j--;
        }
        if (i < j && nums[i] % 2 == 0 && nums[j] % 2 != 0) {
            int temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;
            i++;
            j--;
        }
    }
    return nums;
}

Offer57-II、和为 s 的连续正整数序列
和为 s 的连续正整数序列。

// 双指针
public static int[][] findContinuousSequence(int target) {
    int[][] res = new int[0][];
    for (int i = 1, j = 2; j < target; ) {
        int sum = ((i + j) * ( j - i + 1)) / 2;
        if (sum == target) {
            int[] temp = new int[j - 1];
            int index = 0, start = i;
            while (start <= j) {
                temp[index++] = start++;
            }
            res = Arrays.copyOf(res, res.length + 1);
            res[res.length - 1] = temp;
            i++;
        } else if (sum < target) {
            j++;
        } else {
            i++;
        }
    }
    return res;
}

4.3、链表

141、环形链表
给定一个链表，判断其是否为环形链表。

// 双指针、哈希表
// 双指针（快慢指针）
public static boolean hasCycle(Node node) {
    Node slow = node, fast = node;
    while (slow != null && fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) {
            return true;
        }
    }
    return false;
}

160、Offer52、相交链表
给定两个链表，判断其是否相交，若相交则返回相交节点，若不想交则返回 null。

// 双指针、哈希表
// 双指针
public static Node getIntersectionNode(Node node1, Node node2) {
    Node first = node1, second = node2;
    while (first != second) {
        first = first != null ? first.next : node2;
        second = second != null ? second.next : node1;
    }
    return first;
}

Offer22、链表中倒数第 k 个节点
给定一个链表，返回链表中倒数第 k 个节点。

// 双指针
public static Node getKthFromEnd(Node node, int k) {
    Node first = node, second = node;
    while (k > 0 && second != null) {
        second = second.next;
        k--;
    }
    while (second != null) {
        first = first.next;
        second = second.next;
    }
    return first;
}

5、字符串

Offer58-I、反转字符串中的单词顺序
给定一个字符串，反转字符串中的单词顺序。

// 双指针、字符串
// 字符串
public static String reverseWords(String s) {
    if (s == null || s.length() == 0 || s.replaceAll(" ", "").length() == 0) {
        return "";
    }
    String[] temp = s.split(" ");
    StringBuilder sb = new StringBuilder();
    for (int i = temp.length - 1; i >= 0; i--) {
        if (!temp[i].equals("")) {
            sb.append(temp[i]).append(" ");
        }
    }
    return sb.substring(0, sb.length() - 1);
}

14、最长公共前缀
给定一个字符串数组，求其最长公共前缀。

// 字符串
public static String longestCommonPrefix(String[] s) {
    String prefix = s[0];
    for (String item : s) {
        while (!item.startsWith(prefix)) {
            if (prefix.length() == 0) {
                return "";
            }
            prefix = prefix.substring(0, prefix.length() - 1);
        }
    }
    return prefix;
}

1556、千位分隔数
给定一个整数 n，返回其千位分隔后的字符串。

// 字符串
public static String thousandSeparator(int n) {
    StringBuilder sb = new StringBuilder(String.valueOf(n));
    if (sb.length() <= 3) {
        return sb.toString();
    }
    for (int i = sb.length() - 1 - 3; i >= 0; i -= 3) {
        sb.insert(i + 1, '.');
    }
    return sb.toString();
}

6、哈希表

771、宝石与石头
给定两个字符串 j 和 s，j 中的每个字符代表了一种宝石，s 代表你拥有的石头，统计你拥有的石头中的宝石的数量。

// 哈希表
public static int numJewelsInStones(String j, String s) {
    Set<Character> set = new HashSet<>(j.length());
    for (char c : j.toCharArray()) {
        set.add(c);
    }
    int num = 0;
    for (char c: s.toCharrray()) {
        if (set.contains(c)) {
            num++;
        }
    }
    return num;
}

859、亲密字符串
给定两个字符串 s 和 g，如果只交换 s 中两个字符的位置久能得到与 g 相等的结果，那就认为 s 和 g 是亲密字符串。

// 哈希表
public static boolean buddyStrings(String s, String g) {
    if (s.length() != g.length()) {
        return false;
    }
    if (s.equals(g)) {
        int[] temp = new int[26];  // s g 只包含小写字母
        for (char c : s.toCharAray()) {
            temp[c - 'a']++;
            if (temp[c - 'a'] > 1) {
                return true;
            }
        }
        return false;
    } else {
        int first = -1, second = -1;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) != g.charAt(i)) {
                if (first == -1) {
                    first = i;
                } else if (second == -1) {
                    second = i;
                } else {
                    return false;
                }
            }
        }
        return first != -1 && second != -1 && s.charAt(second) == g.charAt(first) && s.charAt(first) == g.charAt(second);
    }
}

1、两数之和
给定一个整数数组和一个目标整数，请返回数组中和为目标整数的元素下标。

// 哈希表
public static int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>(nums.length());
    int[] res = new int[2];
    for (int i = 0; i < nums.length; i++) {
        if (map.containsKey(nums[i])) {
            res[0] = map.get(nums[i]);
            res[1] = i;
        } else {
            map.put(target - nums[i], i);
        }
    }
    return res;
}

7、栈

7.1、链表

Offer06、从尾到头打印链表
给定一个链表，从尾到头打印链表。

// 双指针、栈、递归/迭代
// 栈
public static int[] reversePrint(Node node) {
  Stack<Integer> stack = new Stack<>();
    while (node != null) {
        stack.push(node.value);
        node = node.next;
    }
    int[] res = new int[stack.size()];
    int index = 0;
    while (!stack.isEmpty()) {
        res[index++] = stack.pop();
    }
    return res;
}

7.2、字符串

20、有效的括号
给定一个只包含 ‘(’、‘)’、‘[’、‘]’、‘{’、‘}’ 字符的字符串，判断其是否有效。有效定义为，左括号必须在对应位置上有正确的右括号。

// 栈
public static boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(') {
            stack.push(')');
        } else if (c == '[') {
            stack.push(']');
        } else if (c == '{') {
            stack.push('}');
        } else if (stack.isEmpty() || c!= stack.pop()) {
            return false;
        }
    }
    return stack.isEmpty();
}

7.3、栈

716、最大栈；Offer30、最小栈
设计一个最大栈数据结构，既支持栈操作，又能查找栈中最大元素。

// 双栈
// 一个栈用来提供栈操作，另一个栈用来提供最大元素操作，利用栈的先进后出的特性

232、Offer09、实现队列
用双栈实现队列。

// 双栈
// 一个栈用来入列，一个栈用来出列。

8、递归/迭代

8.1、链表

83、删除排序链表中的重复元素
给定一个排序链表，删除其中重复的元素。

// 栈、递归/迭代
// 递归/迭代
public static Node deleteDuplicates(Node node) {
    Node last = node;
    Node temp = last.next;
    while (last != null && temp != null) {
        if (last.value != temp.value) {
            last.next = temp;
            last = last.next;
        }
        temp = temp.next;
    }
    last.next = null;
    return node;
}

206、Offer24、反转链表
给定一个链表，反转链表，返回反转后的头节点。

// 栈、递归/迭代
// 迭代
public static Node reverseList(Node node) {
    Node prev = null, curr = node, temp;
    while (curr != null) {
        temp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = temp;
    }
    return prev;
}

237、Offer18、删除链表节点
给定一个链表及一个目标值，删除链表中节点值等于目标值的一个节点。

// 栈、递归/迭代
// 迭代
public static Node deleteNode(Node node, int value) {
    if (node == null) {
        return null;
    }
    Node root;
    if (node.value == value) {
        root = node.next;
    } else {
        root = node;
    }
    while (node.next != null) {
        if (node.next.value == value) {
            node.next = node.next.next;
            break;
        }
        node = node.next;
    }
    return root;
}

8.2、二叉树

144、前；94、中；145、后；深；广遍历
```
// 前中后深广遍历就不用多说了吧
```

108、有序数组转化为二叉搜索树
给定一个有序数组，将其转化为二叉搜索树。

// 递归/迭代、分治
// 递归
public static Tree sortedArrayToBST(int[] nums) {
    return nums == null ? null : build(nums, 0, nums.length - 1);
}

public static Tree build(int[] ums, int left, int right) {
    if (left > right) {
        return null;
    }
    int mid = left + (right - left) / 2;
    Tree tree = new Tree(nums[mid]);
    tree.left = build(nums, left, mid - 1);
    tree.right = build(nums, mid + 1, right);
    return tree;
}

104、二叉树的最大；111、最小深度；112、路径总和
给定一个二叉树，求其最大深度。

// 递归/迭代、深、广
public static int maxDepth(Tree tree) {
    return tree == null ? 0 : Math.max(tree.left, tree.right) + 1;
}

// 最小深度
public static int minDepth(Tree tree) {
    if (tree == null) {
        return 0;
    }
    if (tree.left != null && tree.right == null) {
        return minDepth(tree.left) + 1;
    }
    if (tree.left == null && tree.right != null) {
        return minDepth(tree.right) + 1;
    }
    return Math.min(minDepth(tree.left), minDepth(tree.right)) + 1;
}

// 路径总和
// 给定一个二叉树根节点和一个目标值，判断二叉树的每个叶子节点的总和中是否有和目标值相等的。
public static boolean hasPathSum(Tree tree, int target) {
    if (tree == null) {
        return false;
    }
    if (tree.left == null && tree.right == null) {
        return targte - tree.value == 0;
    }
    return hasPathSum(tree.left, target - tree.value) || hasPathSum(tree.right, target - tree.value);
}

101、Offer28、对称二叉树
给定一个二叉树，判断其是否为对称二叉树。

// 递归
public static boolean isSymmetric(Tree tree) {
    return tree == null ? true : check(tree.left, tree.right);
}

public static boolean check(Tree left, Tree right) {
    if (left == null || right == null) {
        return false;
    }
    return left.value == right.value && check(left.left, right.right) && check(left.right, right.left);
}

226、翻转二叉树
给定一颗二叉树，翻转其左右节点。

// 前、中、后、深、广、笨比
// 前
public static Tree before(Tree tree) {
    if (tree == null) {
        return null;
    }
    Tree temp = tree.left;
    tree.left = brfore(tree.right);
    tree.right = before(temp);
    return tree;
}

// 中
public static Tree middle(Tree tree) {
    if (tree == null) {
        return null;
    }
    middle(tree.left);
    Tree temp = tree.left;
    tree.left = tree.right;
    tree.right = temp;
    middle(tree.left);
    return tree;
}

// 后
public static Tree after(Tree tree) {
    if (tree =null) {
        return null;
    }
    Tree left = after(tree.left);
    Tree right = after(tree.right);
    tree.left = right;
    tree.right = left;
    return tree;
}

// 广
public static Tree bfs(Tree tree) {
        if (tree == null) {
            return null;
        }
        Queue<Tree> queue = new LinkedList<>();
        queue.add(tree);
        while (!queue.isEmpty()) {
            Tree tree1 = tree.poll();
            Tree temp = tree1.left;
            tree1.left = tree1.right;
            tree1.right = temp;
            if (tree1.left != null) {
                queue.add(tree1.left);
            }
            if (tree1.right != null) {
                queue.add(tree1.right);
            }
        }
        return tree;
    }

617、合并二叉树
给定两个二叉树，合并二叉树。

// 递归
public static Tree mergeTrees(Tree tree1, Tree tree2) {
    if (tree1 == null) {
        return tree2;
    }
    if (tree2 == null) {
        return tree1;
    }
    tree1.value += tree2.value;
    tree1.left = mergeTrees(tree1.left, tree2.left);
    tree1.right = mergeTrees(tree1.right, tree2.right);
    return tree1;
}

257、二叉树的所有路径（深）
给定一颗二叉树，返回其所有路径。

// 深
public static List<String> binaryTreePaths(Tree tree) {
	List<String> list = new ArrayList<>();
    StringBuildr sb = new StringBuilder();
    path(tree, list, sb);
    return list;
}

public static void path(Tree tree, List<String> list, StringBuilder sb) {
    if (tree == null) {
        return;
    }
    sb.append(tree.value).append('->');
    if (tree.left != null) {
        path(tree.left, list, new StringBuilder(sb));
    }
    if (tree.right != null) {
        path(tree.right, list, new StringBuilder(sb));
    }
    if (tree.left == null && tree.right == null) {
        list.add(sb.substring(0, sb.length() - 2));
        return;
    }
}

543、二叉树的直径（深）
给定一颗二叉树，求其直径。二叉树直径为任意两个叶节点之间的路径长度。

// 深
int max = 0;
public static int diameterOfBinaryTree(Tree tree) {
    depth(tree);
    return max;
}

public static int depth(Tree tree) {
    if (tree == null) {
        return 0;
    }
    int leftDepth = tree.left != null ? depth(tree.left) + 1 : 0;
    int rightDepth = tree.right != null ? depth(tree.right) + 1 : 0;
    max = Math.max(max, leftDepth + rightDepth);
    return Math.max(leftDepth, rightDepth);
}

572、另一棵树的子树（深）
给定两颗二叉树，判断第二颗是否为第一颗的子树。

// 深
public static boolean isSubtree(Tree, tree1, Tree tree2) {
    if (tree1 == null) {
        return false;
    }
    return isSame(tree1, tree2) || isSame(tree1.left, tree2) || isSame(tree1.right, tree2);
}

public static boolean isSame(Tree tree1, Tree tree2) {
    if (tree1 == null && tree2 == null) {
        return treu;
    }
    if (tree1 == null || tree2 == null) {
        return false;
    }
    return tree1.value == tree2.value && isSame(tree1.left, tree2.left) && isSame(tree1.right, tree2.right);
}

Offer55-II、平衡二叉树（深）
给定一颗二叉树，若其任意节点的左右子树的深度差不超过 1，则称为平衡二叉树。

// 深（自顶向下递归）
public static boolean isBalanced(Tree tree) {
    if (tree == null) {
        return treu;
    }
    if (Math.abs(depth(tree.left) - depth(tree.right)) > 1) {
        return false;
    }
    return isBalanced(tree.left) && isBalanced(tree.right);
    
    // 自底向上递归
    return depth1(tree) >= 0;
}

// 自底向上递归
public static int depth1(Tree tree) {
    if (tree == null) {
        return 0;
    }
    int leftDepth = depth1(tree.left);
    int rightDepth = depth1(tree.right);
    if (leftDepth == -1 || rightDepth == -1 || Math.abs(leftDepth - rightDepth) > 1) {
        return -1;
    }
    return Math.max(leftDepth, rightDepth) + 1;
}

public static int depth(Tree) {
    return tree == null ? 0 : Math.max(tree.left, tree.right) + 1;
}

637、二叉树的层平均值（广）
给定一颗二叉树，返回其层平均值。
```
// 广
// 广度优先遍历 求每一层平均值 代码过于简单 不予展示
```

Offer54、二叉搜索树的第 k 大节点（反中序）
给定一颗二叉搜索树，返回其第 k 大节点。

// 反中序
int count = 0, value = 0;
public static int k(Tree tree, int k) {
    if (tree == null) {
        return -1;
    }
    middle(tree, k);
    return value;
}

public static void middle(Tree tree, int k) {
    if (tree.right != null) {
        middle(tree.right, k);
    }
    if (++count == k) {
        value = tree.value;
        break;
    }
    if (tree.left != null) {
        middle(tree.left, k);
    }
}

559、N 叉树的最大深度（深、广）
给定一颗 n 叉树，返回其最大深度。

// 深/广
// 深
public static int dfs(Tree tree) {
    if (tree == null) {
        return 0;
    }
    int depth = 0;
    for (Tree item : tree.children) {
        depth = Math.max(depth, dfs(item));
    }
    return depth + 1;
}

// 广
public static int bfs(Tree tree) {
	if (tree == null) {
        return 0;
    }
    if (tree.children.size == 0) {
        return 1;
    }
    int depth = 0;
    Queue<Tree> queue = new LinkedList<>();
    queue.add(tree);
    while (!queue.isEmpty()) {
        depth++;
        int size = queue.size();
        while (size > 0) {
            Tree temp = queue.poll();
            if (temp.chiildren,.size > 0) {
                queue.addAll(temp.children);
            }
            size--;
        }
    }
    return depth;
}

9、排序法

9.1、数组

88、合并有序数组
给定两个升序数组，合并数组，并使元素保持升序顺序。

// 双指针法、排序法
// 排序法（归并合并）
public static int[] merge(int[] m, int[] n) {
    int[] res = new int[m.length + n.length];
  int i = 0, j = 0, index = 0;
    while (i < m.length && j < n.length) {
      res[index++] = m[i] < n[j] ? m[i++] : n[j++];
    }
    if (i < m.length) {
        res[index++] = m[i++];
    }
    if (j < n.length) {
        res[index++] = n[j++];
    }
    return res;
}

Offer40、最小的 k 个数（快排）
给定一个整数数组和一个整数 k，k 小于数组的长度，返回数组中最小的 k 个数。

// 排序法（快排思想）
public static int[] getLeastNumbers(int[] nums, int k) {
    if (nums.length == 0) {
        return new int[0];
    }
    return min(nums, 0, nums..length - 1, k);
}

public static int[] min(int[] nums, int left, int right, int k) {
    int index = quick(nums, left, right);
    if (index + 1 == k) {
        return Arrays.copyOf(nums, 0, k);
    }
    return index + 1 < k ? min(nums, index + 1, right, k) : min(nums, left, index - 1, k);
}

public static int quick(int[] nums, int left, int right) {
    int key = nums[left];
    int i = left, j = right;
    while (i < j) {
        while (i < j && nums[j] >= key) {
            j--;
        }
        while (i < j && nums[i] <= key) {
            i++;
        }
        if (i < j) {
            int temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;
        }
    }
    nums[left] = nums[i];
    nums[i] = key;
    return i;
}

9.2、链表

21、Offer25、合并有序链表
合并两个有序链表。

// 排序法（归并合并思想）
public static Node mergeTwoLists(Node node1, Node node2) {
    if (node1 == null) {
        return node2;
    }
    if (node2 == null) {
        return node1;
    }
    Node root = new Node(-1);
    Node node = root;
    while (node1 != null && node2 != null) {
        if (node1.value <= node2.value) {
            node.next = node1;
            node1 = nnode1.next;
        } else {
            node.next = node2;
            node2 = node2.next;
        }
        node = node.next;
    }
    if (node1 != null) {
        node.next = node1;
    }
    if (node2 != null) {
        node.next = node2;
    }
    return root.next;
}

10、匹配法

28、strStr()
实现 strStr() 方法。

// 字符串匹配 直接参考五大匹配算法（BF、RK、KMP、BM、Sunday）

11、记忆化法

// 记忆化法皆可用动态规划解决

12、二分法

35、搜索插入位置
给定一个有序数组和一个整数，返回该整数在数组中的索引，若不存在于数组，则返回其插入位置。

// 二分法
public static int searchInsert(int[] nums, int key) {
    if (key < nums[0]) {
        return 0;
    } else if (key > nums[nums.length - 1]) {
        return nums.length;
    } ele {
        return binary(nums, 0, nums.length - 1, key);
    }
}

public static int binary(int[] nums, int left, int right, int key) {
    if (left == right) {
        if (key <= nums[left]) {
            return left;
        } else {
            return left + 1;
        }
    } else if (left < right) {
        int mid = left + (right - left) / 2;
        if (key == nums[mid]) {
            return mid;
        } else if (key < nums[mid]) {
            return binary(nums, left, mid - 1, key);
        } else {
            return bianry(nums, mid + 1, right, key);
        }
    } else {
        return left;
    }
}

69、x 的平方根
给定一个整数 x，在不使用任何库函数的情况下，返回 x 的算数平方根。

// 二分法
public static int mySqrt(int x) {
    int left = 0, right = x, res = -1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if ((long) mid * mid <= x) {
            res = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return res;
}

704、二分查找
二分查找。

// 二分查找 代码见七大查找算法之二分查找

852、山脉数组的峰顶索引
给定一个山脉数组，返回其峰顶索引值，即返回最大值索引。

public static int peakIndexInMountainArray(int[] nums) {
    int left = 0, right = arr.length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[mid - 1] && nums[mid] > nums[mid + 1]) {
            return mid;
        } else if (nums[mid] < nums[mid - 1]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return - 1;
}

13、分治法

// 皆可用其它方法解决

14、摩尔投票法

169、Offer39、多数元素
给定一个数组，求出现次数超过一半元素。

// 计数法、哈希表、分治法、摩尔投票法
// 摩尔投票法
public static int majorityElement(int[] nums) {
    int count = 1, curr = nums[0];
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] == curr) {
            count++;
        } else {
            count--;
            if (count == 0) {
                if (i< nums.length - 1) {
                    curr = nums[i + 1];
                } else {
                    return -1;
                }
            }
        }
    }
    return count;
}

15、前缀和

303、区域检索-数组不可变
利用前缀和来作为结果。
```
// 代码被扣了
```

16、模拟法

867、转置矩阵
转置矩阵，即将矩阵的行换成列，列换成行。

// 模拟法
public static int[][] transpose(int[][] nums) {
    if (nums.length == 0) {
        return null;
    }
    int[][] res = new int[nums[0].length][nums.length];
    for (int i = 0; i < nums.length; i++) {
        for (int j = 0; j < nums[i].length; j++) {
            res[j][i] = nums[i][j];
        }
    }
    return res;
}

Offer29、顺时针打印矩阵
给定一个矩阵，顺时针打印矩阵内元素。

// 模拟法
public static int[] spiralOrder(int[][] nums) {
    if (nums.length == 0) {
        return new int[] {};
    }
    int high = nums.length, width = nums[0].length;
    int[] res = new int[high * width];
    int right = width - 1, down = high - 1, left = 0, up = 0;
    int index = 0, i = 0, j = 0;

    while (left <= right && up <= down) {
        // 对应存在以最中心元素中心对称的情况
        if ((right == left) && (down == up) && (right == down)) {
            res[index++] = nums[i][j];
            break;
        }
        while (j < right) {
            res[index++] = nums[i][j++];
        }
        right--;
        while (i < down) {
            res[index++] = nums[i++][j];
        }
        down--;
        while (j > left && index < res.length) {
            res[index++] = nums[i][j--];
        }
        left++;
        while (i > up && index < res.length) {
            res[index++] = nums[i--][j];
        }
        up++;
        i++;
        j++;
    }
    return res;
}

17、动态规划

17.1、整数

118、杨辉三角
杨辉三角，在杨辉三角中，每个数字的值等于它左上方和右上方的和。给定一个整数 n，返回 n 行杨辉三角。

// 动态规划
public static int[][] generate(int n) {
    int[][] dp = new int[n][0];
    for (int i = 0; i < n; i++) {
        int[] temp = new int[i + 1];
        dp[i] = temp;
        for (int j = 0; j <= i; j++) {
            if (i == 0 || j == 0) {
                dp[i][j] = 1;
            } else {
                if (j <= i / 2) {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i][i - j];
                }
            }
        }
    }
    return dp;
}

509、Offer10I、斐波那契数列
斐波那契数列 f(n) = f(n - 2) + f(n + 1)。

// 递归/迭代、动态规划
// 动态规划
public static int fibonacci(int n) {
    if (n < 2) {
        return n;
    }
    int prePre = 0, pre = 1, fn = 0;
    for (int i = 1; i < n; i++) {
        fn = (prePre + pre) % 1000000007;
        prePre = pre;
        pre = fn;
    }
    return fn;
}

70、爬楼梯；Offer10II、跳台阶
小丸子爬楼梯与跳台阶，可以一次爬一个台阶，也可以一次爬两个台阶，求对于有 n 个台阶的楼梯，小丸子有多少中爬楼梯方案。

// 动态规划
public static int climbStairs(int n) {
    // 若是跳台阶 小丸子会原地蹦一下
    // if (n == 0) {
    //     return 1;
    // }
    
    if (n <= 2) {
        return n;
    }
    int a = 1, b = 2, temp = 0;
    for (int i = 3; i <= n; i++) {
        temp = (a + b) % 1000000007;
        a = b;
        b = temp;
    }
    return temp;
}

interview-08-01、三步问题
小丸子上楼梯，小丸子长大了，可以一次上一个，也可以一次上两个，也可以一次上三个。对于有 n 个台阶的楼梯，小丸子有多少中爬楼梯方案。

// 动态规划
public static int waysToStep(int n) {
    if (n < 3) {
        return n;
    }
    if (n == 3) {
        return 4;
    }
    int mod = 1000000007;
    int[] dp = new int[n + 1];
    dp[1] = 1;
    dp[2] = 2;
    dp[3] = 4;
    for (int i = 4; i <= n; i++) {
        dp[i] = (dp[i - 3] + dp[i - 2]) % mod + dp[i - 1];
        dp[i] %= mod;
    }
    return dp[n];
}

17.2、数组

53、Offer42、最大连续子段和
给定一个数组，求其最大连续子段和。

// 动态规划
public static int maxSubArray(int[] nums) {
    int max = nums[0];
    for (int i = 1; i < nums.length; i++) {
        nums[i] += Math.max(nums[i], 0);
        max = Math.max(max, nums[i]);
    }
    return max;
}

121、买卖股票问题
给定一个数组，nums[i] 表示第 i 天股票的价格。求股票买卖的最大利润。

// 动态规划
public static int maxProfit(int[] nums) {
    int max = 0, minPrice = nums[0];
    for (int i = 1; i < nums.length; i++) {
        max = Math.max(max, nums[i] - minPrice);
        minPrice = Math.min(minPrice, nums[i]);
    }
    return max;
}

392、判断子序列
给定两个字符串 s 和 t，判断 s 是否为 t 的子序列。

// 双指针、动态规划
// 动态规划
// 转化为最短编辑距离问题，最短编辑距离问题中 s => t 可以经过修改、插入、删除来完成，而在这个问题中 s => t 只能通过插入
public static boolean isSubsequence(String s, String t) {
  char[] a = s.toCharArray();
    char[] b = t.toCharArray();
    int[][] dp = new int[a.length + 1][b.length + 1];
    for (int i = 1; i < a.length + 1; i++) {
        for (int j = 1; j < b.length + 1; j++) {
            if (a[i - 1] == b[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = dp[i][j - 1];
            }
        }
    }
    return dp[a.length][b.length] == s.length();
}

LCP07、传递信息
给定一个整数 n，表示 n 个小朋友，编号从 0 ~ n - 1；给定一个二维数组，其中第二维 [2, 6] 表示信息可以从 2 传到 6；给定一个整数 k 表示传递的次数。求信息经过 k 次传播传到 n - 1 处的方案数。

// 动态规划
public static int numWays(int n, int[][] relation, int k) {
    int[][] dp = new int[k + 1][n];
    dp[0][0] = 1;  // 可以理解为刚开始信息的持有者
    for (int i = 1; i < k + 1; i++) {
        for (int[] temp : relation) {
            dp[i][temp[1]] += dp[i - 1][temp[0]];
        }
    }
    return dp[k][n - 1];
}