分而治之

• 分而治之是算法设计中的一种思想
• 它将一个问题分成多个小问题，递归解决小问题，再将结果合并以解决原来的问题

场景一：归并排序

• 分：将数组从中间一分为二
• 解：递归对两个子数组进行归并排序
• 合：合并有序子数组

场景二：快速排序

• 分：选择基准，将数组一分为二
• 解：递归对两个子数组进行快速排序
• 合：合并有序子数组

leetcode 相关题目

leetcode-374.猜数字大小

/**
 * @param {number} n
 * @return {number}
 */
var guessNumber = function (n) {
  // 二分搜索
  // 递归实现
    const rec = (l, h) => {
        if (l > h) return;
        const mid = Math.floor((l + h) / 2);
        const res = guess(mid);
        if (res === 0) {
            return mid
        } else if (res === 1) {
            return rec(mid + 1, h);
        } else {
            return rec(l, mid - 1);
        }
    }
    return rec(1, n); 
};

leetcode-226.翻转二叉树

/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var invertTree = function (root) {
    if (!root) return null;
    const tmp = root.left;
    root.left = root.right;
    root.right = tmp;
    invertTree(root.left);
    invertTree(root.right);
    return root;
};

leetcode-100.相同的树

/**
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {boolean}
 */
var isSameTree = function (p, q) {
    if (!p && !q) return true;
    if (
        p && q && p.val === q.val
        && isSameTree(p.left, q.left)
        && isSameTree(p.right, q.right)
    ) {
        return true;
    }
    return false;
};

leetcode-101.对称二叉树

/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isSymmetric = function (root) {
    if (!root) return true;
    const rec = (left, right) => {
        if (!left && !right) return true;
        if (
            left && right
            && left.val === right.val
            && rec(left.left, right.right)
            && rec(left.right, right.left)
        ) {
            return true;
        }
        return false;
    }
    return rec(root.left, root.right);
};