二叉树的遍历方式与线索化实现

最新推荐文章于 2021-01-17 14:32:36 发布
最新推荐文章于 2021-01-17 14:32:36 发布
阅读量581 收藏 2
点赞数
分类专栏： 数据结构实战开发【笔记】
课程笔记内容整理于狄泰软件
本文链接：https://blog.csdn.net/qq_39654127/article/details/80512907
版权

目录

1、二叉树结构的层次遍历 

2、二叉树的典型遍历方式 （先序、中序、后序）

3、二叉树的线索化实现

1、二叉树结构的层次遍历 

二叉树的遍历 

       二叉树的遍历(Traversing Binay Tree)是指从根结点出发，按照某种次序

       依次访问二叉树中的所有结点，使得每个结点被访问一次，且仅被访问一次。

 

                通用树结构的层次遍历算法可以用在二叉树结构

设计思路（游标） 

                提供一组遍历相关的函数，按层次访问二叉树中的数据元素。 

        

层次遍历算法 

      －原料： class LinkQueue<T>; 

      －游标： LinkQueue<T>: :front(); 

      －思想

                ● begin() → 将根结点压入队列中 

                ● current() → 访问队头元素指向的数据元素

                ● next() → 队头元素弹出，将队头元素的孩子压入队列中（核心） 

                ● end() → 判断队列是否为空 

层次遍历算法示例 

            

 

2、编程实验 

由于通用树结构（GTree）和 二叉树(BTree)都需要实现一组遍历相关函数所以在抽象父类Tree中设置一组纯虚函数

Tree.h新增：

virtual bool begin() = 0;  
virtual bool end() = 0;  
virtual bool next() = 0;  
virtual T current() = 0;  

BTree.h新增：

bool begin()  
{  
    bool ret = (root() != NULL);  
  
    if(ret)  
    {  
        m_queue.clear();  
        m_queue.add(root());  
    }  
  
    return ret;  
}  
  
bool end()  
{  
    return (m_queue.length() == 0);  
}  
  
bool next()  
{  
    bool ret = (m_queue.length() > 0);  
  
    if( ret )  
    {  
        BTreeNode<T>* node = m_queue.front();   // node指向队头  
  
        m_queue.remove();   // 游标移动指向下一个结点  
  
        if(node->left != NULL)  
        {  
            m_queue.add(node->left);  
        }  
  
        if(node->right != NULL)  
        {  
            m_queue.add(node->right);  
        }  
  
    }  
  
    return ret;  
}  
  
T current()  
{  
    if( !end() )  
    {  
        return m_queue.front()->value;  
    }  
    else  
    {  
        THROW_EXCEPTION(InvalidOperationException, "No value in current position ...");  
    }  
} 

 为了安全性所以我们在删除结点后执行清空队列操作

void clear()  
{  
    free(root());  
  
    m_queue.clear();  
  
    this->m_root = NULL;  
} 
SharedPointer< Tree<T> > remove(const T& value)  
 {  
     BTree<T>* ret = NULL;  
  
     BTreeNode<T>* node = find(value);  
  
     if(node == NULL)  
     {  
         THROW_EXCEPTION(InvalidParameterException,"Can not find the tree node via value ...");  
     }  
     else  
     {  
         remove(node,ret);  
         m_queue.clear();  
     }  
  
     return ret;  
 }  
  
 SharedPointer< Tree<T> > remove(TreeNode<T>* node)  
 {  
     BTree<T>* ret = NULL;  
  
     node = find(node);  
  
     if(node == NULL)  
     {  
         THROW_EXCEPTION(InvalidParameterException,"Parameter node is invalid ...");  
     }  
     else  
     {  
         remove(dynamic_cast<BTreeNode<T>*>(node), ret);  
         m_queue.clear();  
     }  
  
     return ret;  
 } 

 main.cpp

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace DTLib;


int main()
{
    BTree<int> bt;
    BTreeNode<int>* n = NULL;

    bt.insert(1,NULL);

    n = bt.find(1);
    bt.insert(2, n);
    bt.insert(3, n);


    n = bt.find(2);
    bt.insert(4, n);
    bt.insert(5, n);

    n = bt.find(4);
    bt.insert(8, n);
    bt.insert(9, n);

    n = bt.find(5);
    bt.insert(10, n);

    n = bt.find(3);
    bt.insert(6, n);
    bt.insert(7, n);

    cout << bt.count() << endl;
    cout << bt.height() << endl;
    cout << bt.degree() << endl;

    for(bt.begin(); !bt.end(); bt.next())
    {
        cout << bt.current() << " ";
    }

    return 0;
}

  

2、二叉树的典型遍历方式 （先序、中序、后序）

典型的二叉树遍历方式 

    －先序遍历 ( Pre-Order Traversal ) 

    －中序遍历 ( In-Order Traversal )

    －后序遍历 ( Post-Order Traversal ) 

先序遍历( Pre-Order Traversal ) 

    －二叉树为空： 无操作，直接返回 

    －二叉树不为空： 

             ① 访问根结点中的数据元素 

             ② 先序遍历左子树 

             ③ 先序遍历右子树 

                     

中序遍历( In-Order Traversal ) 

    －二叉树为空： 无操作，直接返回 

    －二叉树不为空：

             ① 中序遍历左子树 

             ② 访问根结点中的数据元素 

             ③ 中序遍历右子树

                       

后序遍历( Post-Order Traversal ) 

    －二叉树为空： 无操作，直接返回 

    －二叉树不为空： 

             ① 后序遍历左子树 

             ② 后序遍历右子树 

             ③ 访问根结点中的数据元素

                       

是否可以将二叉树的典型遍历算法集成到BTree中？

如果可以，代码需要做怎样的改动？

设计要点 

       －不能与层次遍历函数冲突，必须设计新的函数接口 

       －算法执行完成后，能够方便的获得遍历结果 

       －遍历结果能够反映结点访问的先后次序 

函数接口设计 

       －SharedPointer< Array<T> > traversal(BTTraversal order) 

                 ● 根据参数 order 选择执行遍历算法（先序，中序，后序） 

                 ● 返回值为堆中的数组对象（生命期由智能指针管理） 

                 ● 数组元素的次序反映遍历的先后次序 

enum BTTraversal
{
    PreOrder,    // 先序遍历
    InOrder,     // 中序遍历
    PostOrder,   // 后序遍历
    LeverOrder   // 层次遍历
};

典型遍历使用示例

    SharedPointer< Array<int> > sp = NULL;

    sp = bt.traversal(PreOrder); // 先序遍历

    for(int i=0; i<(*sp).length(); i++)
 
    {
        cout << (*sp)[i] << " "; 
    }

    层次遍历算法示例

             

            

编程实验 

二叉树的典遍历方式 

#ifndef BTREE_H
#define BTREE_H

#include "Tree.h"
#include "BTreeNode.h"
#include "Exception.h"
#include "LinkQueue.h"
#include "DynamicArray.h"

namespace DTLib
{

enum BTTraversal
{
    PreOrder,
    InOrder,
    PostOrder,
    LeverOrder
};

template < typename T >
class BTree : public Tree<T>
{
protected:
    // ...

    void preOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue) 
    {
        if(node != NULL)
        {
            queue.add(node);
            preOrderTraversal(node->left, queue);
            preOrderTraversal(node->right, queue);
        }
    }

    void inOrderTraversal(BTreeNode<T>* node,LinkQueue<BTreeNode<T>*>& queue)
    {
        if(node != NULL)
        {        
            inOrderTraversal(node->left, queue);
            queue.add(node);
            inOrderTraversal(node->right, queue);
        }
    }

    void postOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
    {
        if(node != NULL)
        {            
            postOrderTraversal(node->left, queue);
            postOrderTraversal(node->right, queue);
            queue.add(node);
        }
    }

    void leverOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
    {
        if(node != NULL)
        {
            LinkQueue<BTreeNode<T>*> tmp;

            tmp.add(node);

            while(tmp.length() > 0)
            {
                BTreeNode<T>* n = tmp.front();

                if(n->left != NULL)
                {
                    tmp.add(n->left);
                }

                if(n->right != NULL)
                {
                    tmp.add(n->right);
                }

                tmp.remove();

                queue.add(n);
            }
        }
    }

    void traversal(BTTraversal order, LinkQueue<BTreeNode<T>*>& queue)
    {
        switch( order )
        {
            case PreOrder:
                preOrderTraversal(root(), queue);
                break;
            case InOrder:
                inOrderTraversal(root(), queue);
                break;
            case PostOrder:
                postOrderTraversal(root(), queue);
                break;
            case LeverOrder:
                leverOrderTraversal(root(), queue);
                break;
            default:
                THROW_EXCEPTION(InvalidParameterException, "Parameter order is invalid ...");
        }
    }

public:
    // ...

    SharedPointer< Array<T> > traversal(BTTraversal order)
    {
        DynamicArray<T>* ret = NULL;
        LinkQueue<BTreeNode<T>*> queue;

        traversal(order, queue); // 遍历，遍历结果保存在queue

        ret = new DynamicArray<T>(queue.length());

        if(ret != NULL)
        {
            /* 将队列里结点数据元素值依次放到返回数组里 */
            for(int i=0; i<ret->length(); i++, queue.remove())
            {
                ret->set(i, queue.front()->value);
            }
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create return array ...");
        }

        return ret;
    }

   // ...
};
}
#endif // BTREE_H

main.cpp

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace DTLib;


int main()
{
    BTree<int> bt;
    BTreeNode<int>* n = NULL;

    bt.insert(1,NULL);

    n = bt.find(1);
    bt.insert(2, n);
    bt.insert(3, n);


    n = bt.find(2);
    bt.insert(4, n);
    bt.insert(5, n);

    n = bt.find(4);
    bt.insert(8, n);
    bt.insert(9, n);

    n = bt.find(5);
    bt.insert(10, n);

    n = bt.find(3);
    bt.insert(6, n);
    bt.insert(7, n);

    SharedPointer< Array<int> > sp = NULL;

    sp = bt.traversal(PreOrder);

    for(int i=0; i<(*sp).length(); i++)

    {
        cout << (*sp)[i] << " ";
    }

    cout << endl;

    return 0;
}

   

小结 

            二叉树的典型遍历都是以递归方式执行的 

            BTree以不同的函数接口支持典型遍历 

            层次遍历与典型遍历互不冲突 

            遍历结果能够反映树结点访问的先后次序 

 

3、二叉树的线索化实现

什么是线索化二叉树？ 

   －将二叉树转换为双向链表的过程（非线性 → 线性）

   －能够反映某种二叉树的遍历次序（结点的先后访问次序）

           ● 利用结点的 right指针指向遍历中的后继结点 

           ● 利用结点的 left指针指向遍历中的前驱结点 

如何对二叉树进行线索化？ 

        思维过程： 

        

二叉树的线索化 

            

函数接口设计 

   －BTreeNode<T>* thread(BTTraversal order) 

            ● 根据参数 order 选择线索化的次序（先序，中序，后序，层次） 

            ● 返回值线索化之后指向链表首结点的指针 

            ● 线索化执行结束之后对应的二叉树变为空树 

线索化流程

                        

 

队列中结点的连接算法[ connect(queue) ] 

 

编程实验 

二叉树的线索化     thread (order)

template < typename T >
class BTree : public Tree<T>
{
protected:
    // ...

    BTreeNode<T>* connect(LinkQueue<BTreeNode<T>*>& queue)
    {
        BTreeNode<T>* ret = NULL;

        if(queue.length() > 0)
        {
            ret = queue.front();

            BTreeNode<T>* slider = queue.front();

            queue.remove();

            slider->left = NULL;

            while(queue.length() > 0)
            {
                slider->right = queue.front();
                queue.front()->left = slider;
                slider = queue.front();
                queue.remove();
            }

            slider->right = NULL;   // 最后一个结点next指针为空
        }

        return ret;
    }

public:
    // ...

    BTreeNode<T>* thread(BTTraversal order)
    {
        BTreeNode<T>* ret = NULL;
        LinkQueue< BTreeNode<T>* > queue;

        traversal(order, queue); // 遍历二叉树，将结果保存在queue队列

        ret = connect(queue);    //  将队列里已遍历好的有次序的结点连成双向链表

        this->m_root = NULL;     // 置为空树
 
        m_queue.clear();

        return ret;

    }
};

main.cpp

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace DTLib;

int main()
{
    BTree<int> bt;
    BTreeNode<int>* n = NULL;

    bt.insert(1, NULL);

    n = bt.find(1);
    bt.insert(2, n);
    bt.insert(3, n);


    n = bt.find(2);
    bt.insert(4, n);
    bt.insert(5, n);
 
    n = bt.find(4);
    bt.insert(8, n);
    bt.insert(9, n);

    n = bt.find(5);
    bt.insert(10, n);

    n = bt.find(3);
    bt.insert(6, n);
    bt.insert(7, n);


    cout << "Old BTree: " << endl;

    for(bt.begin(); !bt.end(); bt.next())
    {
        cout << bt.current() << " ";
    }

    cout << endl << endl;


    BTreeNode<int>* head = bt.thread(LeverOrder);

    while( head->right )
    {
        head = head->right;
    }

    while( head )
    {
        cout << head->value << " ";

        head = head->left;
    }


    return 0;
}

    

 

小结 

            线索化是将二叉树转换为双向链表的过程 

            线索化之后结点间的先后次序符合某种遍历次序 

            线索化操作将破坏原二叉树结点间的父子关系 

            线索化之后二叉树将不再管理结点的生命期 

 

 

 

 

洋葱汪
关注
专栏目录
二叉树的线索化及遍历
皮卡qiu~的博客
03-26 365
目录 一、需求 二、前序线索化 2.1 前序线索化图解 2.2 前序线索化代码实现 2.3 前序线索化的遍历 三、中序线索化 3.1 中序线索化图解 3.2 中序线索化代码实现 3.3 中序线索化的遍历 四、后序线索化 4.1 后序线索化图解 4.2 后序线索化代码实现 五、完整代码 一、需求 /* * 需求:实现线索化二叉树 * 分析: *...
线索二叉树及其遍历
cmd12138的博客
01-15 3036
1.为什么要对二叉树线索化？ 先看下图二叉树： 不难看出有许多空指针域的存在，那对于有n个结点的二叉树它的空指针域有多少呢？一个n结点二叉树总指针域为2n（每个都有左右孩子两个指针域），而n个结点二叉树含有n-1条分支线，反过来想就是没有多少条分支线就有多少个空指针域，所以空指针域为2n-（n-1）=n+1个，空指针太多浪费内存资源。如果我们能把这些空地址放上结点的前驱和后继，那将会节省很多时间。 2.什么是线索化？ 将二叉树变为线索二叉树的过程称为线索化。 按某种次序将二叉树线索化的实质是：按该次序遍历
线索化二叉树的实现和遍历
yljdxh的博客
02-24 232
线索话代码实现实在太难理解了你只要明白怎么实现的， 遍历相对来说会简单很多。 我在写实现的时候分明是往上抄的就是遍历不出来，之后和源代码以一比对还是没发现错误（因为里面node pre太多 看花眼了）。最后还是一个个代码走了一遍 。 学完算法我就觉得我对递归彻底理解了，但是每次学到新的东西就会对递归产生一种敬仰。 递归本身是很简单你要看是怎么运用 我学算法开始发现递归不仅仅是自己调用自己 刚开...
二叉树的遍历与线索化
HLXchamp的博客
04-16 335
二叉树的遍历 二叉树遍历： 按一定规律对二叉树中的每个结点进行访问且仅访问一次。 二叉树的基本结构由根结点、左子树和右子树组成。 用L、D、R分别表示遍历左子树、访问根结点、遍历右子树， 那么对二叉树的遍历顺序就可以有： 访问根，遍历左子树，遍历右子树 (记做DLR)。 访问根，遍历右子树，遍历左子树 (记做DRL)。 遍历左子树，访问根，遍历右子树 (记做LDR)。 遍历左子树，遍历...
实验三 二叉树的遍历和线索的实现
qq_44939000的博客
01-01 547
采用二叉链表存储结构，实现其各种遍历的方法 （1）定义二叉链表的存储结构； （2）按先序遍历创建一棵二叉链表树； （3）实现二叉链表的后序遍历； 采用中序线索链表存储结构，实现中序遍历 （1）定义线索链表的存储结构； （2）按先序遍历创建一棵二叉链表树； （3）实现二叉链表的中序线索化； （4）实现中序线索链表的中序遍历。 第一题 #include <iostream> #incl...
数据结构系列--二叉树遍历和线索化
qq_36400704的博客
09-03 910
由遍历序列确定二叉树 从二叉树的遍历可知，任何一棵二叉树的前序遍历和中序遍历都是唯一的，那么给定结点的前序序列和中序序列能否确定一棵二叉树？ 二叉树的前序序列中，第一个结点必定是根D;根节点D可将中序序列分成两部分:D之前是左子树的中序序列，D之后是右子树的中序序列，再根据左子树的中序序列，又可将前序序列除根以外分成左子树的前序序列和右子树的前序序列，以此类推，便可递归得到整棵二叉树。 结论：给定一颗二叉树的前序序列和中序序列，可以唯一的确定一棵二叉树。 二叉树的线索化 ...
数据结构树和二叉树遍历二叉树和线索二叉树PPT学习教案.pptx
10-05
本资源主要讲述了数据结构树和二叉树遍历的相关知识点，包括二叉树的基本概念、二叉树遍历的六种方案、先序、中序、后序遍历算法的实现、线索二叉树的概念等内容。 二叉树的基本概念 二叉树是一种特殊的树形结构，...
PHP实现的线索二叉树及二叉树遍历方法详解
10-22
同时，线索二叉树提供了一种有效的数据结构方式来处理二叉树遍历中可能出现的空指针问题，并且能够更加高效地实现中序遍历。在实际应用中，线索二叉树非常适合需要频繁遍历的场景，比如在文本编辑器中实现光标移动、...
数据结构二叉树遍历及线索化后各种操作(绝对无错).pdf
最新发布
08-15
"数据结构二叉树遍历及...本文档提供了二叉树遍历和线索化的实现方法，包括前序遍历、中序遍历、后序遍历、树高和叶子节点的统计等操作。这些算法和实现方法可以帮助读者更好地理解和应用二叉树的遍历和线索化技术。
二叉树遍历与线索化实现——中序线索二叉树
"这篇资料是关于数据结构中的树与二叉树，特别是中序线索化二叉树的成员函数实现。讨论了树和森林的基本概念，包括自由树、有根树以及相关的术语如根、子树、度、叶结点等。此外，还涉及到了二叉树的遍历、计数以及...
二叉线索树的线索化以及遍历
m0_43456002的博客
02-15 389
//二叉树的创建，递归遍历，非递归遍历，拷贝，深度 #include<iostream> #include<stack> using namespace std; ////二叉树的结构 //typedef struct BiTNode //{ // char data;//数据域 // int LTag = 0;//左标签 // int RTag = 0;//右标签 // ...
二叉树的线索化和遍历
nullcanon的博客
01-13 290
包括二叉树的前序,中序,后序线索化和线索化遍历 #pragma once #include using namespace std; enum pInfo{ LINK, THREAD }; templateclass T> struct BinTreeThreadNode { BinTreeThreadNode(const T data) :_pLeft(NULL)
[学习笔记]二叉树的线索化和遍历
疯子的自留地
04-07 1580
文章首发:http://pjf.name/post-127.html       本文基于"姓名标识-非商业性-相同方式分享 4.0国际"协议创作或转载,转载原创文章请注明来源于疯子的自留地,否则请勿转载或再转载,谢谢合作:)       在啃二叉树的线索话的时候遇到了一点疑惑,google和度娘和很多文章也没有对此的详解,遂做下笔记,方便自己也说不定也对此问题有同样疑惑的童鞋
线索二叉树建立及遍历（C实现）
ZQYnn's blog
05-13 1919
线索二叉树建立及遍历 线索二叉树概念 二叉树通过二叉链表作为存储结构时，只能得到当前结点的左右孩子信息，而无法得到结点在任一序列的前驱和后继，如果想要保存遍历中的信息,需要在每个结点上添加两个指针域，分别指向当前结点的前驱和后继，指向线性序列中的前驱和后继的指针，称为线索， 并且增加两个标志域 如下图 设置规定如下： ltag=0 表示lchild 指向左孩子 latg=1 表示lchil...
线索二叉树的线索化的实现以及遍历的实现
qq_38181970的博客
07-25 332
      线索二叉树：(threaded binary tree)：n个结点的二叉链表中含有n+1(2n-(n-1)=n+1)个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前驱和后继结点的指针 【注】已知二叉树的节点个数n，那么边的个数n-1。 现在给出树节点的定义： class TreeNode { public:     TreeNode(int x) { v...
二叉树的遍历以及线索化
HHHHUIIII的博客
01-17 186
利用栈实现二叉树的前序遍历 访问二叉树一个结点后，打印其数据后，先判断其是否有右子女，有的话则入栈，没有的话则判断其是否有左子女，有的话则左进到左子女(p=p->Leftchild)，没有则弹栈，并访问。 BinTreeNode<T> *p = root;//初始化 stack.Push(NULL); while (p != NULL) { visit(p); if (p->rightchild != NULL)stack.Push(p->rightchild); if
二叉树线索化和遍历的算法
Fhang
11-29 1521
前言：关于二叉线索树有什么作用，为什么要建立这里就不介绍。因为时间问题，只是总结一下线索化和遍历的算法。这个算法和前面总结过的非递归法遍历二叉树都算是数据结构里面难度系数比栈，队列，线性表那些大的算法。限定时间内要写出来还是有些难度，最好是能有所总结，才能做到得心应手。先序：先序线索化void PreThreading(BiTreeNode *p, BiTreeNode *pre==NULL) {
二叉树的遍历和线索化（递归和非递归版本）
梦的灰色边沿...
03-18 603
1 二叉树的遍历   二叉树的遍历都是根据父结点的顺序位置来命名的。 1.1 先序遍历   先遍历父结点，再遍历左子结点最后遍历右子结点。上述树的遍历顺序为：5 2 1 3 7 6 8   递归版本： @staticmethod def pre_traversal(root, visit_func): ''' @brief 先序遍历 @p...
二叉树的遍历（递归/非递归）、线索化、镜像（递归/非递归）、查找节点算法
flow
11-13 269
import java.util.LinkedList; import java.util.Queue; import java.util.Stack; public class BinaryTree<T> { BinaryTreeNode<T> root; public BinaryTree(T data) { root = new BinaryTreeNode<>(data); } /* public Binar.
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值