二叉树的遍历方法总结与c++实现

最新推荐文章于 2024-03-16 00:12:35 发布
最新推荐文章于 2024-03-16 00:12:35 发布
阅读量738 收藏 4
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22642239/article/details/107094488
版权

概述：

二叉树的遍历方式分为：
深度遍历（前序，中序，后序）
广度遍历（层次遍历）

二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们平常所说的层次遍历。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁，而对于广度遍历来说，需要其他数据结构的支撑，比如堆了。所以，对于一段代码来说，可读性有时候要比代码本身的效率要重要的多。

四种主要的遍历思想为：

前序遍历：根结点 ---> 左子树 ---> 右子树   （此处所谓的根节点是以当前点作为根节点，并不是指整个二叉树的根节点）

中序遍历：左子树---> 根结点 ---> 右子树     （此处所谓的根节点是以当前点作为根节点，并不是指整个二叉树的根节点）

后序遍历：左子树 ---> 右子树 ---> 根结点    （此处所谓的根节点是以当前点作为根节点，并不是指整个二叉树的根节点）

层次遍历：只需按层次遍历即可

 

例如，求下面二叉树的各种遍历

前序遍历：1  2  4  5  7  8  3  6 

中序遍历：4  2  7  5  8  1  3  6

后序遍历：4  7  8  5  2  6  3  1

层次遍历：1  2  3  4  5  6  7  8


 

c++实现遍历方法：

BSTree.h

/**
 * C++ 语言: 二叉查找树
 *
 * @author skywang
 * @date 2013/11/07
 */

#ifndef _BINARY_SEARCH_TREE_HPP_
#define _BINARY_SEARCH_TREE_HPP_

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

template <class T>
class BSTNode{
    public:
        T key;            // 关键字(键值)
        BSTNode *left;    // 左孩子
        BSTNode *right;    // 右孩子
        BSTNode *parent;// 父结点

        BSTNode(T value, BSTNode *p, BSTNode *l, BSTNode *r):
            key(value),parent(),left(l),right(r) {}
};

template <class T>
class BSTree {
    private:
        BSTNode<T> *mRoot;    // 根结点

    public:
        BSTree();
        ~BSTree();

        // 前序遍历"二叉树"
        void preOrder();
        // 中序遍历"二叉树"
        void inOrder();
        // 后序遍历"二叉树"
        void postOrder();

        // (递归实现)查找"二叉树"中键值为key的节点
        BSTNode<T>* search(T key);
        // (非递归实现)查找"二叉树"中键值为key的节点
        BSTNode<T>* iterativeSearch(T key);

        // 查找最小结点：返回最小结点的键值。
        T minimum();
        // 查找最大结点：返回最大结点的键值。
        T maximum();

        // 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
        BSTNode<T>* successor(BSTNode<T> *x);
        // 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
        BSTNode<T>* predecessor(BSTNode<T> *x);

        // 将结点(key为节点键值)插入到二叉树中
        void insert(T key);

        // 删除结点(key为节点键值)
        void remove(T key);

        // 销毁二叉树
        void destroy();

        // 打印二叉树
        void print();
    private:
        // 前序遍历"二叉树"
        void preOrder(BSTNode<T>* tree) const;
        // 中序遍历"二叉树"
        void inOrder(BSTNode<T>* tree) const;
        // 后序遍历"二叉树"
        void postOrder(BSTNode<T>* tree) const;

        // (递归实现)查找"二叉树x"中键值为key的节点
        BSTNode<T>* search(BSTNode<T>* x, T key) const;
        // (非递归实现)查找"二叉树x"中键值为key的节点
        BSTNode<T>* iterativeSearch(BSTNode<T>* x, T key) const;

        // 查找最小结点：返回tree为根结点的二叉树的最小结点。
        BSTNode<T>* minimum(BSTNode<T>* tree);
        // 查找最大结点：返回tree为根结点的二叉树的最大结点。
        BSTNode<T>* maximum(BSTNode<T>* tree);

        // 将结点(z)插入到二叉树(tree)中
        void insert(BSTNode<T>* &tree, BSTNode<T>* z);

        // 删除二叉树(tree)中的结点(z)，并返回被删除的结点
        BSTNode<T>* remove(BSTNode<T>* &tree, BSTNode<T> *z);

        // 销毁二叉树
        void destroy(BSTNode<T>* &tree);

        // 打印二叉树
        void print(BSTNode<T>* tree, T key, int direction);
};

/*
 * 构造函数
 */
template <class T>
BSTree<T>::BSTree():mRoot(NULL)
{
}

/*
 * 析构函数
 */
template <class T>
BSTree<T>::~BSTree()
{
    destroy();
}

/*
 * 前序遍历"二叉树"
 */
template <class T>
void BSTree<T>::preOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        cout<< tree->key << " " ;
        preOrder(tree->left);
        preOrder(tree->right);
    }
}

template <class T>
void BSTree<T>::preOrder()
{
    preOrder(mRoot);
}

/*
 * 中序遍历"二叉树"
 */
template <class T>
void BSTree<T>::inOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        inOrder(tree->left);
        cout<< tree->key << " " ;
        inOrder(tree->right);
    }
}

template <class T>
void BSTree<T>::inOrder()
{
    inOrder(mRoot);
}

/*
 * 后序遍历"二叉树"
 */
template <class T>
void BSTree<T>::postOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        postOrder(tree->left);
        postOrder(tree->right);
        cout<< tree->key << " " ;
    }
}

template <class T>
void BSTree<T>::postOrder()
{
    postOrder(mRoot);
}

/*
 * (递归实现)查找"二叉树x"中键值为key的节点
 */
template <class T>
BSTNode<T>* BSTree<T>::search(BSTNode<T>* x, T key) const
{
    if (x==NULL || x->key==key)
        return x;

    if (key < x->key)
        return search(x->left, key);
    else
        return search(x->right, key);
}

template <class T>
BSTNode<T>* BSTree<T>::search(T key)
{
    search(mRoot, key);
}

/*
 * (非递归实现)查找"二叉树x"中键值为key的节点
 */
template <class T>
BSTNode<T>* BSTree<T>::iterativeSearch(BSTNode<T>* x, T key) const
{
    while ((x!=NULL) && (x->key!=key))
    {
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }

    return x;
}

template <class T>
BSTNode<T>* BSTree<T>::iterativeSearch(T key)
{
    iterativeSearch(mRoot, key);
}

/*
 * 查找最小结点：返回tree为根结点的二叉树的最小结点。
 */
template <class T>
BSTNode<T>* BSTree<T>::minimum(BSTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;

    while(tree->left != NULL)
        tree = tree->left;
    return tree;
}

template <class T>
T BSTree<T>::minimum()
{
    BSTNode<T> *p = minimum(mRoot);
    if (p != NULL)
        return p->key;

    return (T)NULL;
}

/*
 * 查找最大结点：返回tree为根结点的二叉树的最大结点。
 */
template <class T>
BSTNode<T>* BSTree<T>::maximum(BSTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;

    while(tree->right != NULL)
        tree = tree->right;
    return tree;
}

template <class T>
T BSTree<T>::maximum()
{
    BSTNode<T> *p = maximum(mRoot);
    if (p != NULL)
        return p->key;

    return (T)NULL;
}

/*
 * 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
 */
template <class T>
BSTNode<T>* BSTree<T>::successor(BSTNode<T> *x)
{
    // 如果x存在右孩子，则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
    if (x->right != NULL)
        return minimum(x->right);

    // 如果x没有右孩子。则x有以下两种可能：
    // (01) x是"一个左孩子"，则"x的后继结点"为 "它的父结点"。
    // (02) x是"一个右孩子"，则查找"x的最低的父结点，并且该父结点要具有左孩子"，找到的这个"最低的父结点"就是"x的后继结点"。
    BSTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->right))
    {
        x = y;
        y = y->parent;
    }

    return y;
}

/*
 * 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
 */
template <class T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T> *x)
{
    // 如果x存在左孩子，则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
    if (x->left != NULL)
        return maximum(x->left);

    // 如果x没有左孩子。则x有以下两种可能：
    // (01) x是"一个右孩子"，则"x的前驱结点"为 "它的父结点"。
    // (01) x是"一个左孩子"，则查找"x的最低的父结点，并且该父结点要具有右孩子"，找到的这个"最低的父结点"就是"x的前驱结点"。
    BSTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->left))
    {
        x = y;
        y = y->parent;
    }

    return y;
}

/*
 * 将结点插入到二叉树中
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 插入的结点
 */
template <class T>
void BSTree<T>::insert(BSTNode<T>* &tree, BSTNode<T>* z)
{
    BSTNode<T> *y = NULL;
    BSTNode<T> *x = tree;

    // 查找z的插入位置
    while (x != NULL)
    {
        y = x;
        if (z->key < x->key)
            x = x->left;
        else
            x = x->right;
    }

    z->parent = y;
    if (y==NULL)
        tree = z;
    else if (z->key < y->key)
        y->left = z;
    else
        y->right = z;
}

/*
 * 将结点(key为节点键值)插入到二叉树中
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     key 插入结点的键值
 */
template <class T>
void BSTree<T>::insert(T key)
{
    BSTNode<T> *z=NULL;

    // 如果新建结点失败，则返回。
    if ((z=new BSTNode<T>(key,NULL,NULL,NULL)) == NULL)
        return ;

    insert(mRoot, z);
}

/*
 * 删除结点(z)，并返回被删除的结点
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 删除的结点
 */
template <class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T>* &tree, BSTNode<T> *z)
{
    BSTNode<T> *x=NULL;
    BSTNode<T> *y=NULL;

    if ((z->left == NULL) || (z->right == NULL) )
        y = z;
    else
        y = successor(z);

    if (y->left != NULL)
        x = y->left;
    else
        x = y->right;

    if (x != NULL)
        x->parent = y->parent;

    if (y->parent == NULL)
        tree = x;
    else if (y == y->parent->left)
        y->parent->left = x;
    else
        y->parent->right = x;

    if (y != z)
        z->key = y->key;

    return y;
}

/*
 * 删除结点(z)，并返回被删除的结点
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 删除的结点
 */
template <class T>
void BSTree<T>::remove(T key)
{
    BSTNode<T> *z, *node;

    if ((z = search(mRoot, key)) != NULL)
        if ( (node = remove(mRoot, z)) != NULL)
            delete node;
}

/*
 * 销毁二叉树
 */
template <class T>
void BSTree<T>::destroy(BSTNode<T>* &tree)
{
    if (tree==NULL)
        return ;

    if (tree->left != NULL)
        return destroy(tree->left);
    if (tree->right != NULL)
        return destroy(tree->right);

    delete tree;
    tree=NULL;
}

template <class T>
void BSTree<T>::destroy()
{
    destroy(mRoot);
}

/*
 * 打印"二叉查找树"
 *
 * key        -- 节点的键值
 * direction  --  0，表示该节点是根节点;
 *               -1，表示该节点是它的父结点的左孩子;
 *                1，表示该节点是它的父结点的右孩子。
 */
template <class T>
void BSTree<T>::print(BSTNode<T>* tree, T key, int direction)
{
    if(tree != NULL)
    {
        if(direction==0)    // tree是根节点
            cout << setw(2) << tree->key << " is root" << endl;
        else                // tree是分支节点
            cout << setw(2) << tree->key << " is " << setw(2) << key << "'s "  << setw(12) << (direction==1?"right child" : "left child") << endl;

        print(tree->left, tree->key, -1);
        print(tree->right,tree->key,  1);
    }
}

template <class T>
void BSTree<T>::print()
{
    if (mRoot != NULL)
        print(mRoot, mRoot->key, 0);
}

#endif

main.cpp

/**
 * C++ 语言: 二叉查找树
 *
 * @author skywang
 * @date 2013/11/07
 */

#include <iostream>
#include "BSTree.h"
using namespace std;

static int arr[]= {1,5,4,3,2,6};
#define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) )

int main()
{
    int i, ilen;
    BSTree<int>* tree=new BSTree<int>();

    cout << "== 依次添加: ";
    ilen = TBL_SIZE(arr);
    for(i=0; i<ilen; i++)
    {
        cout << arr[i] <<" ";
        tree->insert(arr[i]);
    }

    cout << "\n== 前序遍历: ";
    tree->preOrder();

    cout << "\n== 中序遍历: ";
    tree->inOrder();

    cout << "\n== 后序遍历: ";
    tree->postOrder();
    cout << endl;

    cout << "== 最小值: " << tree->minimum() << endl;
    cout << "== 最大值: " << tree->maximum() << endl;
    cout << "== 树的详细信息: " << endl;
    tree->print();

    cout << "\n== 删除根节点: " << arr[3];
    tree->remove(arr[3]);

    cout << "\n== 中序遍历: ";
    tree->inOrder();
    cout << endl;

    // 销毁二叉树
    tree->destroy();

    return 0;
}

参考文章：https://www.cnblogs.com/skywang12345/p/3576373.html

https://blog.csdn.net/My_Jobs/article/details/43451187

小哈龙
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现二叉树非递归遍历方法实例总结
09-04
主要介绍了C++实现二叉树非递归遍历方法实例总结,是算法设计中比较经典的一个遍历算法,需要的朋友可以参考下
数据结构 二叉树的层次遍历 c/c++实现
weixin_63676550的博客
12-01 850
数据结构，二叉树的层次遍历 c/c++。此处，我们用T表示二叉树的根节点，出谁的时候，T 的指针就会移动到哪里，假设根节点是A，那么第一次首先是A，然后入队A的左右孩子。每出一个根，此时T的指针就指向谁，此时同时入队谁的左右孩子，顺序就不会错。上面那个代码实现，看似T的指针好像一直没有更新，但仔细观察队列的出队和入队的函数，会发现，每次出/入队的时候，都会用T保存已经出队或入队的元素地址，以此来完成对根节点指针T的更新。
二叉树的遍历 C++
m0_60284775的博客
03-07 5247
二叉树的遍历有三种： 1.前序遍历：遍历顺序是：先访问根节点，再遍历左子树，最后遍历右子树； 2.中序遍历：遍历顺序是：先遍历左子树，再访问根节点，最后遍历右子树； 3.后序遍历：遍历顺序是：先遍历左子树，再遍历右子树，最后访问根节点。 可以知道的是，无论我们使用哪种遍历方式，其实质都是dfs(深度优先搜索)； 代码实现：（假设已经给出树的序列) 1.前序遍历： #include<iostream> using namespace std; void pre(int a) {
C++二叉树及遍历方式
最新发布
qq_49209946的博客
03-16 399
PS：前中后序的递归版本代码非常的简单，所以如果有能力的情况下，最好还是学会迭代版本，其原理是利用了栈结构的先入后出的原则，实现了前中后序遍历，而层序遍历则利用了队列的先入先出原则实现，这个需要特别的注意一下，上面的代码可以直接当做模板。其中层序遍历最好理解，就是将二叉树从根节点向下，一层一层遍历出来，遍历出来的结果就是一个二维数组，一维长度就是数的高度，二维长度就是每层的节点的个数。（有一个很好记的方法，就是记根节点的位置，在前就是前序，在中就是中序，在后就是后续，因为左右的相对顺序是不会变的）
二叉树的各种遍历方法（C++版）
eternalpray的博客
10-04 1952
二叉树的遍历
C++实现二叉树的四种遍历方式（建议背诵）
August的博客
10-27 1980
1.前序遍历（先序遍历）   二叉树的前序遍历按照根->左子树->右子树的顺序进行遍历。实现二叉树的前序遍历有递归和非递归版本的实现方法。 前序遍历结果：ABDGHCEIF struct TreeNode{ int val; TreeNode*left; TreeNode*right; TreeNode(int x):val(x),left(NULL),right(NULL){} }; //前序遍历递归版本 class Solution { public: void preor
二叉树的遍历（C++）
阿怪的博客
03-22 2616
文章目录1、先序遍历2、中序遍历3、后序遍历 以如下二叉树为例： 1、先序遍历 【遍历过程】 a.访问根结点; b.先序遍历其左子树; c.先序遍历其右子树。 先序遍历序列为：ABDEFCGH 【代码】 //前序遍历 void GetPreOT(int bt){ if(bt == -1) return ; else{ cout << T[bt].Data; GetPreOT(T[bt].Left); GetPreOT(T[bt].Right); } } 2、中序遍历 【
二叉树遍历 非递归 C++实现代码
09-05
对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现
二叉树各种遍历算法的C++实现
05-19
包括了二叉树的各种递归与非递归的遍历算法 还可对二叉树所有结点求和
C++实现二叉树遍历序列的求解方法
09-04
主要介绍了C++实现二叉树遍历序列的求解方法,需要的朋友可以参考下
二叉树的遍历 （C++实现）
热门推荐
zhhp1001的博客
03-06 3万+
本文涉及三种常见的遍历方式 ： 先序遍历、中序遍历、后序遍历，以及用C++实现的非递归版本代码。 首先我们定义一下二叉树结点类 struct BinaryTreeNode { int val; BinaryTreeNode* leftchild; BinaryTreeNode* rightchild; BinaryTreeNode(int const&amp; _val, Bina...
【C++实现二叉树的遍历】
wddkxg的博客
06-29 758
本项目主要用于二叉树的基础遍历算法测试。 1.binarytree.h包含对二叉树的结构体定义以及二叉树的先序、中序、后序以及层次遍历。 2.binarytree.cpp包含对各个遍历算法的实现。 3.main.cpp包含了对于二叉树遍历算法的测试。
C++实现二叉树三种遍历方法
qq_40624616的博客
03-14 8040
文章目录前序遍历--递归中序遍历--递归后序遍历--递归 前序遍历–递归 文中的二叉树结构如下： struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} TreeNode(int x, TreeNode* le
数据结构-二叉树遍历(C++实现)
lydia的专栏lljstar.com
05-30 2433
文章目录3.3.1遍历方式3.3.2 实现方式1)树的构造数据构建树2)前序遍历结果递归实现非递归实现3)中序遍历结果递归实现非递归实现4)后序遍历结果递归实现非递归实现5)层次遍历结果实现6)测试程序3.3.3 例子1)输出二叉树叶子结点2)输出二叉树深度后序遍历算法层次遍历算法3)二叉树恢复 3.3.1遍历方式 先序遍历、中序遍历、后序遍历、层次遍历(广度优先遍历) 先序遍历(Pre-Ord...
c++实现二叉树并遍历
qq_43575504的博客
04-03 909
Ⅰ 有且只有一个称为根的节点 Ⅱ 有若干个互不相交的子树，这些子树本身也是一棵树 节点、父节点、子节点、子孙、堂兄弟 深度：从根节点到最底层节点的层数，根节点是第一层 叶子节点：没有子节点的节点 非终端节点：非叶子节点 度：子节点的个数 Ⅰ 一般树木：任意一个节点的子节点个数不受限制 Ⅱ 二叉树：任意一个节点的子节点个数最多两个，且子节点位置不可更改 ① 一般二叉树
二叉树各种遍历功能的实现（c/c++）
qq_62800173的博客
11-12 1888
二叉树的递归方式先序、中序、后序遍历，非递归方式先序、中序、后序遍历，层次遍历。
C++实现二叉树的三种遍历方式
qq_45893652的博客
04-03 1310
#C++实现二叉树的三种遍历方式 这里的话，关于二叉树的遍历有许多优化的算法，还有各种适应环境，这里对于刚学习的人正适合，主要要介绍的是二叉树最常见的三种遍历。 先定义一个二叉树的结构体 #include<cstdlib> #include<iostream> using namespace std; typedef struct BiTNode{ char data;...
c++二叉树遍历
clayhell的博客
09-02 1397
非递归实现。
4.二叉树的遍历(C++版)
weixin_44897707的博客
03-01 1988
二叉树的递归 1.二叉树递归遍历 二叉树的递归序 递归序过程： 两个注释1之间的代码代表第一次来到一个节点的时候，会判断一下这个节点是否为空； 来到这个节点的左树去遍历。 遍历完第二次回到本函数，进行两个注释2之间进行操作，两个注释2之间可以进行某些操作也可以不进行某些操作，但是一定会返回本函数。 来到这个节点的右树去遍历。 遍历完第三次回到本函数，进行两个注释3之间进行操作，两个注释3之间可以进行某些操作也可以不进行某些操作，但是一定会返回本函数。 本函数结束，返回。 void traversal(T
二叉树遍历的完整代码c++语言版
03-31
//定义二叉树结构体 struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; }; //前序遍历 void preorderTraversal(struct TreeNode* root){ if(root==NULL) return; printf("%d ",...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值