重学数据结构系列之——二叉树基础

1.二叉树

1.定义

每棵树有且仅有一个树根
左边就是一个二叉树（二叉树的每个结点最多只有两个孩子结点，也就是说每个结点最多有两个子树），右边是不确定是不是叫三叉树
其实我们的计算机的目录结构就像一棵树

2.实现

下面这个是储存int类型的二叉树，既可以int，又可以char请看最底部的代码

#include <iostream>
using namespace std;

//结点类
class Node{
public:
//数据
int data;
//左孩子和右孩子
Node *lchild, *rchild;
Node(int _data){
data = _data;
lchild = NULL;
rchild = NULL;
}
~Node(){
if (lchild != NULL) {
delete lchild;
}
if (rchild != NULL) {
delete rchild;
}
}
//先序遍历（先自己再左右，可以看到下面的顺序也是这样）
void preorder(){
//输出当前结点的数据域
cout<<data<<" ";
//左不为空，则递归调用先序遍历
if (lchild != NULL) {
lchild->preorder();
}
//右不为空，也递归调用先序遍历
if (rchild != NULL) {
rchild->preorder();
}
}
//中序遍历（先左，再中，再右）
void inorder(){
if (lchild != NULL) {
lchild->inorder();
}
cout<<data<<" ";
if (rchild != NULL) {
rchild->inorder();
}
}
//后序遍历（先左右，再中间）
void postorder(){
if (lchild != NULL) {
lchild->postorder();
}
if (rchild != NULL) {
rchild->postorder();
}
cout<<data<<" ";
}
//根据先序，中序构建一颗二叉树
//pre_str:先序遍历的字符串（如124536）
//in_str:中序遍历的字符串
//len：（先序）中序遍历的字符串的长度
Node* build(const string &pre_str, const string &in_str, int len){
//先序遍历的第一位（pre_str[0]）就是根结点，先构建根结点
//pre_str[0] - '0':因为我们这里用的数据域只是数字0-9，减去字符'0'就是实际的数字，其实就是他们的ASCII相减，你可以输出一下'9'-'0'是不是 9
Node *p = new Node(pre_str[0] - '0');
//查找中序遍历中根节点的位置（根结点左边的都是左子树的，右边的都是右子树）
int pos = in_str.find(pre_str[0]);
//左子树不为空，构建左子树
if (pos > 0) {
//以根结点的左子树作为新的根结点去构建即可
//其中左子树结点有pos个，先序中第一个是根结点，所以substr(1,pos)【表示从索引1开始，截取pos个字符】就是左子树的先序遍历
//in_str.substr(0,pos):从索引0开始，截取pos个字符
p->lchild = build(pre_str.substr(1,pos), in_str.substr(0,pos), pos);
}
//右子树不为空，构建右子树
if (len - pos -1 > 0) {
//其中右子树结点有len - pos -1个，先序中第一个是根结点，跟着是pos个左子树的，所以substr(pos+1)【表示从索引pos+1到字符串的最后】就是右子树先序遍历
//in_str.substr(pos+1):从索引pos+1开始到字符串的最后
p->rchild = build(pre_str.substr(pos+1), in_str.substr(pos+1), len - pos -1);
}
//构建完成,返回二叉树
return p;
}
};

class BinaryTree{
private:
//树的根，就是最上面的结点
Node *root;
public:
//无参构造函数
BinaryTree(){
//一开始是一颗没结点的树--空树
root = NULL;
}
//已知先序，中序遍历的构造函数
BinaryTree(const string &pre_str, const string &in_str, int len){
root = root->build(pre_str, in_str, len);
}
~BinaryTree(){
if (root != NULL) {
delete root;
}
}
//构建一个简单的二叉树以便测试
void build_demo(){
root = new Node(1);
root->lchild = new Node(2);
root->rchild = new Node(3);
root->lchild->lchild = new Node(4);
root->lchild->rchild = new Node(5);
root->rchild->rchild = new Node(6);

}
//先序遍历
void preorder(){
root->preorder();
}
//中序遍历
void inorder(){
root->inorder();
}
//后序遍历
void postorder(){
root->postorder();
}
};

int main(){
BinaryTree binarytree;
binarytree.build_demo();
cout<<"先序遍历"<<endl;
binarytree.preorder();
cout<<endl;
cout<<"中序遍历"<<endl;
binarytree.inorder();
cout<<endl;
cout<<"后序遍历"<<endl;
binarytree.postorder();
cout<<endl<<endl;

cout<<"根据先序中序构建二叉树并输出后续遍历结果"<<endl;
string pre_str = "136945827";
string in_str = "963548127";
BinaryTree binarytree2(pre_str, in_str, in_str.length());
binarytree2.postorder();
cout<<endl;

return 0;
}

3.运行结果

2.解决一个小问题：二叉树左右对调（镜像）

1.描述

已知先序和中序，输出原二叉树的后序和左右对调后（就是镜像）的后序遍历

2.代码实现

#include <iostream>
#include <string>
using namespace std;

//结点类
template<class Type> class Node{
public:
//数据
Type data;
//左孩子和右孩子
Node *lchild, *rchild;
Node(Type _data){
data = _data;
lchild = NULL;
rchild = NULL;
}
~Node(){
if (lchild != NULL) {
delete lchild;
}
if (rchild != NULL) {
delete rchild;
}
}
//先序遍历（先自己再左右，可以看到下面的顺序也是这样）
void preorder(){
//输出当前结点的数据域
cout<<data<<"";
//左不为空，则递归调用先序遍历
if (lchild != NULL) {
lchild->preorder();
}
//右不为空，也递归调用先序遍历
if (rchild != NULL) {
rchild->preorder();
}
}
//中序遍历（先左，再中，再右）
void inorder(){
if (lchild != NULL) {
lchild->inorder();
}
cout<<data<<"";
if (rchild != NULL) {
rchild->inorder();
}
}
//后序遍历（先左右，再中间）
void postorder(){
if (lchild != NULL) {
lchild->postorder();
}
if (rchild != NULL) {
rchild->postorder();
}
cout<<data<<"";
}
//根据先序，中序构建一颗二叉树
//pre_str:先序遍历的字符串（如124536）
//in_str:中序遍历的字符串
//len：（先序）中序遍历的字符串的长度
Node* build(const string &pre_str, const string &in_str, int len){
Node<Type> *p;
//先序遍历的第一位（pre_str[0]）就是根结点，先构建根结点
if (pre_str[0]>='0' && pre_str[0]<='9') {
//如果是数字类型
p = new Node<Type>(pre_str[0]-'0');
}else{
p = new Node<Type>(pre_str[0]);
}
//Node<Type> *p = new Node<Type>(pre_str[0]);
//查找中序遍历中根节点的位置（根结点左边的都是左子树的，右边的都是右子树）
int pos = in_str.find(pre_str[0]);
//左子树不为空，构建左子树
if (pos > 0) {
//以根结点的左子树作为新的根结点去构建即可
//其中左子树结点有pos个，先序中第一个是根结点，所以substr(1,pos)【表示从索引1开始，截取pos个字符】就是左子树的先序遍历
//in_str.substr(0,pos):从索引0开始，截取pos个字符
p->lchild = build(pre_str.substr(1,pos), in_str.substr(0,pos), pos);
}
//右子树不为空，构建右子树
if (len - pos -1 > 0) {
//其中右子树结点有len - pos -1个，先序中第一个是根结点，跟着是pos个左子树的，所以substr(pos+1)【表示从索引pos+1到字符串的最后】就是右子树先序遍历
//in_str.substr(pos+1):从索引pos+1开始到字符串的最后
p->rchild = build(pre_str.substr(pos+1), in_str.substr(pos+1), len - pos -1);
}
//构建完成,返回二叉树
return p;
}
Node* buildMirror(const string &pre_str, const string &in_str, int len){
Node<Type> *p;
if (pre_str[0]>='0' && pre_str[0]<='9') {
p = new Node<Type>(pre_str[0]-'0');
}else{
p = new Node<Type>(pre_str[0]);
}
int pos = in_str.find(pre_str[0]);
if (pos > 0) {
p->rchild = buildMirror(pre_str.substr(1,pos), in_str.substr(0,pos), pos);
}
if (len - pos -1 > 0) {
p->lchild = buildMirror(pre_str.substr(pos+1), in_str.substr(pos+1), len - pos -1);
}
return p;
}

};

template<class Type> class BinaryTree{
private:
//树的根，就是最上面的结点
Node<Type> *root;
public:
//无参构造函数
BinaryTree(){
//一开始是一颗没结点的树--空树
root = NULL;
}
//已知先序，中序遍历的构造函数
BinaryTree(const string &pre_str, const string &in_str, int len){
root = root->build(pre_str, in_str, len);
}
~BinaryTree(){
if (root != NULL) {
delete root;
}
}

//先序遍历
void preorder(){
root->preorder();
}
//中序遍历
void inorder(){
root->inorder();
}
//后序遍历
void postorder(){
root->postorder();
}
//构建镜像二叉树
void buildMirror(const string &pre_str, const string &in_str, int len){
root = root->buildMirror(pre_str, in_str, len);
}
};

int main(){
string pre_str;
string in_str;
cin>>pre_str>>in_str;
BinaryTree<char> binarytree(pre_str, in_str, in_str.length());
binarytree.postorder();
cout<<endl;
binarytree.buildMirror(pre_str, in_str, in_str.length());
binarytree.postorder();
cout<<endl;
return 0;
}

3.运行结果