二叉树的多种遍历方式

最新推荐文章于 2022-05-24 20:15:00 发布
最新推荐文章于 2022-05-24 20:15:00 发布
阅读量486 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzuhuang/article/details/17447571
版权
#ifndef   __TREE_H__
#define   __TREE_H__

#include   <vector>

enum   {    DirLeft   = 0,   DirRight   = 1, };

struct   node
{
        int       nNodeData   ;
        node *    pLeftNode   ;
        node *    pRightNode   ;
};

class   CTree
{
public   :
        CTree ()   {}
     ~   CTree ()  {}

        void   Initialize   ();
        bool   InsertNode   (   int   nValue   );

        void   InOrderRecursion   ();          //   递归中根遍历
        void   InOrderRecusionHelp   (   node *   pNode   );
        void   PreOrderRecursion   ();         //   递归前根遍历
        void   PreOrderRecursionHelp   (   node *   pNode   );
        void   PostOrderRecursion   ();        //   递归后根遍历
        void   PostOrderRecursionHelp   (   node *   pNode   );

        void   InOrderNoRecursion   ();         //   非递归中根遍历
        void   PreOrderRecursionWay1   ();      //   非递归前跟遍历方式
        void   PreOrderRecursionWay2   ();      //   非递归前跟遍历方式
        void   PostOrderNoRecursion1   ();      //   非递归后跟遍历方式
        void   PostOrderNoRecursion2   ();      //   非递归后跟遍历方式

        //   层次遍历
        void   LevelTravase   ();

        void   PrintTree   ();
private   :
        node *   m_pRoot   ;
        std :: vector   < int >   m_vecInOrderRecur ;
        std :: vector   < int >   m_vecInOrderNoRecur ;
     
        std :: vector   < int >   m_vecPreOrderRecur ;
        std :: vector   < int >   m_vecPreOrderNoRecur1   ;
        std :: vector   < int >   m_vecPreOrderNoRecur2   ;

        std :: vector   < int >   m_vecPostOrderRecur ;
        std :: vector   < int >   m_vecPostOrderNoRecur   ;
        std :: vector   < int >   m_vecPostOrderNoRecur2   ;

        std :: vector   < int >   m_vecLevelTravse ;
};




#endif   // _TREE_H_
// TravseTree.cpp : Defines the entry point for the console application.
//

#include   "stdafx.h"
#include   "Tree.h"
#include   <iostream>
#include   <list>

void   CTree ::   Initialize ()
{
        m_pRoot   =   NULL   ;
}

bool   CTree ::   InsertNode (   int   nValue   )
{
        node *   pNewNode   =   new   node ;
        if ( ! pNewNode   )
     {
             return   false   ;
     }

        pNewNode -> nNodeData     =   nValue ;
        pNewNode -> pLeftNode     =   NULL ;
        pNewNode -> pRightNode   =   NULL ;

        if (   m_pRoot   ==   NULL   )
     {
             m_pRoot   =   pNewNode   ;
             return   true   ;
     }

        int   nDir   = -1;
        node *   pFindPlace   =   m_pRoot ;
        while ( 1 )
     {
             if (   nValue   > (   pFindPlace ->   nNodeData   ) )
          {
                 if (   pFindPlace   -> pRightNode   )
                      pFindPlace   =   pFindPlace   -> pRightNode ;
                 else
              {
                      nDir   =   DirRight   ;
                      break ;
              }
          }
             else
          {
                 if (   pFindPlace   -> pLeftNode   )
                      pFindPlace   =   pFindPlace   -> pLeftNode ;
                 else
              {
                      nDir   =   DirLeft   ;
                      break ;
              }
          }
     }

        if (   DirLeft   ==   nDir   )
             pFindPlace -> pLeftNode     =   pNewNode ;
        else
             pFindPlace -> pRightNode   =   pNewNode ;
        return   true   ;
}


void   CTree ::   InOrderRecursion ()
{
        m_vecInOrderRecur . clear   ();
        InOrderRecusionHelp (   m_pRoot   );
}

void   CTree ::   InOrderRecusionHelp (   node   *   pNode   )
{
        if ( ! pNode   )
             return   ;

        InOrderRecusionHelp (   pNode   -> pLeftNode   );
        m_vecInOrderRecur . push_back   (   pNode ->   nNodeData   );
        InOrderRecusionHelp (   pNode   -> pRightNode   );
}

void   CTree ::   InOrderNoRecursion ()
{
        node *   pNode   =   m_pRoot ;
        std :: vector   < node *>   listNodeSet ;
        listNodeSet . clear   ();
        m_vecInOrderNoRecur . clear   ();

        do
     {
             while (   pNode   )
          {
                 listNodeSet . push_back   (   pNode   );
                 pNode   =   pNode   -> pLeftNode ;
          }

             pNode   =   listNodeSet   . back ();
             m_vecInOrderNoRecur . push_back   (   pNode ->   nNodeData   );
             listNodeSet . pop_back   ();
          
             pNode   =   pNode   -> pRightNode ;
     }   while (   pNode   || ! listNodeSet .   empty () );
}

void   CTree ::   PreOrderRecursion ()
{
        m_vecPreOrderRecur . clear   ();
        PreOrderRecursionHelp   (   m_pRoot   );
}

void   CTree ::   PreOrderRecursionHelp   (   node *   pNode   )
{
        if ( ! pNode   )
             return   ;

        m_vecPreOrderRecur . push_back   (   pNode ->   nNodeData   );
        PreOrderRecursionHelp   (   pNode ->   pLeftNode   );
        PreOrderRecursionHelp   (   pNode ->   pRightNode   );
}

void   CTree ::   PreOrderRecursionWay1   ()
{
        m_vecPreOrderNoRecur1   . clear ();
        std :: vector   < node *>   vecNodeSet ;
        vecNodeSet . clear   ();
        vecNodeSet . push_back   (   m_pRoot   );
        node *   pTempNode   ;

        while ( ! vecNodeSet   . empty () )
     {
             pTempNode   =   vecNodeSet   . back ();
             vecNodeSet . pop_back   ();
             m_vecPreOrderNoRecur1   . push_back (   pTempNode   -> nNodeData   );

             if (   pTempNode   -> pRightNode   )
                 vecNodeSet . push_back   (   pTempNode ->   pRightNode   );
          
             if (   pTempNode   -> pLeftNode   )
                 vecNodeSet . push_back   (   pTempNode ->   pLeftNode   );
     }
}


void   CTree ::   PreOrderRecursionWay2   ()
{
        m_vecPreOrderNoRecur2   . clear ();
        std :: vector   < node *>   vecNodeStack ;
        vecNodeStack . clear   ();
        node *   TempNode   =   m_pRoot ;

        do
     {
             while (   TempNode   )
          {
                 m_vecPreOrderNoRecur2   . push_back (   TempNode   -> nNodeData   );
                 vecNodeStack . push_back   (   TempNode   );
                 TempNode   =   TempNode   -> pLeftNode ;
          }

             TempNode   =   vecNodeStack   . back ();
             vecNodeStack . pop_back   ();

             TempNode   =   TempNode   -> pRightNode ;
     }   while ( !(   NULL   ==   TempNode   &&   vecNodeStack . empty   () ) );
}


void   CTree ::   PostOrderRecursion ()
{
        m_vecPostOrderRecur . clear   ();
        PostOrderRecursionHelp   (   m_pRoot   );
}

void   CTree ::   PostOrderRecursionHelp   (   node *   pNode   )
{
        if ( ! pNode   )
             return   ;

        PostOrderRecursionHelp   (   pNode ->   pLeftNode   );
        PostOrderRecursionHelp   (   pNode ->   pRightNode   );
        m_vecPostOrderRecur . push_back   (   pNode ->   nNodeData   );
}

void   CTree ::   PostOrderNoRecursion1   ()
{
        m_vecPostOrderNoRecur   . clear ();
        std :: vector   < node *>   vecNodeSet ;
        vecNodeSet . clear   ();
        vecNodeSet . push_back   (   m_pRoot   );

        while ( ! vecNodeSet   . empty () )
     {
             node *   p   =   vecNodeSet .   back ();
             vecNodeSet . pop_back   ();
             m_vecPostOrderNoRecur   . push_back (   p -> nNodeData   );

             if (   p   -> pLeftNode   )
                 vecNodeSet . push_back   (   p ->   pLeftNode   );
             if (   p   -> pRightNode   )
                 vecNodeSet . push_back   (   p ->   pRightNode   );
     }

        int   nSize   =   m_vecPostOrderNoRecur . size   ();
     --   nSize ;
        int   nTempData   ;
        for (   int   i   = 0;   i   <   nSize   ; ++ i , --   nSize   )
     {
             nTempData   =   m_vecPostOrderNoRecur   [ i ];
             m_vecPostOrderNoRecur   [ i ] =   m_vecPostOrderNoRecur   [ nSize ];
             m_vecPostOrderNoRecur   [ nSize ] =   nTempData ;
     }
}

void   CTree ::   PostOrderNoRecursion2   ()
{
        m_vecPostOrderNoRecur2   . clear ();
        std :: vector   < node *>   vecNodeStack ;
        vecNodeStack . clear   ();
        node *   TempNode   =   m_pRoot ;

        do
     {
             while (   TempNode   )
          {
                 m_vecPostOrderNoRecur2   . push_back (   TempNode   -> nNodeData   );
                 vecNodeStack . push_back   (   TempNode   );
                 TempNode   =   TempNode   -> pRightNode ;
          }

             TempNode   =   vecNodeStack   . back ();
             vecNodeStack . pop_back   ();

             TempNode   =   TempNode   -> pLeftNode ;
     }   while ( !(   NULL   ==   TempNode   &&   vecNodeStack . empty   () ) );
}

void   CTree ::   LevelTravase ()
{
        m_vecLevelTravse . clear   ();
        std :: list   < node *>   listNodeQueue ;
        listNodeQueue . clear   ();
        listNodeQueue . push_back   (   m_pRoot   );

        while ( ! listNodeQueue   . empty () )
     {
             node *   pFindNode   =   listNodeQueue .   front ();
             listNodeQueue . pop_front   ();

             m_vecLevelTravse . push_back   (   pFindNode ->   nNodeData   );

             if (   pFindNode   -> pLeftNode   )
                 listNodeQueue . push_back   (   pFindNode   -> pLeftNode   );

             if (   pFindNode   -> pRightNode   )
                 listNodeQueue . push_back   (   pFindNode   -> pRightNode   );
     }
}

void   CTree ::   PrintTree ()
{
        int   nSize   =   m_vecInOrderRecur .   size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   中序遍历   ---- 递归 ------------"   << std ::   endl << std   :: endl ;
             for (   int   i   = 0;   i   <   nSize   ; ++ i   )
                 std :: cout   << "    " << m_vecInOrderRecur   [ i ]<<   "  " <<   std :: endl   ;
     }

        nSize   =   m_vecInOrderNoRecur   . size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   中序遍历   ---- 非递归 ------------" <<   std :: endl   << std ::   endl ;
             for (   int   i   = 0;   i   <   nSize   ; ++ i   )
                 std :: cout   << "    " <<   m_vecInOrderNoRecur [ i   ]<< "  " <<   std :: endl   ;
     }

        nSize   =   m_vecPreOrderRecur   . size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   前序遍历   ---- 递归 ------------"   << std ::   endl << std   :: endl ;
             for (   int   i   = 0;   i   <   nSize   ; ++ i   )
                 std :: cout   << "    " << m_vecPreOrderRecur   [ i ]<<   "  " <<   std :: endl   ;
     }

      nSize   =   m_vecPreOrderNoRecur1   . size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   前序遍历   ---- 非递归 ------------" <<   std :: endl   << std ::   endl ;
             for (   int   i   = 0;   i   <   nSize   ; ++ i   )
                 std :: cout   << "    " <<   m_vecPreOrderNoRecur1   [ i ]<<   "  " << std   :: endl ;
     }

        nSize   =   m_vecPreOrderNoRecur2   . size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   前序遍历   ---- 非递归 ------------" <<   std :: endl   << std ::   endl ;
             for (   int   i   = 0;   i   <   nSize   ; ++ i   )
                 std :: cout   << "    " <<   m_vecPreOrderNoRecur2   [ i ]<<   "  " << std   :: endl ;
     }
     
        nSize   =   m_vecPostOrderRecur   . size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   后序遍历   ---- 递归 ------------"   << std ::   endl << std   :: endl ;
             for (   int   i   = 0;   i   <   nSize   ; ++ i   )
                 std :: cout   << "    " <<   m_vecPostOrderRecur [ i   ]<< "  " <<   std :: endl   ;
     }

        nSize   =   m_vecPostOrderNoRecur   . size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   后序遍历   ---- 非递归 ------------" <<   std :: endl   << std ::   endl ;
             for (   int   i   = 0;   i   <   nSize   ; ++ i   )
                 std :: cout   << "    " <<   m_vecPostOrderNoRecur   [ i ]<<   "  " << std   :: endl ;
     }

        nSize   =   m_vecPostOrderNoRecur2   . size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   后序遍历   ---- 非递归 ------------" <<   std :: endl   << std ::   endl ;
             for (   int   i   =   nSize   - 1;   i   >= 0; -- i   )
                 std :: cout   << "    " <<   m_vecPostOrderNoRecur2   [ i ]<<   "  " << std   :: endl ;
     }

        nSize   =   m_vecLevelTravse   . size ();
        if (   nSize   != 0 )
     {
             std :: cout   << "   层次遍历   ------------" << std   :: endl <<   std :: endl   ;
             for (   int   i   = 0;   i   <   nSize   ; ++ i   )
                 std :: cout   << "    " << m_vecLevelTravse   [ i ]<<   "  " <<   std :: endl   ;
     }
}

#include   "stdafx.h"
#include   "Tree.h"

const   static   int   A   [8] = { 14, 5, 10, 23, 6, 90, 2, 31 };

int   main ()
{
        CTree   tree   ;
        tree . Initialize   ();
        for (   int   i   = 0;   i   < 8; ++ i   )
             tree . InsertNode   (   A [   i ] );

        tree . InOrderRecursion   ();
        tree . InOrderNoRecursion   ();
     
        tree . PreOrderRecursion   ();
        tree . PreOrderRecursionWay1   ();
        tree . PreOrderRecursionWay2   ();

        tree . PostOrderRecursion   ();
        tree . PostOrderNoRecursion1   ();
        tree . PostOrderNoRecursion2   ();

        tree . LevelTravase   ();

        tree . PrintTree   ();

        system (   "pause"   );
        return   0;
}








郑祖煌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的遍历_二叉树的遍历_
10-01
使用C语言实现是多种二叉树的遍历方式，分别为层序遍历、顺序递归、非递归中序遍历、中序线索二叉树
[算法] 二叉树的 先序遍历、中序遍历、后序遍历
scxyz的博客
02-27 3万+
本文根据清华大学邓俊辉老师课程《数据结构》总结，课程地址 。 遍历介绍 按照事先约定的某种规则或次序，对节点各访问一次而且仅一次。与向量和列表等线性结构一样，二叉树的这类访问也统称为遍历（traversal）。 二叉树本身并不具有天然的全局次序， 故为实现遍历，需通过在各节点与其孩子之间约定某种局部次序， 间接地定义某种全局次序。 按惯例左兄弟优先于右兄弟， 若记做节点 V ，...
一文弄懂二叉树的三种遍历方式
高性能架构探索
08-31 2万+
关注公众号:高性能架构探索。后台回复【资料】，可以免费领取 俗话说：学如逆水行舟,不进则退;心似平原走马,易放难收。这句话对程序员而言，体会更深。这行已经越来越卷了，时刻准备着，????。 二叉树，在面试中，已是必备的开胃菜。而在二叉树相关的面试题目中，遍历更是常考题目。本文将从二叉树的遍历角度入手，从递归和非递归角度来分析和讲解二叉树的遍历。 遍历 二叉树的遍历是指从根节点出发，按照某种次序依次访问二叉树中的所有节点，使每个节点被且仅被访问一次。 二叉树的遍历，有先序遍历、中序遍历以
二叉树的遍历
super码力的博客
05-24 3169
遍历一棵二叉树有很多种方法。假如用D、L、R分别代表二叉树的根结点、左子树、右子树，那么要遍历这棵二叉树，方法就有6种：DLR、DRL、LDR、LRD、RDL、RLD。一般在遍历时遵循先左后右的原则，因此常用的遍历方法有三种：DLR，称为先（根）序遍历；LDR，称为中（根）序遍历；LRD，称为后（根）序遍历。
二叉树的遍历（递归遍历）
littesss的博客
06-28 909
一、什么是二叉树的遍历 所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。 二、二叉树遍历分类 遍历：前序遍历(Preorder)：根节点----->左节点---->右节点 中序遍历(Inordef)： 左节点----->根节点---->右节
C++二叉树，实现增删改查，多种遍历方式
最新发布
12-30
以及前序遍历、中序遍历、后序遍历、层序遍历等。运用了C++的模板template ，以泛型编程的原则写的，泛型编程指编写完全一般化并可重复使用的算法，其效率与针对某特定的数据类型而设计的算法相同。所谓泛型，是指...
二叉树遍历
07-10
先序、中序、后序、层次遍历。
实现泛型树的多种遍历C#源代码.zip
11-20
文件包含定义一个自定义泛型树并进行前序、中序、后序、层序遍历的C#源代码
二叉树遍历源码
03-06
二叉树遍历源码
二叉树的遍历程序(C语言版)
12-04
此资源为二叉树遍历算法演示的C语言代码，为本科某小白亲自写完并调试成功的代码
数据结构 二叉树遍历
05-14
数据结构第七章二叉树遍历的源代码，有用有用~~按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树...
二叉树的创建及其遍历
04-17
 按先序遍历的扩展序列建立二叉树的二叉链表存储结构，实现二叉树先序、中序、后序遍历的递归算法，实现二叉树中序遍历的非递归算法，实现二叉树层次遍历的非递归算法（要求使用顺序队列，调用顺序队列基本操作实现），求二叉树的深度(后序遍历)。
二叉树的实现各种遍历算法
09-29
二叉树的实现各种遍历算法，插入删除成员函数非常全。二叉树的实现各种遍历算法，插入删除成员函数非常全
二叉树的四种遍历方式
weixin_42127177的博客
02-16 9304
中序遍历 二叉树的中序遍历就是首先遍历左子树，然后访问当前节点，最后遍历右子树。对于下面的二叉树，中序遍历结果如下： 直观来看，二叉树的中序遍历就是将节点投影到一条水平的坐标上。如图： 二叉树结构 struct treenode { int val; treenode *left; treenode *right; treenode() : val(0), left(nullptr), right(nullptr) {} treenode(in
【数据结构】 二叉树及其三种遍历
热门推荐
Hello World!
02-21 21万+
二叉树（Binary Tree）一种重要的树形结构，其每个节点最多只能有两棵子树，通常称为左子树和右子树，且子树有左右之分，其次序不能颠倒。二叉树是n个有限元素的集合，该集合或者为空（称为空二叉树），或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。
二叉树概念及其遍历
我的祖传代码
05-17 658
结点是数据结构中的基础，是构成复杂数据结构的基本组成单位。 1.树 树（Tree）是n（n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中： 1）有且仅有一个特定的称为根（Root）的结点； 2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、......、Tn，其中每一个集合本身又是一棵树，并且称为根的子树。 此外，树的定义还需要强调以下两点： 1）n>0时根结点是唯一的，不可能存在多个根结点，数据结构中的树只能有一个根结点。 2）m>0
深度优先搜索遍历和二叉树遍历
09-01
二叉树的遍历方式有多种，包括前序遍历、中序遍历和后序遍历。前序遍历的顺序是：根节点 -> 左子树 -> 右子树；中序遍历的顺序是：左子树 -> 根节点 -> 右子树；后序遍历的顺序是：左子树 -> 右子树 -> 根节点。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值