leetcode刷题记录(9)-中等

1.验证二叉搜索树

题目：

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

思路：二叉搜索树的特点是左边的子树小于根节点，右边的子树也都要大于根节点，同时每一课子树也要递归的判断。所以用一个变量记录当前子树的最小值和最大值即可

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isValidBST = function(root) {
  const isValidBSTAA = (root, min, max) => {
    if (!root) return true;
    if (root.val <= min || root.val >= max) return false;
    return (
      isValidBSTAA(root.left, min, root.val) &&
      isValidBSTAA(root.right, root.val, max)
    );
  };
  if (!root) return true;
  return isValidBSTAA(root, -Infinity, Infinity);
};

换个思路，二叉搜索树的中序遍历是升序，那么我们用中序遍历的方式，去比较当前的数和前一个数的值即可，。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isValidBST = function(root) {
  let pre = -Infinity;
  let flag = false;
  const search = (root) => {
    if (flag) return;
    if (!root) return;
    search(root.left);
    if (root.val <= pre) {
      flag = true;
      return;
    }
    pre = root.val;
    search(root.right);
  };
  search(root);
  return !flag;
};

2.二叉树的层序遍历

题目：给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

思路：这里递归就比迭代麻烦

迭代：

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
  const res = [];
  if (!root) return res;
  const stack = [root];
  while (stack.length) {
    const temp = stack.map((item) => item.val);
    res.push(temp);
    const newStack = stack.reduce((res, item) => {
      if (item.left) res.push(item.left);
      if (item.right) res.push(item.right);
      return res;
    }, []);
    stack.splice(0, Infinity, ...newStack);
  }
  return res;
};

3.二叉树的锯齿层次遍历

题目：

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回锯齿形层次遍历如下：

[
  [3],
  [20,9],
  [15,7]
]

思路：和程序遍历类似，用一个变量记录方向即可

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var zigzagLevelOrder = function(root) {
  if (!root) return [];
  const stack = [root];
  let flag = true;
  const res = [];
  while (stack.length) {
    const tempStack = [];
    const temp = stack.reduce((res, item) => {
      if (flag) {
        res.push(item.val);
      } else {
        res.unshift(item.val);
      }
      if (item.left) {
        tempStack.push(item.left);
      }
      if (item.right) {
        tempStack.push(item.right);
      }
      return res
    }, []);
    res.push(temp);
    flag = !flag;
        stack.splice(0, Infinity, ...tempStack);
  }
  return res;
};

4.从前序与中序遍历结果构造二叉树

题目：

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

 

思路：可以注意到，前序遍历的第一个节点是根节点，所以我们只要找到根节点在中序遍历的下标，左边的节点构造子树，右边的节点构造右树。然后子树的根节点，在前序遍历中是当前根节点+当前子树的节点数量，左右子树的数量可由中序遍历的下标得知。所以递归处理的即可

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {number[]} preorder
 * @param {number[]} inorder
 * @return {TreeNode}
 */
var buildTree = (preorder, inorder) => {
  return helper(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1)
}

function helper(preorder, p_start, p_end, inorder, i_start, i_end) {
  if (p_start > p_end) return null 
  let rootVal = preorder[p_start] 
  let root = new TreeNode(rootVal) 
  let mid = inorder.indexOf(rootVal) 
  let leftNum = mid - i_start 

  root.left = helper(preorder, p_start + 1, p_start + leftNum, inorder, i_start, mid - 1)
  root.right = helper(preorder, p_start + leftNum + 1, p_end, inorder, mid + 1, i_end)
  return root
}

5.从中序和后序遍历序列构造二叉树

题目：

根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

思路：和前一题类似，后序遍历的最后一个节点是根节点，根据根节点在中序遍历结果中的位置，我们计算左右子树的数量，然后计算左右子树的根节点在后序遍历结果中的位置，递归处理

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {number[]} inorder
 * @param {number[]} postorder
 * @return {TreeNode}
 */
var buildTree = function(inorder, postorder) {
    let build = (inorder) => {
        if(!inorder.length) return null
        let tmp = postorder.pop(),mid = inorder.indexOf(tmp)
        let root = new TreeNode(tmp)
        root.right = build(inorder.slice(mid + 1))
        root.left = build(inorder.slice(0,mid))
        return root
    }
    return build(inorder)
};