xgqfrms™, xgqfrms® : xgqfrms's offical website of cnblogs! xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!

LeetCode 对称二叉树算法题解 All In One

LeetCode 对称二叉树算法题解 All In One

对称二叉树原理 图解

image

101. Symmetric Tree

  1. 对称二叉树

https://leetcode.com/problems/symmetric-tree/

https://leetcode.cn/problems/symmetric-tree/

error

image

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */


function dfs(node, arr) {
  if(node === null) {
    return;
  }
  // 中序遍历 (左根右)
  dfs(node.left, arr);
  arr.push(node.val);
  dfs(node.right, arr);
  // if(node.left !== null) {
  //   dfs(node.left, arr)
  // }
  // arr.push(node.val);
  // if(node.right !== null) {
  //   dfs(node.right, arr)
  // }
}

function isSymmetric(root: TreeNode | null): boolean {
  let result = false;
  // const left = [root.val];
  // const right = [root.val];
  const left = [];
  const right = [];
  dfs(root.left, left)
  dfs(root.right, right);
  console.log(`left`, left);
  console.log(`right`, right);
  if(JSON.stringify(left) === JSON.stringify(right.reverse())) {
    result = true;
  }
  // if(JSON.stringify(left) === JSON.stringify(right.reverse()) && JSON.stringify(left) !== JSON.stringify(right)) {
  //   result = true;
  // }
  return result;
};


// 先序遍历 （根,左右）
// 后序遍历 （左右,根）

// 中序遍历 （左,根,右） 324
// 中序遍历,逆序 （右,根,左）423 => 324

// 分成左右 child
// 左 child 中序遍历 （左根右）
// 右 child 中序遍历 （左根右） 再逆序 （右根左）✅
// 比较是否相等 

/*

通过测试用例：
195 / 199
输入：
[1,2,2,2,null,2]
输出：
true
预期结果：
false

*/


// function isSymmetric(root: TreeNode | null): boolean {
//   // Symmetric Tree / 对称树
//   // left child tree 
//   // right child tree
//   // ??? 映射/反转: 2->3->4 / 3->4->2 ??? 2->4->3 / 4->3->2
//   // 后续遍历 3->4->2->1
//   // 先序遍历 1->2->4->3 
//   // 中序遍历 4->2->3->1
//   return false;
// };


// tree generator 按层次，BFS 广度优先搜索生成 tree ✅ (从上到下，从左到右)


// [1,2,2,2,null,2 ] ❌ ??? 边界条件 [2,2] !== [2,2] 非镜像 bug ❌

// [1,2,2,2,null,2,2] ✅

solutions

动态遍历左右子树比较

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function dfs(nodeLeft, nodeRight) {
  if(nodeLeft === null && nodeRight === null) {
    return true;
  }
  if(nodeLeft === null || nodeRight === null) {
    return false;
  }
  if(nodeLeft.val !== nodeRight.val) {
    return false;
  }
  return dfs(nodeLeft.left, nodeRight.right) && dfs(nodeLeft.right, nodeRight.left);
}

function isSymmetric(root: TreeNode | null): boolean {
  return dfs(root.left, root.right);
};

// function dfs(node, arr) {
//   if(node === null) {
//     return;
//   }
//   // 中序遍历 (左根右)
//   if(node.left !== null) {
//     dfs(node.left, arr)
//   }
//   arr.push(node.val);
//   if(node.right !== null) {
//     dfs(node.right, arr)
//   }
// }



// function dfsCompare(nodeLeft, nodeRight, flag) {
//   if(nodeLeft === null && nodeRight === null) {
//     return;
//   }
//   if(nodeLeft.val !== nodeRight.val) {
//     flag = false;
//     return;
//   }
//   if(nodeLeft.left !== null && nodeRight.right !== null) {
//     dfsCompare(nodeLeft.left, nodeRight.right, flag)
//   }
//   if(nodeLeft.right !== null && nodeRight.left !== null) {
//     dfsCompare(nodeLeft.right, nodeRight.left, flag)
//   }
// }

// function isSymmetric(root: TreeNode | null): boolean {
//   let result = true;
//   dfsCompare(root.left, root.right, result)
//   return result;
// };


// 先序遍历 （根,左右）
// 后序遍历 （左右,根）

// 中序遍历 （左,根,右） 324
// 中序遍历,逆序 （右,根,左）423 => 324

// 分成左右 child
// 左 child 中序遍历 （左根右）
// 右 child 中序遍历 （左根右） 再逆序 （右根左）✅
// 比较是否相等 

/*

通过测试用例：
195 / 199
输入：
[1,2,2,2,null,2]
输出：
true
预期结果：
false

*/


// function isSymmetric(root: TreeNode | null): boolean {
//   // Symmetric Tree / 对称树
//   // left child tree 
//   // right child tree
//   // ??? 映射/反转: 2->3->4 / 3->4->2 ??? 2->4->3 / 4->3->2
//   // 后续遍历 3->4->2->1
//   // 先序遍历 1->2->4->3 
//   // 中序遍历 4->2->3->1
//   return false;
// };


// tree generator 按层次，BFS 广度优先搜索生成 tree ✅ (从上到下，从左到右)


// [1,2,2,2,null,2 ] ❌ ??? 边界条件 [2,2] !== [2,2] 非镜像 bug ❌

// [1,2,2,2,null,2,2] ✅



"use strict";

/**
 *
 * @author xgqfrms
 * @license MIT
 * @copyright xgqfrms
 * @created 2023-01-15
 * @modified 2023-02-02
 *
 * @description 101. Symmetric Tree
 * @description 101. 对称树
 * @difficulty Easy
 * @ime_complexity O(n)
 * @space_complexity O(n)
 * @augments
 * @example
 * @link https://leetcode.com/problems/symmetric-tree/
 * @link https://leetcode.cn/problems/symmetric-tree/
 * @solutions
 *
 * @best_solutions
 *
 */

export {};

const log = console.log;

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */


class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = (val === undefined ? 0 : val);
    this.left = (left === undefined ? null : left);
    this.right = (right === undefined ? null : right);
  }
}

function dfs(nodeLeft, nodeRight) {
  // 同时到达叶子节点，对称 ✅
  if(nodeLeft === null && nodeRight === null) {
    return true;
  }
  // 非同时到达叶子节点，非对称 ❌
  if(nodeLeft === null || nodeRight === null) {
    return false;
  }
  // 对应节点的值不同，非对称 ❌
  if(nodeLeft.val !== nodeRight.val) {
    return false;
  }
  // return 递归
  // 左子树 left === 右子树 right && 左子树 right === 右子树 left
  return dfs(nodeLeft.left, nodeRight.right) && dfs(nodeLeft.right, nodeRight.left);
}

function isSymmetric(root: TreeNode | null): boolean {
  return dfs(root?.left, root?.right);
};

LeetCode 题解 / LeetCode Solutions

https://www.youtube.com/results?search_query=+Leetcode+2

https://www.youtube.com/playlist?list=PLamwFu9yMruCBtS2tHUD77oI_Wsce-syE

YouTube & LeetCode 力扣官方算法题解视频列表

https://github.com/xgqfrms/leetcode/issues/14

https://www.youtube.com/channel/UCftIXZeipv4MTVwmfFphtYw/videos

类似问题

(🐞 反爬虫测试！打击盗版⚠️）如果你看到这个信息, 说明这是一篇剽窃的文章，请访问 https://www.cnblogs.com/xgqfrms/ 查看原创文章！

refs

image

https://leetcode.cn/problems/symmetric-tree/solution/dong-hua-yan-shi-101-dui-cheng-er-cha-shu-by-user7/

©xgqfrms 2012-2021

www.cnblogs.com/xgqfrms 发布文章使用：只允许注册用户才可以访问！

原创文章，版权所有©️xgqfrms, 禁止转载 🈲️，侵权必究⚠️！

posted @ 2023-02-02 22:55  xgqfrms  阅读(11)  评论(2)  编辑  收藏  举报