数据结构和算法经典100题-第15题

题目:

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

例如输入：

8

/ /

6 10

/ / / /

5 7 9 11

输出：

8

/ /

10 6

/ / / /

11 9 7 5

题目分析：

题目分析：

因为树的本质就是用递归实现的，所以用递归解决此问题并不难。就是有子树就翻转，那么上代码：

void BinaryTree::recursion(Node* obj) {
// 交换左右子树
swap(obj);

if (NULL != obj->left) {
recursion(obj->left);
}

if (NULL != obj->right) {
recursion(obj->right);
}

return ;
}

// 递归实现
Node* BinaryTree::reverseWithRecursion() {
recursion(m_root);
return m_root;
}

递归向迭代转化。其实递归调用树的关键思想就是利用了函数的栈。我们可以自己建立一个栈，来模拟函数的栈。从而在函数即将递归的时候，压入我们的栈，然后弹出。我们还是看一下代码，代码是不会骗人的。

// 迭代实现
void BinaryTree::reverseWithIteration() {
vector<Node*> stack;

stack.push_back(m_root);
Node* tmp = m_root;

while (NULL != tmp) {
// 把要交换的结点弹出栈
stack.pop_back();
swap(tmp);

//
if (NULL != tmp->left) {
stack.push_back(tmp->left);
}

if (NULL != tmp->right) {
stack.push_back(tmp->right);
}

if (0 < stack.size()) {
tmp = stack.back();
} else {
break;
}

}

return;
}

最后我们看一下完整的代码，首先我定义了一棵二叉树。

#ifndef ___00_alg_tests___5th__
#define ___00_alg_tests___5th__

#include <stdio.h>

struct Node {
int value;
Node* left;
Node* right;
};

class BinaryTree {
//递归
void recursion(Node* obj);

//
void swap(Node* obj);

// 树的根结点
Node* m_root;

public:
// 构造
BinaryTree(Node* root) : m_root(root) {};

// 析构
~BinaryTree() {};

// 递归实现
Node* reverseWithRecursion();

// 迭代实现
void reverseWithIteration();
};

int test_15();

#endif /* defined(___00_alg_tests___5th__) */

//
//  15th.cpp
//  100-alg-tests
//
//  Created by bobkentt on 15-5-10.
//  Copyright (c) 2015年 kedong. All rights reserved.
//

#include <vector>
#include <iostream>

#include "15th.h"

using namespace std;

/*
题目：输入一颗二元查找树，将该树转换为它的镜像，
即在转换后的二元查找树中，左子树的结点都大于右子树的结点。
用递归和循环两种方法完成树的镜像转换。
例如输入：
8
/ /
6  10
/ / / /
5 7 9 11

输出：
8
/ /
10  6
/ / / /
11 9 7  5

*/

void BinaryTree::swap(Node* obj) {
Node* tmp = obj->left;

obj->left = obj->right;

obj->right = tmp;

return ;
}

void BinaryTree::recursion(Node* obj) {
// 交换左右子树
swap(obj);

if (NULL != obj->left) {
recursion(obj->left);
}

if (NULL != obj->right) {
recursion(obj->right);
}

return ;
}

// 递归实现
Node* BinaryTree::reverseWithRecursion() {
recursion(m_root);
return m_root;
}

// 迭代实现
void BinaryTree::reverseWithIteration() {
vector<Node*> stack;

stack.push_back(m_root);
Node* tmp = m_root;

while (NULL != tmp) {
// 把要交换的结点弹出栈
stack.pop_back();
swap(tmp);

//
if (NULL != tmp->left) {
stack.push_back(tmp->left);
}

if (NULL != tmp->right) {
stack.push_back(tmp->right);
}

if (0 < stack.size()) {
tmp = stack.back();
} else {
break;
}

}

return;
}
void Link(Node* obj, int parrent, int left, int right) {

if (-1 != left) {
obj[parrent].left = &obj[left];
}

if (-1 != right) {
obj[parrent].right = &obj[right];
}

return ;
}

// 中序遍历打印树
void printTree(Node* obj)
{
if (NULL != obj) {

cout<<"Value = "<<obj->value<<endl;;
printTree(obj->left);
printTree(obj->right);

} else {
return ;
}
}

int test_15()
{
/* tree like:

0
/    \
1        2
/ \      / \
3   4    5   6
/          \
7            8

change into:
0
/      \
2        1
/ \      / \
6   5    4   3
/          \
8            7

*/

Node obj_1[9];
memset(obj_1, 0, sizeof(Node)*9);

for (int i = 0; i < 9; i++) {
obj_1[i].value = i;
obj_1[i].left = NULL;
obj_1[i].right = NULL;
}

Link(obj_1, 0, 1, 2);
Link(obj_1, 1, 3, 4);
Link(obj_1, 2, 5, 6);
Link(obj_1, 3, 7, -1);
Link(obj_1, 5, -1, 8);
//printTree(&obj_1[0]);
BinaryTree tree(&obj_1[0]);
//Node* root = tree.reverseWithRecursion();
tree.reverseWithIteration();
printTree(&obj_1[0]);

return 0;
}

测试结果：

Value = 0
Value = 2
Value = 6
Value = 5
Value = 8
Value = 1
Value = 4
Value = 3
Value = 7
Program ended with exit code: 0