算法-分而治之思想

分而治之是什么

1. 分而治之是算法设计中的一种方法(算法思想)
2. 它将一个问题分成多个和原问题相似的小问题，递归解决小问题，再将结果合并以解决原来的问题
3. 典型案例:快速排序,归并排序

leetcode

374

假设数字是6

   function guess(guess) {
      if (guess == 6) { //猜的数字等于真实数字
        return 0
      } else if (guess > 6) { //猜的数字比真实数字大
        return -1
      } else { // //猜的数字比真实数字小
        return 1
      }
    }

第一步：分

1. 定好搜索范围是1-n
2. 以数组中间值为分隔

    function guessNumber(n) {
      const rec = (low,high) => {
        const mid = Math.floor((low+high)/2)
        const res = guess(mid)
        if(res === 0){
          //得到对应的值，
        }else if(res ===1){
          //对应的值在中间值到最大值区域
        }else{
          //对应的值在最小值到中间值区域
        }       
      }
      return rec(1, n) //代表搜索范围1-n
    }
    var result = guessNumber(10)

第二步: 递归

递归终结条件:最小值大于最大值

    function guessNumber(n) {
      const rec = (low,high) => {
        if(low > high){
          return 0;
        }  
        const mid = Math.floor((low+high)/2)
        const res = guess(mid)
        if(res === 0){
          return mid;
        }else if(res ===1){
          return rec(mid+1,high)
        }else{
          return rec(low,mid-1)
        }
      }
      return rec(1, n)
    }
    var result = guessNumber(10)

时空复杂度
时间:O(logN)
空间:O(logN) 定义的mid，可能线性增长

226 翻转二叉树

题目案例

定义一棵树

    const tree = {
      val: 4,
      left: {
        val: 2,
        left: {
          val: 1,
          left: null,
          right: null
        },
        right: {
          val: 3,
          left: null,
          right: null
        }
      },
      right: {
        val: 7,
        left: {
          val: 6,
          left: null,
          right: null
        },
        right: {
          val: 9,
          left: null,
          right: null
        }
      }
    }

解题思路

1. 分：获取左右子树
2. 解: 递归地翻转左右子树
3. 合: 将翻转后的左右子树换个位置放到根节点上

代码实现

    function invertTree(root) {
      if(!root){
        return null;
      }
     let left = invertTree(root.left)
     let right = invertTree(root.right)
     root.left = right;
     root.right = left
     return root
    }
    var result = invertTree(tree)
    console.log('result', result)

时间复杂度:O(n)，其中 NN 为二叉树节点的数目。我们会遍历二叉树中的每一个节点，对每个节点而言，我们在常数时间内交换其两棵子树。
空间复杂度: O(N)。使用的空间由递归栈的深度决定，它等于当前节点在二叉树中的高度。在平均情况下，二叉树的高度与节点个数为对数关系，即 O(logN)。而在最坏情况下，树形成链状，空间复杂度为 O(n)

递归分析

代表未进入函数之前

代表进入了第二个递归

100 对称二叉树

    const tree1 = {
      val: 1,
      left: {
        val: 2,
        left: {
          val: 4,
          left: null,
          right: null
        },
        right: {
          val: 5,
          left: null,
          right: null
        }
      },
      right: {
        val: 2,
        left: {
          val: 5,
          left: null,
          right: null
        },
        right: {
          val: 4,
          left: null,
          right: null
        }
      }
    }

    function isSameTree(tree) {
      if (!tree) {
        return true
      }
      const rec = (left, right) => {
        if (!left && !right) {
          return true
        }
        if (left.val && right.val && left.val === right.val && rec(left.left, right.right) && rec(right.left, left.right)) {
          return true
        } else {
          return false
        }

      }
      return rec(tree.left, tree.right)
    }