手把手教数据结构与算法：简单二叉树（递归和迭代实现三种遍历）

于 2024-05-19 15:57:56 发布
阅读量1.7k 收藏 128
点赞数 151
分类专栏： 手把手教数据结构与算法 文章标签： 算法 二叉树 层序遍历 中序遍历 递归 迭代器模式 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73611714/article/details/138966686
版权

个人主页：

想转码的电筒人

专栏：

手把手教数据结构与算法

目录

二叉树

基本概念

树的基本术语

二叉树的定义

​编辑

二叉树的形态

基本形态

特殊形态

完全二叉树

满二叉树

完美二叉树

扩充二叉树

二叉树的常见基本操作

二叉树的基本性质

二叉树的存储方式

顺序存储

完全二叉树顺序存储

非完全二叉树的顺序存储

链接存储

二叉树类的应用

递归实现二叉树

问题描述

输入

输出

样例

解题思路

代码实现

结点类（Node）

二叉树类（Binary Tree）

公有函数

构造函数

基本函数

createTree()函数 

height()函数

size()函数 

遍历函数

preOrder()函数

midOrder 函数

postOrder 函数 

makeTree()函数

clear()函数

完整代码（递归法）

递归算法的问题

二叉树遍历迭代器

问题描述

输入

输出

样例

解题思路

前序遍历迭代器

中序遍历迭代器

后序遍历迭代器

代码实现

树结点类（Node）

辅助结点类（StNode）

链式栈类（linkStack）

 TreeIterator类

前序遍历（Preorder） 

中序遍历（InOrder）

后序遍历（PostOrder）

完整代码（迭代器）

附录

分类专栏

本专栏上一节

二叉树

基本概念

树的基本术语

结点的度：子结点或非空子树的个数

树的度：树中所有结点的度的最大值

叶结点：树中度为0的结点

中间结点：树中叶结点以外的结点，亦称内部结点

兄弟结点：父结点相同的结点彼此是兄弟结点

结点的层次：根结点在第1层；如果结点的层次是𝑘 (𝑘≥1) ，则其子结点都在第𝑘+1层。亦称结点的深度

结点的高度：叶结点的高度等于1；中间结点的高度等于其所有子结点的高度的最大值加1

树的高度：根结点的高度，亦称树的深度

有序树：树中各结点的子树从左向右依次排列，不能交换次序；否则称作无序树

森林：零个或多个互不相交（独立）的树的集合

二叉树的定义

二叉树（Binary Tree）：

二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点，因此二叉树的度为2。二叉树可以为空，或者由一个根节点和零个、一个或两个子树组成，这些子树也是二叉树。

二叉树的定义可以用递归的方式描述：

  1. 一个节点包含一个数据元素以及指向其左子树和右子树的指针。
  2. 左子树和右子树也是二叉树。
  3. 二叉树的子树可以为空，也可以包含一个或多个节点。

二叉树可以是有序的，也可以是无序的，它被广泛应用于表达式计算，数据压缩和编码，字符串处理和搜索中。

二叉树的形态

基本形态

从上面二叉树的递归定义可以看出，二叉树或为空，或为一个根结点加上两棵左右子树，因为两棵左右子树也是二叉树也可以为空，所以二叉树有5种基本形态：

特殊形态
完全二叉树

完全二叉树满足下述三个条件：

1.从第1层到第𝑑−2层全是度为2的中间结点

2.第𝑑层的结点都是叶结点，度为0

3.在第𝑑−1层，各结点的度从左向右单调非递增排列，同时度为1的结点要么没有，要么只有一个且该结点的左子树非空

下图为树的高度不超过3的所有完全二叉树

满二叉树

由度为0的叶结点和度为2的中间结点构成的二叉树，树中没有度为1的结点（国外定义）

国内定义满二叉树等同上文所述的完全二叉树

完美二叉树

对于高度（深度）为d≥1 的完全二叉树，如果第d-1层所有结点的度都是2，则该树是一个完美二叉树

扩充二叉树

扩充二叉树是二叉树中的一种，是指在二叉树中出现空子树的位置增加空树叶，所形成的二叉树

二叉树的常见基本操作

  1. 插入节点（Insert Node）：在二叉树中插入新的节点，通常需要遵循特定的插入规则，如二叉搜索树中保持节点值的有序性。

  2. 删除节点（Delete Node）：从二叉树中删除指定节点，需要考虑不同情况下的处理方法，如叶子节点、有一个子节点的节点、有两个子节点的节点等。

  3. 查找节点（Search Node）：在二叉树中查找指定值的节点，可以采用递归或迭代的方式实现。

  4. 遍历（Traversal）：遍历二叉树是指按照一定顺序访问树中的所有节点。常见的遍历方式包括： 

    1. 前序遍历（Preorder Traversal）：根-左-右

    2. 中序遍历（Inorder Traversal）：左-根-右

    3. 后序遍历（Postorder Traversal）：左-右-根

    4. 层序遍历（Level Order Traversal）：按层从左到右逐个访问节点

  5. 计算树的高度（Calculate Height）：计算二叉树的高度或深度，即树中从根节点到最远叶子节点的最长路径的长度。

  6. 判断是否为空树（IsEmpty）：检查二叉树是否为空，即是否包含任何节点。

  7. 判断树的相等性（Check Tree Equality）：比较两棵二叉树是否结构相同且对应节点的值相等

二叉树的基本性质

1.二叉树的第i层上至多有2^(i-2)（i≥1）个节点

2.深度为h的二叉树中至多含有2^(h-1)个节点

3.若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2+1

4.具有n个节点的满二叉树深为log2（n+1)

5.非空满二叉树中叶结点数等于中间结点数加1（满二叉树定理）

6.完全二叉树有n个结点(n≥1)，按层次从左向右连续编号。树中任一结点k (1≤k≤n)满足以下性质：

（1）如果2k≤n，则结点 k 的左子结点是 2k，否则没有左子结点

（2）如果2k+1≤n ，则结点 k 的右子结点是2k+1 ，否则没有右子结点

（3）如果 k>1，则结点 k 的父结点是 ⌊k/2⌋

二叉树的存储方式

顺序存储
完全二叉树顺序存储

完全二叉树所有结点可以分层从左向右连续编号，可用一组地址连续的存储单元（顺序表）存储二叉树的各个结点

非完全二叉树的顺序存储

（1）结点编号：树根的索引为1；设结点的编号为𝑘 (𝑘≥1)，如果其左子树非空，则左子结点的编号为2𝑘；如果右子树非空，则右子结点为2𝑘+1

（2）顺序存放：用一组地址连续的存储单元存储二叉树的各个结点

链接存储

使用链表存放二叉树，比顺序存储能更有效地表达二叉树的非线性逻辑结构

二叉树类的应用

下面让我们自己动手用递归的方法实现一棵二叉树，并完成求高度，规模以及遍历等操作。

递归实现二叉树

问题描述

创建两棵由非负整型值组成的二叉树 tree0 和 tree1，求出这两棵二叉树的高度及规模（节点数）并将他们归并为一棵新的树 tree2，求新的二叉树的高度、规模以及该树的前序、中序和后序遍历结果。

输入

第一行输入 tree0 的数据；
第二行输入 tree1 的数据；
第三行输入 tree2 根节点的数据

  • 备注：
    二叉树的创建过程为先输入根结点的值，创建根节点；对已添加到树上的每个结点，依次输入它的两个儿子的值。如果没有儿子，则输入特定值-1 作为标志。循环上述操作直至二叉树创建完成，下图为一个二叉树创建实例：
  • 二叉树的归并过程为将第三行输入的数据作为 tree2 的根节点，tree0 根节点成为 tree2 根节点的左节点，tree1 根节点成为 tree2根节点的右节点。
输出

第一行输出 tree0 的高度与规模；
第二行输出 tree1 的高度与规模；
第三行输出 tree2 的高度与规模；
第四行输出 tree2 的前序遍历结果；
第五行输出 tree2 的中序遍历结果；
第六行输出 tree2 的后序遍历结果

  • 备注：
    注意输出最后一行数据后即结束程序运行，不做换行处理。
样例

输入

1 2 3 4 -1 5 6 -1 -1 7 -1 -1 -1 -1 -1
3 2 1 0 -1 -1 -1 0 -1 0 -1 -1 -1
10

输出

4 7
5 6
6 14
10 1 2 4 3 5 7 6 3 2 0 0 0 1
4 2 1 7 5 3 6 10 0 0 0 2 3 1
4 2 7 5 6 3 1 0 0 0 2 1 3 10

解题思路

该问题创建两棵二叉树，求出树的高度和规模并且归并两棵树，输出归并后的前序、中序和后序遍历结果。由于树的特性，我们可以采用递归算法来求解树的高度、规模以及三种遍历结果，归并树时只需创建一个新节点，该结点的左结点和右结点分别指向两棵树的根节点即可。

代码实现

结点类（Node）

首先是树的结点设计，可以设计出下图所示结构体，Node 表示结点，其中包含有数据域data和左指针域left以及右指针域right，用于指向孩子结点。


其中 data 表示数据，其可以是简单的类型，也可以是复杂的结构体，故采用泛型编程template<typename Type>。左右指针表示，左右孩子，其指向下一个结点。结点类还有构造函数，在创建结点时可以进行初始化。

template <class Type>
struct Node {
        Node* left;
        Node* right;
        Type data;

        Node() :left(NULL), right(NULL) {}
        Node(Type item, Node* L = NULL, Node* R = NULL) :data(item), left(L), right(R) {}

        ~Node() {}
    };
二叉树类（Binary Tree）

二叉树类（Binary Tree）采用泛型编程，其中Type是模板参数，代表树中元素的类型。root为树的根结点，利用根结点可对整个树进行增删查改操作。

公有函数

含有一些基本函数或者通过公有函数调用私有函数，完成查询树根节点、高度和规模等功能

构造函数

构造函数用于初始化根节点，将root初始化为 NULL，表示树为空。

基本函数

getRoot() ： 返回根节点的值

getLeft()： 返回左子节点的值

getRight() ： 返回右子节点的值

Node* getroot() ： 返回指向根节点的指针

int size() const { return size(root); }： 返回二叉树的节点数（规模）

int height() const { return height(root); }： 返回二叉树的高度。

preOrder()，midOrder()，postOrder()：用于调用私有的前序、中序、后序遍历函数

template <class Type>
class BinaryTree {
public:
    BinaryTree() :root(NULL) {}
    BinaryTree(const Type& value) {
        root = new Node(value);
    }

    Type getRoot() const { return root->data; }
    Type getLeft() const { return root->left->data; }
    Type getRight() const { return root->right->data; }
    Node* getroot() { return root; }
    int size() const { return size(root); }
    int height() const { return height(root); }
    }
     void preOrder() const {
        if (root != NULL) {
            preOrder(root);
        }
        cout << endl;
    }

    void midOrder() const {
        if (root != NULL) {
            midOrder(root);
        }
        cout << endl;
    }

    void postOrder() const {
        if (root != NULL) {
            postOrder(root);
        }
        //cout << endl;
    }
};
createTree()函数 

用于创建一个二叉树，并根据输入的数据构建该二叉树的结构。

该函数首先定义一个队列 que，用于辅助构建二叉树，从标准输入中读取第一个节点的值 x，并检查其是否为标记值，如果是则将根节点置为空，结束函数。

如果根节点值不是标记值，则创建根节点，并将其加入队列中。

使用队列进行层次遍历：从队列中取出一个节点 tmp，并移出队列。 从标准输入中读取该节点的左子节点值 ldata 和右子节点值 rdata。 如果左子节点值不是标记值，则创建一个新节点，并将其设为当前节点 tmp 的左子节点，同时将新节点加入队列。 如果右子节点值不是标记值，则创建一个新节点，并将其设为当前节点 tmp 的右子节点，同时将新节点加入队列。 循环直到队列为空，即所有节点都已经处理完毕

void createTree(float flag) {
        queue<Node*> que;
        Node* tmp;
        Type x, ldata, rdata;
        cin >> x;
        if (x == flag) {
            root = NULL;
            return;
        }
        root = new Node(x);
        que.push(root);
        while (!que.empty())
        {
            tmp = que.front();
            que.pop();
            cin >> ldata >> rdata;
            if (ldata != flag)
                que.push(tmp->left = new Node(ldata));
            if (rdata != flag)
                que.push(tmp->right = new Node(rdata));
        }
    }
height()函数

递归求树高，如果当前节点不为空，则递归计算左子树和右子树的高度，并取较大值，返回 1（当前节点的高度）加上左右子树中较大的高度

int height(Node* t) const { 
        if (t == NULL) return 0;
        else {
            int lt = height(t->left), rt = height(t->right);
            return 1 + ((lt > rt) ? lt : rt);
        }
        }
size()函数 

递归求节点数（规模），如果当前节点不为空，则递归计算左子树和右子树的规模，并相加，返回 1（当前节点的规模）加上左右子树的节点数

int size(Node * t) const {
            if (t == NULL) return 0;
            return 1 + size(t->left) + size(t->right);
        }
遍历函数
preOrder()函数

对给定二叉树进行前序遍历，并将遍历结果输出到标准输出流中。如果当前节点指针不为空，则先输出当前节点的值，然后递归地对左子树和右子树进行前序遍历

midOrder 函数

对给定二叉树进行中序遍历，并将遍历结果输出到标准输出流中。如果当前节点指针不为空，则先递归地对左子树进行中序遍历，然后输出当前节点的值，最后递归地对右子树进行中序遍历。

postOrder 函数 

对给定二叉树进行后序遍历，并将遍历结果输出到标准输出流中。 如果当前节点指针不为空，则先递归地对左子树进行后序遍历，然后递归地对右子树进行后序遍历，最后输出当前节点的值。

void preOrder(Node * t) const {
            if (t != NULL) {
                cout << t->data << ' ';
                preOrder(t->left);
                preOrder(t->right);
            }
        }
        void midOrder(Node * t) const {
            if (t != NULL) {
                midOrder(t->left);
                cout << t->data << ' ';
                midOrder(t->right);
            }
        }
        void postOrder(Node * t) const {
            if (t != NULL) {
                postOrder(t->left);
                postOrder(t->right);
                cout << t->data << ' ';
            }
        }
makeTree()函数

创建一棵新的二叉树，并将两棵已有的二叉树作为其左子树和右子树

创建一个新的根节点，左节点指向tree1的根结点，右节点指向tree2的根结点

void makeTree(const Type& x, BinaryTree& lt, BinaryTree& rt) {
        root = new Node(x);
        root->left = lt.getroot();
        root->right = rt.getroot();
    }
clear()函数

用于清空树的所有节点

如果输入的根节点指针 t 为 NULL，则表示当前节点为空，直接返回，不做任何操作。 递归清空左子树和右子树，即先清空左子树，再清空右子树。 在清空左右子树后，删除当前节点 t，释放其内存

void clear(Node * t) {
         if (t->left != NULL)
                clear(t->left);
         if (t->right != NULL)
                clear(t->right);
            delete t;
            //t = NULL;
            return;
        }
完整代码（递归法）
#include <queue>
#include <stack>
#include <iostream>
using namespace std;
template <class Type>
class BinaryTree {
private:
    struct Node {
        Node* left;
        Node* right;
        Type data;

        Node() :left(NULL), right(NULL) {}
        Node(Type item, Node* L = NULL, Node* R = NULL) :data(item), left(L), right(R) {}

        ~Node() {}
    };
    Node* root;

public:
    BinaryTree() :root(NULL) {}
    BinaryTree(const Type& value) {
        root = new Node(value);
    }

    Type getRoot() const { return root->data; }
    Type getLeft() const { return root->left->data; }
    Type getRight() const { return root->right->data; }
    Node* getroot() { return root; }
    void makeTree(const Type& x, BinaryTree& lt, BinaryTree& rt) {
        root = new Node(x);
        root->left = lt.getroot();
        root->right = rt.getroot();
    }
    int size() const { return size(root); }
    int height() const { return height(root); }

    void preOrder() const {
        if (root != NULL) {
            preOrder(root);
        }
        cout << endl;
    }

    void midOrder() const {
        if (root != NULL) {
            midOrder(root);
        }
        cout << endl;
    }

    void postOrder() const {
        if (root != NULL) {
            postOrder(root);
        }
        //cout << endl;
    }
    // 此处输入等于 flag 表示该位置没有节点的情况
    void createTree(float flag) {
        queue<Node*> que;
        Node* tmp;
        Type x, ldata, rdata;
        cin >> x;
        if (x == flag) {
            root = NULL;
            return;
        }
        root = new Node(x);
        que.push(root);
        while (!que.empty())
        {
            tmp = que.front();
            que.pop();
            cin >> ldata >> rdata;
            if (ldata != flag)
                que.push(tmp->left = new Node(ldata));
            if (rdata != flag)
                que.push(tmp->right = new Node(rdata));
        }
    }

private:
    int height(Node* t) const { if (t == NULL) return 0;
        else {
            int lt = height(t->left), rt = height(t->right);
            return 1 + ((lt > rt) ? lt : rt);
        }
        }
    void clear(Node * t) {
         if (t->left != NULL)
                clear(t->left);
         if (t->right != NULL)
                clear(t->right);
            delete t;
            //t = NULL;
            return;
        }
        int size(Node * t) const {
            if (t == NULL) return 0;
            return 1 + size(t->left) + size(t->right);
        }
        //递归实现
        void preOrder(Node * t) const {
            if (t != NULL) {
                cout << t->data << ' ';
                preOrder(t->left);
                preOrder(t->right);
            }
        }
        //递归实现
        void midOrder(Node * t) const {
            if (t != NULL) {
                midOrder(t->left);
                cout << t->data << ' ';
                midOrder(t->right);
            }
        }
        //递归实现
        void postOrder(Node * t) const {
            if (t != NULL) {
                postOrder(t->left);
                postOrder(t->right);
                cout << t->data << ' ';
            }
        }
    };

int main() {
    int x;
    BinaryTree<int> tree, tree1, tree2;
    //第一颗树的构建，-1 作为没有子节点的标志
    tree.createTree(-1);
    cout << tree.height() << ' ' << tree.size() << endl;

    //第二颗树的构建
    tree1.createTree(-1);
    cout << tree1.height() << ' ' << tree1.size() << endl;

    //合并两棵树，x 为根节点的值
    cin >> x;
    tree2.makeTree(x, tree, tree1);
    cout << tree2.height() << ' ' << tree2.size() << endl;
    tree2.preOrder();
    tree2.midOrder();
    tree2.postOrder();
    return 0;
}

递归算法的问题

 (1) 存在不支持递归算法的程序设计语言  

 (2) 递归算法在运行中，需要系统在内存栈中分配空间保存函数的参数、返回地址以及局部变量等，运行效率较低    

(3)系统对每个进程分配的栈容量有限，如果二叉树的深度太大造成递归调用的层次太高，容易导致栈溢出

下面我们采用非递归算法实现二叉树，即用迭代的方法实现二叉树，关键是使用栈结构模拟函数调用中系统栈的工作原理

二叉树遍历迭代器

问题描述

二叉树的遍历可以使用递归算法实现， 但是递归算法的执行速度较慢， 而非递归的实现比较复杂。 现在希望使用二叉树的迭代器来实现二叉树的三种遍历（即， 前序遍历、 中序遍历和后序遍历），三种遍历对应于三种迭代器。

输入

第一行输入二叉树的节点数据， 用来创建一棵二叉树， 其输入逻辑类同实验“二叉树类的应用”。

  • 备注：
    1）二叉树的创建过程为先输入根结点的值， 创建根节点；
    2）对已添加到树上的每个结点， 依次输入它的两个儿子的值。 3）如果没有儿子， 则输入特定值-1 作为标志。
    循环上述操作直至二叉树创建完成，下图为一个二叉树创建实例：
输出

输出一共三行， 分别表示前、 中、 后序遍历结果， 每行整数间使用空格分开。

  • 备注：
    输出最后一行数据后即结束程序运行，不做换行处理。
样例

输入：

1 2 3 -1 -1 4 -1 -1 -1

输出：

1 2 3 4
2 1 4 3
2 4 3 1

解题思路

使用二叉树的迭代器来实现二叉树的三种遍历（前序遍历、中序遍历和后序遍历）可以通过栈来实现。

前序遍历迭代器

创建一个栈，将根节点压入栈中。 循环直到栈为空

（1）弹出栈顶节点，并输出其值

（2）如果栈顶节点有右子节点，则将右子节点压入栈中

（3）如果栈顶节点有左子节点，则将左子节点压入栈中

中序遍历迭代器

创建一个栈，将根节点及其所有左子节点压入栈中， 循环直到栈为空

（1）弹出栈顶节点，并输出其值

（2）如果弹出的节点有右子节点，则将右子节点及其所有左子节点压入栈中

后序遍历迭代器

创建两个栈，一个用于存储遍历结果，另一个用于辅助遍历。 将根节点压入第一个栈中。 循环直到第一个栈为空

（1）弹出栈顶节点，将其值插入第二个栈的栈顶

（2）如果弹出的节点有左子节点，则将左子节点压入第一个栈中

（3）如果弹出的节点有右子节点，则将右子节点压入第一个栈中

（4）最后输出第二个栈的所有元素即为后序遍历结果。

代码实现

树结点类（Node）

和递归方法的树结点基本相同，不再赘述

struct Node {
    Node* left;
    Node* right;
    Type data;
    Node() :left(NULL), right(NULL) {}
    Node(Type item, Node* L = NULL, Node* R = NULL) :data(item), left(L), right(R) {}
};
辅助结点类（StNode）

StNode 是用来辅助实现后序遍历的迭代器中的结构体。
（1）StNode 结构体存储了二叉树节点的指针信息以及辅助计数信息
（2）TimesPop 成员变量用于记录节点被弹出栈的次数
（3）StNode 结构体主要用于后序遍历迭代器中，通过记录节点被弹出栈的次数，可以判断何时访问节点，并确定节点的访问顺序。

template <class Type>
struct StNode
{
    Node<Type>* node;
    int TimesPop;
    StNode(Node<Type>* N = NULL) : node(N), TimesPop(0) {}
};
链式栈类（linkStack）

该链式栈类实现了栈的基本功能，包括入栈、出栈、返回栈顶元素、判断栈是否为空以及清空栈。由于采用链表作为底层数据结构，可以动态地管理内存空间

栈的详解可阅读：手把手教数据结构与算法：栈的应用（平衡符号和简单计算器）_计算器系统 栈-CSDN博客

template <class elemType>
class linkStack : public stack<elemType>
{
private:
    struct node {
        elemType data;
        node* next;
        node(const elemType& x, node* N = NULL) { data = x; next = N; }
        node() :next(NULL) {}
        ~node() {}
    };
    //结点定义 next和数据
    node* elem;
public:
    linkStack() { elem = NULL; }
    ~linkStack() {
        node* tmp;
        while (elem != NULL) {
            tmp = elem;
            elem = elem->next;
            delete tmp;
        }
    }
    bool isEmpty() { return elem == NULL; }
    void push(const elemType& x) {
        node* tmp = new node(x, elem);
        elem = tmp;
    }
    // 入栈
    elemType pop() {
        node* tmp = elem;
        elemType x = tmp->data;
        elem = elem->next;
        delete tmp;
        return x;
    }
    // 出栈 并返回头结点数据
    elemType top() { return elem->data; } 
    void makeEmpty() {
        node* tmp;
        while (elem != NULL) {
            tmp = elem;
            elem = elem->next;
            delete tmp;
        }
        elem = NULL;
    }
    // 清空栈
};
 TreeIterator类

TreeIterator 类提供一个通用的接口，用于实现二叉树的迭代器功能。通过派生类实现不同的遍历方式的 First() 和 operator++() 函数，可以实现前序、中序和后序遍历等不同的遍历方式。

template <class Type>
class TreeIterator {
public:
    TreeIterator(const BinaryTree<Type>& BT) : T(BT), current(NULL) {}
    virtual ~TreeIterator() {}
    // 第一个被访问的结点地址送 current
    virtual void First() = 0;
    // 下一个被访问的结点地址送 current
    virtual void operator++() = 0;
    // 判当前结点为空吗， 为空返回 True
    bool operator+() const { return current != NULL; }
    // 返回当前结点指针 current 所指向的结点的数据值。
    Type& operator()() const { return current->data; }

public:
    const BinaryTree<Type>& T;
    // BinaryTree<Type>::Node* current;
    Node<Type>* current;
    // 指向当前结点的指针。
};
前序遍历（Preorder） 

成员函数 First重写了基类中的纯虚函数 First()，用于定位到第一个被访问的节点。在该函数中，首先清空栈 s，然后将二叉树的根节点压入栈 s 中，最后调用 operator++() 函数。

成员函数 operator++

重写了基类中的纯虚函数 operator++()，用于定位到下一个被访问的节点。

（1）在该函数中，首先判断栈 s 是否为空，如果为空则将当前节点指针 current 置为空并返回；（2）如果栈不为空，则弹出栈顶节点，并将其指定为当前节点。然后，如果当前节点有右子节点，则将右子节点压入栈 s 中；如果当前节点有左子节点，则将左子节点压入栈 s 中。

template <class Type>
class Preorder : public TreeIterator<Type> //前序遍历迭代器
{
public:
    Preorder(const BinaryTree<Type>& R) : TreeIterator<Type>(R) { s.push(this->T.root); }
    ~Preorder() {}

    void First() {
        s.makeEmpty();
        if (this->T.root) s.push(this->T.root);
        operator++();
    }
    void operator++() {
        if (s.isEmpty()) {
            this->current = NULL; return;
        }
        this->current = s.top();
        s.pop();
        // 得到当前结点的地址， 并进行出栈操作。
        if (this->current->right != NULL)
            s.push(this->current->right); //非空右儿子进栈。
        if (this->current->left != NULL)
            s.push(this->current->left);  //非空左儿子进栈。
    }
protected:
    linkStack<Node<Type>*> s;
};
中序遍历（InOrder）

（1）首先，检查栈 s 是否为空，如果为空，说明已经完成了中序遍历，将当前节点指针 current 置为 NULL 并返回。

（2）如果栈不为空，则从栈 s 中弹出一个节点 Cnode。 对弹出的节点 Cnode 进行操作：

如果节点 Cnode 的遍历状态计数器 TimesPop 的值为 2，表示左子树已经被处理，当前节点可以被访问：将当前节点指针 current 指向节点 Cnode。 如果节点 Cnode 存在右子节点，则将右子节点压入栈 s 中，为下一次迭代做准备。 返回，结束函数执行。

如果节点 Cnode 的遍历状态计数器 TimesPop 的值不为 2，表示左子树还未处理，需要继续处理：将节点 Cnode 再次压入栈 s 中，表示暂时不访问当前节点，继续处理其左子树。 如果节点 Cnode 存在左子节点，则将其左子节点压入栈 s 中，为下一次迭代做准备。

template <class Type> class Inorder : public Postorder < Type >
{
public:
    Inorder(const BinaryTree < Type >& R) : Postorder<Type>(R) { }
    void operator++(); // 中序时的下一个结点的地址。
};
template <class Type>
void Inorder<Type>::operator++()
{
    if (this->s.isEmpty())
    { // 当栈空且 current 也为空时， 遍历结束。
        this->current = NULL; return;
    } // 置当前指针为空， 结束。
    StNode<Type> Cnode;
    for (; ; )
    {
            Cnode = this->s.top(); this->s.pop();
            if (++Cnode.TimesPop == 2)  // 左子树已处理,该结点可访问。
            {
                this->current = Cnode.node;
                if (Cnode.node->right != NULL)   // 有右儿子，进栈。
                    this->s.push(StNode<Type>(Cnode.node->right));
                return;
            }
            this->s.push(Cnode);
            if (Cnode.node->left != NULL)	
                this->s.push(StNode<Type>(Cnode.node->left));
    }
}
后序遍历（PostOrder）

（1）检查栈是否为空： 如果栈 s 为空，则表示遍历已经结束，将当前节点指针 current 置为空，并返回。

（2）弹出栈顶节点： 从栈 s 中弹出一个节点 Cnode。 更新节点的遍历状态： 对 Cnode 的遍历状态计数器 TimesPop 进行增加操作，表示当前节点被访问的次数。

（3）判断节点是否可访问： 如果 Cnode 的遍历状态计数器为 3，则表示当前节点已经完成了左右子树的访问，可以被访问。将当前节点指针 current 指向 Cnode.node，即当前节点。 返回，结束函数执行。

（4）根据节点的遍历状态进行入栈操作： 如果 Cnode 的遍历状态计数器为 1，则表示当前节点的左子树还未访问，需要访问左子树。如果当前节点有左子节点，则将其压入栈 s 中，同时将遍历状态计数器设为 2，表示左子树访问结束。 如果 Cnode 的遍历状态计数器为 2，则表示当前节点的左子树已经访问完毕，需要访问右子树。如果当前节点有右子节点，则将其压入栈 s 中，同时将遍历状态计数器设为 3，表示右子树访问结束。

template <class Type>
class Postorder : public TreeIterator<Type>
{
public:
    Postorder(const BinaryTree < Type >& R) : TreeIterator<Type>(R) {
        s.push(StNode<Type>(this->T.root));
    }
    ~Postorder() { }
    // 后序遍历时的第一个结点的地址。
    void First() {
        s.makeEmpty();
        if (this->T.root)  s.push(this->T.root);
        operator++();
    }
    // 后序遍历时的下一个结点的地址。
    void operator++() {
        if (s.isEmpty())
        { // 当栈空且 current 也为空时， 遍历结束。
            this->current = NULL;
            return;
        } // 置当前指针为空，结束。
        StNode<Type> Cnode;
        for (; ; )
        {
            { Cnode = s.top(); s.pop();
            if (++Cnode.TimesPop == 3) //该结点可访问。
            {
                this->current = Cnode.node; return;
            }
            s.push(Cnode);
            if (Cnode.TimesPop == 1)   // 转向访问左子树。 
            {
                if (Cnode.node->left != NULL)   // 有左儿子，进栈。
                    s.push(StNode<Type>(Cnode.node->left));
            }
            else {// Cnode.TimesPop == 2 访左结束，转向访问右子树。
                if (Cnode.node->right != NULL)
                    s.push(StNode<Type>(Cnode.node->right));
            }
            }
        }
    }
protected:
    linkStack<StNode<Type>> s;
};
完整代码（迭代器）
#include <queue>
#include <stack>
#include <iostream>
using namespace std;
template <typename Type>
struct Node {
    Node* left;
    Node* right;
    Type data;
    Node() :left(NULL), right(NULL) {}
    Node(Type item, Node* L = NULL, Node* R = NULL) :data(item), left(L), right(R) {}
}; 
//结点定义 左右子和数据
template <class Type>
struct StNode
{
    Node<Type>* node;
    int TimesPop;
    StNode(Node<Type>* N = NULL) : node(N), TimesPop(0) {}
};
template <class elemType>
class linkStack : public stack<elemType>
{
private:
    struct node {
        elemType data;
        node* next;
        node(const elemType& x, node* N = NULL) { data = x; next = N; }
        node() :next(NULL) {}
        ~node() {}
    };
    //结点定义 next和数据
    node* elem;
public:
    linkStack() { elem = NULL; }
    ~linkStack() {
        node* tmp;
        while (elem != NULL) {
            tmp = elem;
            elem = elem->next;
            delete tmp;
        }
    }
    bool isEmpty() { return elem == NULL; }
    void push(const elemType& x) {
        node* tmp = new node(x, elem);
        elem = tmp;
    }
    // 入栈
    elemType pop() {
        node* tmp = elem;
        elemType x = tmp->data;
        elem = elem->next;
        delete tmp;
        return x;
    }
    // 出栈 并返回头结点数据
    elemType top() { return elem->data; } 
    void makeEmpty() {
        node* tmp;
        while (elem != NULL) {
            tmp = elem;
            elem = elem->next;
            delete tmp;
        }
        elem = NULL;
    }
    // 清空栈
};
template <class Type>
class BinaryTree {
public:
    Node<Type>* root;
    struct stNode {
        Node<Type>* node;
        int timesPop;
        stNode(Node<Type>* N = NULL) :node(N), timesPop(0) {}
    };
public:
    BinaryTree() :root(NULL) {}
    BinaryTree(const Type& value) {
        root = new Node<Type>(value);
    }
    ~BinaryTree() {
        clear();
    }
    void clear() {
        if (root != NULL)
            clear(root);
        root = NULL;
    }
    void createTree(Type flag) {
        queue<Node<Type>*> que;
        Node<Type>* tmp;
        Type x, ldata, rdata;
        cin >> x;
        root = new Node<Type>(x);
        que.push(root);
        while (!que.empty())
        {
            tmp = que.front();
            que.pop();
            cin >> ldata >> rdata;
            if (ldata != flag)
                que.push(tmp->left = new Node<Type>(ldata));
            if (rdata != flag)
                que.push(tmp->right = new Node<Type>(rdata));
        }
    }
    // 创建一个树 并设置标志
private:
    void clear(Node<Type>* t) {
        if (t->left != NULL)
            clear(t->left);
        if (t->right != NULL)
            clear(t->right);
        delete t;
        return;
    }
    // 清除结点t
};
template <class Type>
class TreeIterator {
public:
    TreeIterator(const BinaryTree<Type>& BT) : T(BT), current(NULL) {}
    virtual ~TreeIterator() {}
    // 第一个被访问的结点地址送 current
    virtual void First() = 0;
    // 下一个被访问的结点地址送 current
    virtual void operator++() = 0;
    // 判当前结点为空吗， 为空返回 True
    bool operator+() const { return current != NULL; }
    // 返回当前结点指针 current 所指向的结点的数据值。
    Type& operator()() const { return current->data; }

public:
    const BinaryTree<Type>& T;
    // BinaryTree<Type>::Node* current;
    Node<Type>* current;
    // 指向当前结点的指针。
};
template <class Type>
class Preorder : public TreeIterator<Type> //前序遍历迭代器
{
public:
    Preorder(const BinaryTree<Type>& R) : TreeIterator<Type>(R) { s.push(this->T.root); }
    ~Preorder() {}

    void First() {
        s.makeEmpty();
        if (this->T.root) s.push(this->T.root);
        operator++();
    }
    void operator++() {
        if (s.isEmpty()) {
            this->current = NULL; return;
        }
        this->current = s.top();
        s.pop();
        // 得到当前结点的地址， 并进行出栈操作。
        if (this->current->right != NULL)
            s.push(this->current->right); //非空右儿子进栈。
        if (this->current->left != NULL)
            s.push(this->current->left);  //非空左儿子进栈。
    }
protected:
    linkStack<Node<Type>*> s;
};

template <class Type>
class Postorder : public TreeIterator<Type>
{
public:
    Postorder(const BinaryTree < Type >& R) : TreeIterator<Type>(R) {
        s.push(StNode<Type>(this->T.root));
    }
    ~Postorder() { }
    // 后序遍历时的第一个结点的地址。
    void First() {
        s.makeEmpty();
        if (this->T.root)  s.push(this->T.root);
        operator++();
    }
    // 后序遍历时的下一个结点的地址。
    void operator++() {
        if (s.isEmpty())
        { // 当栈空且 current 也为空时， 遍历结束。
            this->current = NULL;
            return;
        } // 置当前指针为空，结束。
        StNode<Type> Cnode;
        for (; ; )
        {
            { Cnode = s.top(); s.pop();
            if (++Cnode.TimesPop == 3) //该结点可访问。
            {
                this->current = Cnode.node; return;
            }
            s.push(Cnode);
            if (Cnode.TimesPop == 1)   // 转向访问左子树。 
            {
                if (Cnode.node->left != NULL)   // 有左儿子，进栈。
                    s.push(StNode<Type>(Cnode.node->left));
            }
            else {// Cnode.TimesPop == 2 访左结束，转向访问右子树。
                if (Cnode.node->right != NULL)
                    s.push(StNode<Type>(Cnode.node->right));
            }
            }
        }
    }
protected:
    linkStack<StNode<Type>> s;
};
template <class Type> class Inorder : public Postorder < Type >
{
public:
    Inorder(const BinaryTree < Type >& R) : Postorder<Type>(R) { }
    void operator++(); // 中序时的下一个结点的地址。
};
template <class Type>
void Inorder<Type>::operator++()
{
    if (this->s.isEmpty())
    { // 当栈空且 current 也为空时， 遍历结束。
        this->current = NULL; return;
    } // 置当前指针为空， 结束。
    StNode<Type> Cnode;
    for (; ; )
    {
            Cnode = this->s.top(); this->s.pop();
            if (++Cnode.TimesPop == 2)  // 左子树已处理,该结点可访问。
            {
                this->current = Cnode.node;
                if (Cnode.node->right != NULL)   // 有右儿子，进栈。
                    this->s.push(StNode<Type>(Cnode.node->right));
                return;
            }
            this->s.push(Cnode);
            if (Cnode.node->left != NULL)	
                this->s.push(StNode<Type>(Cnode.node->left));
    }
}
int main()
{
    BinaryTree<int> tree;
    tree.createTree(-1);

    Preorder<int> pre(tree);
    for (pre.First(); +pre; ++pre)
        cout << pre() << ' ';
    cout << endl;

    Inorder<int> in(tree);
    for (in.First(); +in; ++in)
        cout << in() << ' ';
    cout << endl;

    Postorder<int> post(tree);
    for (post.First(); +post; ++post)
        cout << post() << ' ';
    return 0;
}

附录

分类专栏

链接：

​​​​​手把手教数据结构与算法

本专栏上一节

链接：

手把手教数据结构与算法：优先级队列（银行排队问题）-CSDN博客

想转码的电筒人
关注
  • 151
    点赞
  • 踩
  • 128
    收藏
    觉得还不错? 一键收藏
  • 177
    评论
专栏目录
[数据结构基础]链式二叉树及其前序、中序、后序和层序遍历
weixin_43908419的博客
01-17 2261
本文介绍了链式二叉树的结构和实现，并介绍了其前序、中序和后序遍历
二叉树 常用函数 小结
阿拉修
12-15 2977
实现功能如下 insertLeft 左插 insertRight 右插 delLeft 左删 delRight 右删 preorder 前序遍历 inorder 中序遍历 postorder 后序遍历 levelOrder 层序遍历 traversal 遍历汇总 getHeight 树高 size 树的结点个数 movetree 将a树移到b树的左侧 preCreate 人机交互创建树 reverse 将树的结点翻转 BitreeNode 类代码如下： package tree; class BiTree
3. 二叉树的后续遍历 (postOrder)
没戴面具的小丑
07-27 1670
头文件：　用到的是前序遍历中的头文件，具体可参见 "二叉树的前序遍历" 一，后序遍历的概念 后序遍历 按照 左儿子-右儿子-根节点 的顺序访问二叉树 方式 1，递归遍历 2，栈迭代遍历 (借助栈结构) 3, Morris 遍历 (栈迭代的基础上优化空间复杂度) 二，递归遍历 /* 递归遍历 先访问当前节点的左子树，然后再访问当前...
红黑树 rb_first_postorder rb_next_postorder 两个函数作用举例
zqwone的专栏
04-11 688
struct rb_node *rb; for (rb = rb_first_postorder(&root.rb_root); rb; rb = rb_next_postorder(rb)) { } 上述for循环作用是遍历红黑树上每个结点，假如遍历的是如下这棵树 a / \ b c / \ / \ d e h i / \ f g 顺序是： d f g e b h i c a ...
Generator函数的理解和使用
Hei, Welcome To vickie's Blog，Good Good Study, Day Day Up ~
10-02 1万+
Generator 函数是 ES6 提供的一种异步编程解决方案，所谓“异步”，简单说就是一个任务分成两段，先执行第一段，然后转而执行其他任务，等做好了准备，再回过头执行第二段。
数据结构与算法：树和二叉树.pptx
05-11
数据结构中的树是一种重要的非线性数据结构，它模拟...总的来说，理解和掌握树和二叉树的概念、术语、性质及其应用是学习数据结构与算法的重要基础，它们在软件开发、数据库设计、编译原理等多个领域都有着广泛的应用。
C语言数据结构之二叉树的非递归后序遍历算法
01-01
C语言数据结构之二叉树的非递归后序遍历算法 前言： 前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一...
用递归和非递归算法实现二叉树的三种遍历.docx
05-07
通过实验，我们可以看到递归算法和非递归算法都可以实现二叉树的三种遍历，但是递归算法更容易理解和实现，而非递归算法需要使用栈来实现。同时，我们也可以看到二叉树的三种遍历算法的时间复杂度都是O(n)，其中n是...
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。
07-01
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，...
二叉树遍历算法收集(先序 preorder，后序 postorder，中序 inorder） 循环+递归
weixin_33819479的博客
10-07 789
preorder: root-left-rightinorder: left-root-rightpostorder: left-right-root order指的是root的位置。 recursive算法比较简单，iterative算法比较难想，可是leetcode原题都说了： recursive method is trivial,...
二叉树的实现及相关函数的实现
心之所向，一如既往
05-04 814
#include <iostream> #include <queue> #include <stack>using namespace std;template<typename T> struct BinaryNode //__默认构造函数__ { BinaryNode() : _pData(0) , _pLeftChild(NULL) , _pRightCh
二叉树基本操作函数（先、中、后、层次遍历，含全部代码）
关注网络安全、云原生安全
01-12 1万+
InitTree(BiTree &amp;T) 参数T，二叉树根节点 作用：初始化二叉树，先序递归创建 PreOrder(BiTree T)  参数T，二叉树根节点 作用：先序遍历二叉树，递归方式 InOrder(BiTree T)   参数T，二叉树根节点 作用：中序遍历二叉树，递归方式 PostOrder(BiTree T) 参数T，二叉树根节点 作用：后序遍历二叉树，递归方式 LevelOr...
数据结构与算法
Javavaa的博客
10-12 259
复杂度 （通过复杂度可以评判出算法的性能） 1. 时间复杂度： 估算程序指令的执行次数（执行时间） 2. 空间复杂度： 估算程序执行所占用的存储空间 3. 大O表示法： 用该方法可以估算出算法的复杂度 方法：忽略常数，系数，低阶 9 -----> O(1) 2n + 3 -----> O(n) n^2 + 2n + 6 -----> O(n^2) 4n^3 + 3n^2 + 22n + 5 -----> O(n^3) 复杂度大小比较： O(1) < O(logn) <
数据结构基本操作函数功能
weixin_43657184的博客
07-17 1620
一：线性表及其存储 操作集合如下。 (1 ) void init (sequence list *slt)顺序表的初始化- (2) void append (sequence_ list *slt,datatype x) 在顺序表后部插人值为x的结点。 (3) void display (sequence_ list slt)打印顺序 表的各结点值。 (4) int empty (sequence_ list slt). 判断顺序表是否为空。 (5) int find (sequence_ list slt
LeetCode - 590 - N叉树的后续遍历（n-ary-tree-postorder-traversal）
weixin_41806099的博客
11-23 128
一 目录 不折腾的前端，和咸鱼有什么区别目录一 目录二 前言三 解题及测试四 LeetCode Submit五 解题思路六 进一步思考二 前言 难度：简单涉及知识：树题目...
二叉树的先序(preorder)，中序（inorder），后序(postorder)的遍历(python)
热门推荐
15plus的博客
09-11 3万+
本篇文章主要是总结二叉树的三种遍历方式，和相关leetcode算法题的解法。 跟线性的数据结构（矩阵，列表，队列，栈···）不同，树的遍历可以有不同的遍历方式。 先序遍历 遍历过程如下： 访问根节点， 访问当前节点的左子树， 访问当前节点的右子树。 先序遍历的应用场景主要是对树进行复制。对于上面的树，先序遍历的顺序是1 2 4 5 3. 简单的用递归实现一下： def printPreord...
数据结构与算法：遍历二叉树的后序方法
文章中的CREATS(S)算法就是后序遍历的一种实现，它利用栈操作进行非递归遍历。 线索化二叉树是一种特殊形式的二叉树，通过添加线索(thread)来标识节点的前驱和后继，使得在非递归情况下也能方便地进行中序遍历或...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 177
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值