zoukankan      html  css  js  c++  java
  • [GeeksForGeeks] Convert a binary tree into its mirror tree

    Given a binary tree, convert it to its mirror tree.

    Mirror of a binary tree T is another binary tree M with the left and right children of all non-leaf nodes exchanged in T.

    Solution 1. Recursion, O(n) runtime

    Recursively get the mirror binary tree of the left child and right child of node N;

    Then reassign the old right child as N's left child; reassign the old left child as N's right child.

    Key note: We can easily forget about adding line 15 of saving the reference to root's left. 

    If this line is not there, this program does not work. It would get the mirror tree of root's right subtree,

    then reassign it as root's new left child. Then we try to get the mirror tree of root's old left subtree by calling 

    getMirrorBinaryTree(root.left). But root.left has been changed to the mirror of its original right subtree!

    We lost the original left subtree forever!

     1 class TreeNode{
     2     int key;
     3     TreeNode left, right;
     4     TreeNode(int key){
     5         this.key = key;
     6         this.left = null;
     7         this.right = null;
     8     }
     9 }
    10 public class Solution {
    11     public TreeNode getMirrorBinaryTree(TreeNode root){
    12         if(root == null){
    13             return null;
    14         }
    15         TreeNode temp = root.left;
    16         root.left = getMirrorBinaryTree(root.right);
    17         root.right = getMirrorBinaryTree(temp);
    18         return root;
    19     }
    20 }

    Solution 2. Iterative approach,  tree traversal

    Level order traversal to swap each non-leaf node's left and right child nodes.

     1 import java.util.LinkedList;
     2 import java.util.Queue;
     3 
     4 class TreeNode{
     5     int key;
     6     TreeNode left, right;
     7     TreeNode(int key){
     8         this.key = key;
     9         this.left = null;
    10         this.right = null;
    11     }
    12 }
    13 public class Solution {
    14     public TreeNode getMirrorBinaryTree(TreeNode root){
    15         if(root == null){
    16             return null;
    17         }
    18         Queue<TreeNode> queue = new LinkedList<TreeNode>();
    19         queue.offer(root);
    20         while(!queue.isEmpty()){
    21             TreeNode curr = queue.poll();
    22             if(curr.left == null && curr.right == null){
    23                 continue;
    24             }
    25             TreeNode temp = curr.left;
    26             curr.left = curr.right;
    27             curr.right = temp;
    28             if(curr.left != null){
    29                 queue.offer(curr.left);
    30             }
    31             if(curr.right != null){
    32                 queue.offer(curr.right);
    33             }
    34         }
    35         return root;
    36     }
    37 }

    Follow up question: do all tree traversal methods work for this problem? (pre order, in order, post order and level order)

    Yes.

    Pre-order: swap children nodes first, then change left subtree to its mirror, change right subtree last; Top down approach

     1 public class Solution {
     2      public void getMirrorBinaryTree(TreeNode root){
     3          if(root == null){
     4              return;
     5          }
     6          TreeNode temp = root.left;
     7          root.left = root.right;
     8          root.right = temp;
     9          getMirrorBinaryTree(root.left);
    10          getMirrorBinaryTree(root.right);
    11      }
    12 }

    In-order

    Both pre and post order solutions are pretty straightforward. In order is a bit tricky. 

    First get the mirror of root's left subtree; 

    Then we swap root's children nodes; 

    Get the mirror of root's left subtree again as this new left subtree is the old right subtree of root.

     1 public class Solution {
     2      public void getMirrorBinaryTree(TreeNode root){
     3          if(root == null){
     4              return;
     5          }
     6          getMirrorBinaryTree(root.left);
     7          TreeNode temp = root.left;
     8          root.left = root.right;
     9          root.right = temp;
    10          getMirrorBinaryTree(root.left);
    11      }
    12 }

    Post-order: change left subtree to its mirror, then right subtree to its mirror, swap children nodes last; Bottom up approach

    Solution 1 is actually a post order traversal. The following re-implementation makes the post order nature more clear.

    Essentially we need to recursively get the mirror tree of root node's left subtree and right subtree, then exchange root's

    left and right child nodes.

     1 public class Solution {
     2      public void getMirrorBinaryTree(TreeNode root){
     3          if(root == null){
     4              return;
     5          }
     6          getMirrorBinaryTree(root.left);
     7          getMirrorBinaryTree(root.right);
     8          TreeNode temp = root.left;
     9          root.left = root.right;
    10          root.right = temp;
    11      }
    12 }

    Challenge:

    Use iterative tree traversal to solve this problem.

  • 相关阅读:
    numpy中linspace用法 (等差数列创建函数)
    Ubuntu环境下 matplotlib 图例中文乱码
    转载: 广义逆矩阵
    matplotlib.pyplot中add_subplot方法参数111的含义
    转载:(论文) 二次指数平滑法中确定初始值的简便方法
    图像处理之 opencv 学习---opencv 中的常用算法
    图像处理之 opencv 学习---矩阵的操作
    编译异常之static和extern---more than one storage class specified
    格式转换至yuv422转 yuv420
    阶段3 3.SpringMVC·_02.参数绑定及自定义类型转换_6 自定义类型转换器代码编写
  • 原文地址:https://www.cnblogs.com/lz87/p/7337139.html
Copyright © 2011-2022 走看看