算法与数据结构面试题(18)-二叉树镜像

题目

输入一颗二元查找树，将该树转换为它的镜像，
即在转换后的二元查找树中，左子树的结点都大于右子树的结点。
用递归和循环两种方法完成树的镜像转换。

解题思路

递归遍历每个结点，然后转换左右结点。

代码

前人写的二叉树java类，直接拿过来用。但是它的中序和后续的遍历代码调用了前序的代码，需要修改下。

/**
* 二叉树的二叉链表表示
*/
public class BinaryTree<T> {

private TreeNode root; // 根节点

public BinaryTree() {
}

public BinaryTree(TreeNode root) {
this.root = root;
}

/**
* 定义节点 内部类
*/
private static class TreeNode<T> {
private T data = null; // 数据部分
private TreeNode lchild; // 左节点的引用
private TreeNode rchild; // 右节点的引用

protected TreeNode() {
}

protected TreeNode(T data, TreeNode lchild, TreeNode rchild) {
this.data = data;
this.lchild = lchild;
this.rchild = rchild;
}

private T getData() {
return data;
}

private void setData(T data) {
this.data = data;
}

private TreeNode getLchild() {
return lchild;
}

private void setLchild(TreeNode lchild) {
this.lchild = lchild;
}

private TreeNode getRchild() {
return rchild;
}

private void setRchild(TreeNode rchild) {
this.rchild = rchild;
}
}

/**
* 返回父结点
*
* @param element
* @return
*/
public TreeNode getParent(TreeNode element) {
// 如果传入参数为根节点或根节点为空，返回null
return (root == null || root == element) ? null : parent(root, element);
}

/**
* @param subTree
* @param element
* @return
*/
public TreeNode parent(TreeNode subTree, TreeNode element) {
if (subTree == null) {
return null;
}

// 如果subTree的左孩子节点或右孩子节点等于element，则返回subTree
if (subTree.getLchild() == element || subTree.getRchild() == element) {
// 返回父结点地址
return subTree;
}

TreeNode p;
// 现在左子树中找，如果左子树中没有找到，才到右子树去找
if ((p = parent(subTree.getLchild(), element)) != null) {
// 递归在左子树中搜索
return p;
} else {
// 递归在右子树中搜索
return parent(subTree.getRchild(), element);
}
}

/**
* 节点个数
*
* @return
*/
public int getSize() {
return getNum(root);
}

private int getNum(TreeNode node) {
if (node == null) {
return 0;
} else {
int i = getNum(node.getLchild());
int j = getNum(node.getRchild());
return j + i + 1;
}
}

/**
* 树高度
*
* @return
*/
public int getHeight() {
return getHeight(root);
}

private int getHeight(TreeNode tree) {
if (tree == null)
return 0;// 递归结束：空树高度为0
else {
int i = getHeight(tree.getLchild());
int j = getHeight(tree.getRchild());
return (i < j) ? (j + 1) : (i + 1);
}
}

/**
* 前序遍历 先访问根结点，然后遍历左子树，最后遍历右子树
*
* @param node
*/
public void preOrder(TreeNode node) {
if (node != null) {
System.out.println(node.getData());
preOrder(node.getLchild());
preOrder(node.getRchild());
}
}

/**
* 中序遍历 首先遍历左子树，然后访问根结点，最后遍历右子树
*
* @param node
*/
public void inOrder(TreeNode node) {
if (node != null) {
inOrder(node.getLchild());
System.out.println(node.getData());
inOrder(node.getRchild());
}
}

/**
* 后序遍历 首先遍历左子树，然后遍历右子树，最后遍历访问根结点
*
* @param node
*/
public void postOrder(TreeNode node) {
if (node != null) {
postOrder(node.getLchild());
postOrder(node.getRchild());
System.out.println(node.getData());
}
}

public static void main(String[] args) {
TreeNode leaf1 = new TreeNode("5", null, null); // 没有左右孩子节点
TreeNode leaf2 = new TreeNode("7", null, null); // 没有左右孩子节点
TreeNode leaf3 = new TreeNode("9", null, null); // 没有左右孩子节点
TreeNode leaf4 = new TreeNode("11", null, null); // 没有左右孩子节点

TreeNode n3 = new TreeNode("6", leaf1, leaf2); // 根节点左子树
TreeNode n4 = new TreeNode("10", leaf3, leaf4); // 根节点右子树
TreeNode root = new TreeNode("8", n3, n4); // 创建根节点

BinaryTree bt = new BinaryTree(root);
System.out.println("=======先序遍历======");
bt.preOrder(bt.root);
System.out.println("=======中序遍历======");
bt.inOrder(bt.root);
System.out.println("========后续遍历=======");
bt.postOrder(bt.root);
System.out.println("===========");
//		System.out.println(bt.getHeight());
//		System.out.println(bt.getSize());
//
//		System.out.println(bt.getParent(leaf1).getData());
}
}

现在我们来前序遍历二叉树的同事，再颠倒左右孩子。在前序遍历的方法里做一些修改。

//前序遍历并颠倒左右子树
public void preOrderAndTransform(TreeNode node) {
if (node != null) {
// System.out.println(node.getData());
// 先保存左孩子结点
TreeNode lNode = node.getLchild();
node.setLchild(node.getRchild());
node.setRchild(lNode);
preOrderAndTransform(node.getLchild());
preOrderAndTransform(node.getRchild());
}
}

测试程序：

public static void main(String[] args) {
TreeNode leaf1 = new TreeNode("5", null, null); // 没有左右孩子节点
TreeNode leaf2 = new TreeNode("7", null, null); // 没有左右孩子节点
TreeNode leaf3 = new TreeNode("9", null, null); // 没有左右孩子节点
TreeNode leaf4 = new TreeNode("11", null, null); // 没有左右孩子节点

TreeNode n3 = new TreeNode("6", leaf1, leaf2); // 根节点左子树
TreeNode n4 = new TreeNode("10", leaf3, leaf4); // 根节点右子树
TreeNode root = new TreeNode("8", n3, n4); // 创建根节点

BinaryTree bt = new BinaryTree(root);
System.out.println("=======先序遍历======");
bt.preOrder(bt.root);
System.out.println("=======中序遍历======");
bt.inOrder(bt.root);
System.out.println("========后续遍历=======");
bt.postOrder(bt.root);
System.out.println("======镜像=====");

// 镜像颠倒
bt.preOrderAndTransform(bt.root);
System.out.println("=======先序遍历======");
bt.preOrder(bt.root);
System.out.println("=======中序遍历======");
bt.inOrder(bt.root);
System.out.println("========后续遍历=======");
bt.postOrder(bt.root);

// System.out.println(bt.getHeight());
// System.out.println(bt.getSize());
//
// System.out.println(bt.getParent(leaf1).getData());
}

输出

=======先序遍历======
8
6
5
7
10
9
11
=======中序遍历======
5
6
7
8
9
10
11
========后续遍历=======
5
7
6
9
11
10
8
颠倒后 ：
=======先序遍历======
8
10
11
9
6
7
5
=======中序遍历======
11
10
9
8
7
6
5
========后续遍历=======
11
9
10
7
5
6
8

循环的话使用while。用游标指向下一个待转换的结点，直到结点的左右孩子都为空。否则颠倒2个字结点。