剑指Offer 二叉树的镜像

题目描述:

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

思路:

遍历二叉树 如果当前节点存在左子树和右子树 那么将两个子树进行交换



1) 递归实现

package com.hqq.exercise.tree;

/**
* MirrorTree 二叉树的镜像
* 题目描述:
* 请完成一个函数，输入一个二叉树，该函数输出它的镜像。
* 思路:
* 遍历两个二叉树 如果当前节点存在子节点的话 就交换它的两个子节点
* Created by heqianqian on 2017/8/12.
*/
public class MirrorTree {

/**
* 输出一个二叉树的镜像[递归]
* @param root 二叉树的根节点
*/
public static void mirrorTreeByRecursion(BinaryTreeNode root){
if(root == null){
return;
}
if(root.leftNode==null && root.rightNode == null){
return;
}
//如果存在子节点 那么就交换它的两个子节点
BinaryTreeNode temp = root.leftNode;
root.leftNode = root.rightNode;
root.rightNode =temp;

if (root.leftNode!=null){
mirrorTreeByRecursion(root.leftNode);
}

if (root.rightNode!=null){
mirrorTreeByRecursion(root.rightNode);
}
}

/**
* 输出一个二叉树的镜像[循环]
* @param root 二叉树的根节点
*/
public static void mirrorTreeByLoop(BinaryTreeNode root){
while (root!=null&&root.leftNode!=null&&root.rightNode!=null){
//交换节点
BinaryTreeNode temp = root.leftNode;
root.leftNode = root.rightNode;
root.rightNode = temp;
}
}
}

package com.hqq.exercise.tree;

import org.junit.Before;
import org.junit.Test;

import static org.junit.Assert.*;

/**
* MirrorTree 二叉树的镜像
* 题目描述:
* 请完成一个函数，输入一个二叉树，该函数输出它的镜像。
* 思路:
* 遍历两个二叉树 如果当前节点存在子节点的话 就交换它的两个子节点
* 样例输入:
* ------8
* ---6     10
* --5 7   9  11
* {8,6,5,7,10,9,11}
* 样例输出:
* ---------8
* -----10     6
* --11   9   7   5
* {8,10,11,9,6,7,5}
* Created by heqianqian on 2017/8/12.
*/
public class MirrorTreeTest {

private BinaryTreeNode root;

@Before
public void setUp() throws Exception {
root = new BinaryTreeNode(8);

BinaryTreeNode leftChild = new BinaryTreeNode(10);
leftChild.leftNode = new BinaryTreeNode(11);
leftChild.rightNode = new BinaryTreeNode(9);

BinaryTreeNode rightChild = new BinaryTreeNode(6);
rightChild.leftNode = new BinaryTreeNode(7);
rightChild.rightNode = new BinaryTreeNode(5);

root.leftNode = leftChild;
root.rightNode = rightChild;

System.out.println("Before Mirror");
print(root);
System.out.println();
}

@Test
public void test() throws Exception {
MirrorTree.mirrorTreeByRecursion(root);
System.out.println("After Mirror");
print(root);
}

/**
* 先序遍历二叉树
*/
private void print(BinaryTreeNode root) {
System.out.print(root.value + " ");
if (root.leftNode != null) {
print(root.leftNode);
}
if (root.rightNode != null) {
print(root.rightNode);
}
}
}

运行结果:

Before Mirror
8 10 11 9 6 7 5
After Mirror
8 6 5 7 10 9 11

2） 非递归实现

1.思路：使用层序遍历+队列实现

层序遍历二叉树 如果当前节点的左右子树不为空 那么交换左右子树

如果左节点非空 左节点入队列

如果右节点非空 右节点入队列

public static void mirrorTreeByLoopLevelTraversal(BinaryTreeNode root) {
Queue<BinaryTreeNode> treeNodeQueue = new LinkedBlockingDeque<>();
while (root != null) {
if (root.leftNode != null && root.rightNode != null) {
BinaryTreeNode temp = root.leftNode;
root.leftNode = root.rightNode;
root.rightNode = temp;
}
if (root.leftNode != null) {
treeNodeQueue.add(root.leftNode);
}
if (root.rightNode != null) {
treeNodeQueue.add(root.rightNode);
}
if (!treeNodeQueue.isEmpty()) {
root = treeNodeQueue.poll();
} else {
break;
}
}
}

2.使用先序遍历+栈

public static void mirrorTreeByLoopPreTraversal(BinaryTreeNode root) {
Stack<BinaryTreeNode> stack = new Stack<>();
stack.push(root);
BinaryTreeNode temp = null;
BinaryTreeNode t = null;
while (!stack.isEmpty()) {
temp = stack.pop();
//如果temp的左右子树不为空 那么交换左右子树
if (temp.leftNode != null && temp.rightNode != null) {
t = temp.leftNode;
temp.leftNode = temp.rightNode;
temp.rightNode = t;
}
//如果左子树不为空 左子树入栈
if (temp.leftNode != null) {
stack.push(temp.leftNode);
}
//如果右子树不为空 右子树入栈
if (temp.rightNode != null) {
stack.push(temp.rightNode);
}
}
}