[C++]封装二叉树
题目要求
（简单的说，就是把二叉树的功能封装起来）
binary tree is a tree data structure in which each node has at most two children, which are referred to as the left child and the right child.
Three Constructor:
creat a tree by copy.
creat a tree by a array.(using BFS)
creat a tree by preorder and inorder.
Methods:
clear: clear the tree.
copyTree: input old tree root and new tree root, copy get a new tree.
Static Methods:
three way to search tree.
测试文件：
#include <iostream>
#include "BinaryTree.hpp"
using namespace std;
void print(BinaryTree::Node * temp) {
cout << temp->val << " ";
}
std::vector<char> pre;
std::vector<char> in;
void getPreOrder(BinaryTree::Node * temp) {
pre.push_back(temp->val);
}
void getInOrder(BinaryTree::Node * temp) {
in.push_back(temp->val);
}
void testTree() {
cout << "test Tree" << endl;
int n = 1;
std::vector<char> tree;
cin >> n;
while (n--) {
char temp = ‘\0‘;
cin >> temp;
tree.push_back(temp);
}
BinaryTree x = BinaryTree(tree);
BinaryTree::preOrder(print, x.getRoot());
cout << endl;
BinaryTree::inOrder(print, x.getRoot());
cout << endl;
BinaryTree::postOrder(print, x.getRoot());
cout << endl;
BinaryTree::preOrder(getPreOrder, x.getRoot());
BinaryTree::inOrder(getInOrder, x.getRoot());
BinaryTree t = BinaryTree(pre, in);
BinaryTree::postOrder(print, t.getRoot());
cout << endl;
BinaryTree y = BinaryTree(t);
BinaryTree::preOrder(print, y.getRoot());
cout << endl;
BinaryTree::inOrder(print, y.getRoot());
cout << endl;
BinaryTree::postOrder(print, y.getRoot());
BinaryTree::preOrder(getPreOrder, y.getRoot());
BinaryTree::inOrder(getInOrder, y.getRoot());
}
int main() {
testTree();
}接口文件：
//
// BinaryTree.hpp
// C++
//
// Created by 李天培 on 16/5/4.
// Copyright ? 2016年 lee. All rights reserved.
//
#ifndef BinaryTree_hpp
#define BinaryTree_hpp
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#define EMPTY_ELE ‘#‘
class BinaryTree {
public:
struct Node {
char val;
Node* left;
Node* right;
Node(char v, Node* l = NULL, Node* r = NULL):
val(v), left(l), right(r) {
}
};
BinaryTree(const BinaryTree&);
BinaryTree(std::vector<char>&);
// created by preorder and inorder
BinaryTree(const std::vector<char>& preOrder,
const std::vector<char>& inOrder);
~BinaryTree();
Node* getRoot() const;
void clear();
static void preOrder(void (*visite)(BinaryTree::Node*), Node*);
static void inOrder(void (*visite)(BinaryTree::Node*), Node*);
static void postOrder(void (*visite)(BinaryTree::Node*), Node*);
private:
Node * copyNode(Node * oldNode, Node * newNode);
Node * root;
};
#endif /* BinaryTree_hpp */问题分析
先来讨论相对简单的访问二叉树问题。
遍历问题
前(先)序遍历
中序遍历
后序遍历
代码实现：
void BinaryTree::preOrder(void (*visite)(BinaryTree::Node *),
BinaryTree::Node * treeNode) {
if (treeNode != NULL) {
visite(treeNode);
preOrder(visite, treeNode->left);
preOrder(visite, treeNode->right);
}
}
void BinaryTree::inOrder(void (*visite)(BinaryTree::Node *),
BinaryTree::Node * treeNode) {
if (treeNode != NULL) {
inOrder(visite, treeNode->left);
visite(treeNode);
inOrder(visite, treeNode->right);
}
}
void BinaryTree::postOrder(void (*visite)(BinaryTree::Node *),
BinaryTree::Node * treeNode) {
if (treeNode != NULL) {
postOrder(visite, treeNode->left);
postOrder(visite, treeNode->right);
visite(treeNode);
}
}根据前序后序求中序
已知前序遍历为GDAFEMHZ，中序遍历为ADEFGHMZ，请画出这棵二叉树。
①根据前序遍历特征，我们知道根结点必在首位置，所以为G；
②根据中序遍历特征。其中根节点G左侧的ADEF必然是根节点的左子树，G右侧的HMZ必然是根节点的右子树；
③根据前序中序特征，重复以上步骤。递归找到子树根节点；
那么，我们可以画出这个二叉树：
由图可知，后序遍历顺序为：AEFDHZMG
代码实现
BinaryTree::Node* recursionBuild(const std::vector<char>& preorder,
unsigned long preLeft,
unsigned long preRight,
const std::vector<char>& inorder,
unsigned long inLeft,
unsigned long inRight) {
if (preLeft > preRight || preRight == preorder.size() ||
inLeft > inRight || inRight == inorder.size())
return NULL;
unsigned long i = 0;
BinaryTree::Node* node = new BinaryTree::Node(preorder[preLeft]);
for (i = inLeft; i <= inRight; i++) {
if (inorder[i] == node->val) {
break;
}
}
node->left = recursionBuild(preorder,
preLeft + 1, preLeft + i -inLeft,
inorder,
inLeft, i - 1);
node->right = recursionBuild(preorder,
preLeft + i - inLeft + 1, preRight,
inorder,
i + 1, inRight);
return node;
}
BinaryTree::BinaryTree(const std::vector<char> & preorder,
const std::vector<char> & inorder) {
root = NULL;
unsigned long preSize = preorder.size();
unsigned long inSize = inorder.size();
if (preSize == 0 || preSize != inSize) {
return;
}
root = recursionBuild(preorder, 0, preSize - 1,
inorder, 0, inSize - 1);
}根据后序中序求前序
已知一棵二叉树的中序序列和后序序列分别是BDCEAFHG 和 DECBHGFA，请画出这棵二叉树。
分析：
- ①由后序遍历特征，根结点必在后序序列尾部（即A）；
- ②由中序遍历特征，根结点必在其中间，而且其左部必全部是左子树的子孙（即BDCE），其右部必全部是右子树的子孙（即FHG）；
- ③递归找出子树根节点。
那么，我们可以画出这个二叉树：
注意事项：
左子树中序为BDCE，后序为DECB，说明B为A的左子树根节点，C为B的右子树（从BDCE看出）根节点（从DCE及DEC看出）；
右子树中序为FHG，后序为HGF，说明F为A的右子树的根节点，H为G的左子树根节点。
构造过程
接下来讨论在构造过程中出现的难点。
用队列让vector构造二叉树
用队列可以实现FIFO，从而让每一个节点都依次赋值。但必须注意在queue中要存储_Node**，就是存储一个指向指针的指针。（因为在其内部应该实现了深复制。所以如果只用_Node*会就会复制指针所指向的对象（都为NULL）,这与我们的算法就想违背了。）
BinaryTree::BinaryTree(std::vector<char>& orig) {
std::queue<_Node**> queue_Node;
if (!orig.empty() && orig[0] != EMPTY_ELE) {
root = new _Node(orig[0]);
queue_Node.push(&root->left);
queue_Node.push(&root->right);
int i = 1;
while (!queue_Node.empty()) {
_Node** temp = queue_Node.front();
queue_Node.pop();
if (i >= orig.size()) {
temp = NULL;
i++;
} else if (orig[i] == EMPTY_ELE) {
temp = NULL;
i++;
} else {
*temp = new _Node(orig[i++]);
queue_Node.push(&((*temp)->left));
queue_Node.push(&((*temp)->right));
}
}
} else {
root = NULL;
}
}第二种方法：（更细致的实现方法。）
BinaryTree::BinaryTree(std::vector<char> & elements) {
unsigned long size = elements.size();
int index = 0;
std::queue<Node*> queue;
if (elements.empty() || elements[index] == EMPTY_ELE) {
root = NULL;
} else {
root = new Node(elements[index]);
queue.push(root);
index += 1;
while (index < size) {
Node* temp = queue.front();
queue.pop();
if (elements[index] != EMPTY_ELE) {
temp->left = new Node(elements[index]);
queue.push(temp->left);
}
index += 1;
if (index >= size) {
break;
}
if (elements[index] != EMPTY_ELE) {
temp->right = new Node(elements[index]);
queue.push(temp->right);
}
index += 1;
}
}
}copy构造函数（递归实现）
BinaryTree::Node* BinaryTree::copyNode(BinaryTree::Node *oldNode,
BinaryTree::Node *newNode) {
if (oldNode == NULL) {
newNode = NULL;
return newNode;
}
newNode = new Node(oldNode->val);
newNode->left = copyNode(oldNode->left, newNode->left);
newNode->right = copyNode(oldNode->right, oldNode->right);
return newNode;
}
BinaryTree::BinaryTree(const BinaryTree &old) {
root = NULL;
root = copyNode(old.getRoot(), root);
}问题解决
//
// BinaryTree.cpp
// C++
//
// Created by 李天培 on 16/5/4.
// Copyright ? 2016年 lee. All rights reserved.
//
#include "BinaryTree.hpp"
BinaryTree::Node* recursionBuild(const std::vector<char>& preorder,
unsigned long preLeft,
unsigned long preRight,
const std::vector<char>& inorder,
unsigned long inLeft,
unsigned long inRight) {
if (preLeft > preRight || preRight == preorder.size() ||
inLeft > inRight || inRight == inorder.size())
return NULL;
unsigned long i = 0;
BinaryTree::Node* node = new BinaryTree::Node(preorder[preLeft]);
for (i = inLeft; i <= inRight; i++) {
if (inorder[i] == node->val) {
break;
}
}
node->left = recursionBuild(preorder,
preLeft + 1, preLeft + i -inLeft,
inorder,
inLeft, i - 1);
node->right = recursionBuild(preorder,
preLeft + i - inLeft + 1, preRight,
inorder,
i + 1, inRight);
return node;
}
BinaryTree::BinaryTree(const BinaryTree &old) {
root = NULL;
root = copyNode(old.getRoot(), root);
}
BinaryTree::BinaryTree(const std::vector<char> & preorder,
const std::vector<char> & inorder) {
root = NULL;
unsigned long preSize = preorder.size();
unsigned long inSize = inorder.size();
if (preSize == 0 || preSize != inSize) {
return;
}
root = recursionBuild(preorder, 0, preSize - 1,
inorder, 0, inSize - 1);
}
BinaryTree::BinaryTree(std::vector<char> & elements) {
unsigned long size = elements.size();
int index = 0;
std::queue<Node*> queue;
if (elements.empty() || elements[index] == EMPTY_ELE) {
root = NULL;
} else {
root = new Node(elements[index]);
queue.push(root);
index += 1;
while (index < size) {
Node* temp = queue.front();
queue.pop();
if (elements[index] != EMPTY_ELE) {
temp->left = new Node(elements[index]);
queue.push(temp->left);
}
index += 1;
if (index >= size) {
break;
}
if (elements[index] != EMPTY_ELE) {
temp->right = new Node(elements[index]);
queue.push(temp->right);
}
index += 1;
}
}
}
BinaryTree::Node* BinaryTree::copyNode(BinaryTree::Node *oldNode,
BinaryTree::Node *newNode) {
if (oldNode == NULL) {
newNode = NULL;
return newNode;
}
newNode = new Node(oldNode->val);
newNode->left = copyNode(oldNode->left, newNode->left);
newNode->right = copyNode(oldNode->right, oldNode->right);
return newNode;
}
BinaryTree::Node* BinaryTree::getRoot() const {
return root;
}
BinaryTree::~BinaryTree() {
clear();
}
void BinaryTree::clear() {
std::queue<Node*> queue;
if (root != NULL) {
queue.push(root);
}
while (!queue.empty()) {
Node * temp = queue.front();
queue.pop();
if (temp->left != NULL)
queue.push(temp->left);
if (temp->right != NULL)
queue.push(temp->right);
delete temp;
}
}
void BinaryTree::preOrder(void (*visite)(BinaryTree::Node*), Node* r = NULL) {
Node *temp = r;
if (temp == NULL) {
return;
} else {
visite(temp);
preOrder(visite, temp->left);
preOrder(visite, temp->right);
}
}
void BinaryTree::inOrder(void (*visite)(BinaryTree::Node*), Node* r = NULL) {
Node *temp = r;
if (temp == NULL) {
return;
} else {
inOrder(visite, temp->left);
visite(temp);
inOrder(visite, temp->right);
}
}
void BinaryTree::postOrder(void (*visite)(BinaryTree::Node*), Node* r = NULL) {
Node *temp = r;
if (temp == NULL) {
return;
} else {
postOrder(visite, temp->left);
postOrder(visite, temp->right);
visite(temp);
}
}时间： 2024-10-07 05:46:24