【数据结构】线索化二叉树的基本操作

最新推荐文章于 2022-09-08 23:21:43 发布
最新推荐文章于 2022-09-08 23:21:43 发布
阅读量1.1k 收藏 7
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 二叉树 二叉树的线索化 搜索 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sofia_m/article/details/79115223
版权

二叉树的线索化源码：

BinSearchTree.h：
#pragma once
#ifndef __BINSEARCH_H__
#define __BINSEARCH_H__

#include<iostream>
#include<stdio.h>
#include<stack>
#include<queue>

using namespace std;

//搜索二叉树节点

enum BinThread{LINK,THREAD};

template<class T>
struct BinTreeNodeThd
{
    BinTreeNodeThd(const T& data)
    :_data(data)
    , _pLeft(NULL)
    , _pRight(NULL)
    , _pParent(NULL)
    , _pLeftThread(LINK)
    , _pRightThread(LINK)
    {}
    T _data;
    BinTreeNodeThd<T>* _pLeft;
    BinTreeNodeThd<T>* _pRight;
    BinThread _pLeftThread;
    BinThread _pRightThread;//标记是否需要线索化
    BinTreeNodeThd<T>* _pParent;//父母节点
};

template<class T>
class BinSearchTree
{
    typedef BinTreeNodeThd<T> Node;
    typedef Node* pNode;
public:
    //构造函数
    //空搜索二叉树的构造
    BinSearchTree()
        :_pRoot(NULL)
    {}

    //带参的搜索二叉树构造函数
    BinSearchTree(const T* arr, size_t size, const T& invalid){
        size_t index = 0;
        pNode parent = NULL;
        _CreateNewTree(_pRoot,arr, size, index, invalid,parent);
    }

    //前序递归遍历
    void PreOrder(){
        cout << "前序递归遍历" << endl;
        _PreOrder(_pRoot);
        cout << endl;
    }

    //前序非递归遍历线索化后的二叉树
    void PreOrderNor(){
        cout << "前序非递归遍历" << endl;
        _PreOrderNor(_pRoot);
        cout << endl;
    }
    //中序递归遍历
    void InOrder(){
        cout << "中序递归遍历" << endl;
        _InOrder(_pRoot);
        cout << endl;
    }

    //中序非递归遍历线索化后的二叉树
    void InOrderNor(){
        cout << "中序非递归遍历" << endl;
        _InOrderNor(_pRoot);
        cout << endl;
    }

    //后序递归遍历
    void PostOrder(){
        cout << "后序递归遍历" << endl;
        _PostOrder(_pRoot);
        cout << endl;
    }

    //后序非递归遍历线索化后的二叉树
    void PostOrderNor(){
        cout << "后序非递归遍历" << endl;
        _PostOrderNor(_pRoot);
        cout << endl;
    }

    //前序线索化二叉树
    void PreThread(){
        cout << "前序线索化二叉树" << endl;
        pNode prev = NULL;
        _PreThread(_pRoot, prev);
    }

    //中序线索化二叉树
    void InThread(){
        cout << "中序线索化二叉树" << endl;
        pNode prev = NULL;
        _InThread(_pRoot, prev);
    }

    //后序线索化二叉树
    void PostThread(){
        cout << "后序线索化二叉树" << endl;
        pNode prev = NULL;
        _PostThread(_pRoot, prev);
    }

protected:
    //创建搜索二叉树
    void _CreateNewTree(pNode& pRoot,const T* arr, size_t size, size_t& index, const T& invalid,pNode& parent){
        if (index < size && arr[index] != invalid){
            pRoot = new Node(arr[index]);
            pRoot->_pParent = parent;
            _CreateNewTree(pRoot->_pLeft,arr, size, ++index, invalid,pRoot);
            _CreateNewTree(pRoot->_pRight,arr, size, ++index, invalid,pRoot);
        }
    }

    //前序递归遍历
    void _PreOrder(pNode pRoot){
        if (pRoot){
            cout << pRoot->_data << "  ";
            _PreOrder(pRoot->_pLeft);
            _PreOrder(pRoot->_pRight);
        }
    }

    //前序非递归遍历线索化后的二叉树
    void _PreOrderNor(pNode pRoot){
        if (NULL == pRoot)
            return;
        pNode pCur = pRoot;
        while (pCur){
            //遍历当前节点
            while (LINK == pCur->_pLeftThread){
                cout << pCur->_data << "  ";
                pCur = pCur->_pLeft;
            }
            cout << pCur->_data << "  ";
            //不管是当前节点的右子树，或是线索化后指向的下个节点，都可以用此步来进入下一层子循环
            pCur = pCur->_pRight;
        }


    }

    //中序递归遍历
    void _InOrder(pNode pRoot){
        if (pRoot){
            _InOrder(pRoot->_pLeft);
            cout << pRoot->_data << "  ";
            _InOrder(pRoot->_pRight);
        }
    }

    //中序非递归遍历线索化后的二叉树
    void _InOrderNor(pNode pRoot){
        if (NULL == pRoot)
            return;
        pNode pCur = pRoot;
        while (pCur){
            //先找到左子树最左边的节点
            while (LINK == pCur->_pLeftThread)
                pCur = pCur->_pLeft;
            //遍历该节点的根节点（该节点一定没有左子树，因为上面的while循环）
            cout << pCur->_data << "  ";
            //遍历该节点的下一节点（线索化后的右指针域）
            while (THREAD == pCur->_pRightThread){
                pCur = pCur->_pRight;
                cout << pCur->_data << "  ";
            }
            //遍历该节点的右子树，进入下一层子循环
            pCur = pCur->_pRight;
        }
    }

    //后序递归遍历
    void _PostOrder(pNode pRoot){
        if (pRoot){
            _PostOrder(pRoot->_pLeft);
            _PostOrder(pRoot->_pRight);
            cout << pRoot->_data << "  ";
        }
    }

    //后序非递归遍历线索化后的二叉树
    void _PostOrderNor(pNode pRoot){
        if (NULL == pRoot)
            return;
        pNode pCur = pRoot;
        pNode prev = NULL;
        while (pCur){

            //先找到左子树的最左节点
            if (pCur && pCur->_pLeft != prev){
                //if 防止左边重复走两次
                while (LINK == pCur->_pLeftThread)
                    pCur = pCur->_pLeft;
            }
            //左为空，右也为空，访问后继节点
            while (THREAD == pCur->_pRightThread){
                cout << pCur->_data << "  ";
                prev = pCur;//标记刚刚访问的节点
                pCur = pCur->_pRight;
            }
            //处理根节点
            if (pRoot == pCur && (NULL == pRoot->_pRight || prev == pRoot->_pRight)){
                cout << pCur->_data << "  ";
                return;
            }

            //防止右单支的情况出现
            //需要加入父母节点，形成父母孩子节点，可以访问前驱节点
            while (pCur && prev == pCur->_pRight/* && pRoot != pCur*/){
                cout << pCur->_data << "  ";
                prev = pCur;
                pCur = pCur->_pParent;
            }
            //遍历右子树，进行下一次子循环
            if (pCur && NULL != pCur->_pRight && prev != pCur->_pRight){
                if (pCur && LINK == pCur->_pRightThread)
                    pCur = pCur->_pRight;
            }
        }
    }

    //前序线索化二叉树
    void _PreThread(pNode& pRoot, pNode& prev){
        if (pRoot){
            //线索化当前节点
            //线索化当前节点的左指针域
            if (NULL == pRoot->_pLeft){
                pRoot->_pLeft = prev;
                pRoot->_pLeftThread = THREAD;
            }
            //线索化当前节点的右指针域
            if (prev && NULL == prev->_pRight){
                prev->_pRight = pRoot;
                prev->_pRightThread = THREAD;
            }
            //标记刚刚进行线索化的节点
            prev = pRoot;
            //线索化左子树
            if (LINK == pRoot->_pLeftThread)
                _PreThread(pRoot->_pLeft, prev);
            //线索化右子树
            if (LINK == pRoot->_pRightThread)
                _PreThread(pRoot->_pRight, prev);
        }
    }

    //中序线索化二叉树
    void _InThread(pNode& pRoot, pNode& prev){
        if (pRoot){
            //线索化左子树
            _InThread(pRoot->_pLeft, prev);
            //线索化当前节点
            //线索化当前节点的左指针域
            if (NULL == pRoot->_pLeft){
                pRoot->_pLeft = prev;
                pRoot->_pLeftThread = THREAD;
            }
            //线索化当前节点的右指针域
            if (prev && NULL == prev->_pRight){
                prev->_pRight = pRoot;
                prev->_pRightThread = THREAD;
            }
            //标记刚刚进行线索化的节点
            prev = pRoot;

            //线索化右子树
            if (LINK == pRoot->_pRightThread)
                _InThread(pRoot->_pRight, prev);
        }
    }

    //后序线索化二叉树
    void _PostThread(pNode& pRoot, pNode& prev){
        if (pRoot){
            //线索化左子树
            _PostThread(pRoot->_pLeft, prev);
            //线索化右子树
            _PostThread(pRoot->_pRight, prev);
            //线索化当前节点
            //线索化当前节点的左指针域
            if (NULL == pRoot->_pLeft){
                pRoot->_pLeft = prev;
                pRoot->_pLeftThread = THREAD;
            }
            //线索化当前节点的右指针域
            if (prev && NULL == prev->_pRight){
                prev->_pRight = pRoot;
                prev->_pRightThread = THREAD;
            }
            //标记刚刚进行线索化的节点
            prev = pRoot;
        }
    }

private:
    pNode _pRoot;
};

#endif //__BINSEARCH_H__
test.c：
#include"bintree.h"
#include"BinSearchTree.h"
#include<Windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
//测试搜索二叉树
void test1(){
    //普通场景
    char arr[] = { 'A', 'B', 'D', '#', '#', '#', 'C', 'E', '#', '#', 'F' };
    //char arr2[] = { '1', '2', '#', '#', '3' };
    BinSearchTree<char> bt(arr, sizeof(arr) / sizeof(arr[0]), '#');
    //左子树有可能走两次
    char arr1[] = { 'A', 'B', 'D', 'E', '#', '#', 'F', '#', '#', '#', 'C' };
    BinSearchTree<char> bt1(arr1, sizeof(arr1) / sizeof(arr1[0]), '#');
    //左单支
    char arr2[] = { 'A', 'B', 'C', 'D' };
    BinSearchTree<char> bt2(arr2, sizeof(arr2) / sizeof(arr2[0]), '#');
    //右单支
    char arr3[] = { 'A', '#', 'B', '#', 'C', '#', 'D' };
    BinSearchTree<char> bt3(arr3, sizeof(arr3) / sizeof(arr3[0]), '#');

    //测试后序非递归遍历线索化后的二叉树
    cout << "场景：普通场景" << endl;
    bt.PostOrder();
    bt.PostThread();
    bt.PostOrderNor();
    cout << endl;
    cout << "场景：左子树有可能走两次" << endl;
    bt1.PostOrder();
    bt1.PostThread();
    bt1.PostOrderNor();
    cout << endl;
    cout << "场景：左单支" << endl;
    bt2.PostOrder();
    bt2.PostThread();
    bt2.PostOrderNor();
    cout << endl;
    cout << "场景：右单支" << endl;
    bt3.PostOrder();
    bt3.PostThread();
    bt3.PostOrderNor();
    cout << endl;   

    //测试前序递归遍历、前序线索化二叉树、前序非递归遍历
    //bt.PreOrder();
    //bt.PreThread();
    //bt.PreOrderNor();

    //测试中序递归遍历、中序线索化二叉树、中序非递归遍历
    //bt.InOrder();
    //bt.InThread();
    //bt.InOrderNor();
}

int main(){
    test1();
    system("pause");
    return 0;
}

测试结果：

前序线索化二叉树：

这里写图片描述

这里写图片描述

前序测试结果：

这里写图片描述

中序线索化二叉树：

这里写图片描述

这里写图片描述

中序测试结果：

这里写图片描述

后续线索化二叉树：

场景一：普通场景

这里写图片描述

这里写图片描述

场景二：特殊场景（左子树有可能走两次）

这里写图片描述

这里写图片描述

场景三：左单支

这里写图片描述

这里写图片描述

场景四：右单支

这里写图片描述

这里写图片描述

后续测试结果：

这里写图片描述

sofia_m
关注
专栏目录
二叉树之线索二叉树基本操作（C++实现）
diviner_s的博客
05-10 545
#include<iostream> using namespace std; typedef char TElemType; //TElemType 相当于 char typedef struct BiThrNode { TElemType data; struct BiThrNode *lchild,*rchild; //左右孩子指针 int LTag,RTag; //左右标志 } BiThrNode,*BiThrTree;
数据结构-线索二叉树基本操作源代码（C/C++实现）
JunsIr的技术栈
11-21 1352
数据结构-线索二叉树基本操作源代码（C/C++实现） 关键点理解 中序遍历有隔一个结点为一个叶子结点的特点–>叶子结点孩子指针为NULL—>利用起来，叶子结点左边域空间方指向前驱结点，前驱结点若无右孩子结点，则前驱结点的右孩子指针域指向当前结点 当真不知道是哪个个鬼才发明的结构…光理解就要好半天 源代码 #include "string.h" #include "stdio.h" ...
数据结构二叉树线索化
wangzhencu的博客
05-28 451
线索化二叉树指的是将二叉树中的结点进行逻辑意义上的“重排列”，使其可以线性的方式访问每一个结点。二叉树线索化之后每个结点都有一个线性下标，通过这个下标可以快速访问结点，而不需要遍历二叉树。                                               代码：            [cpp] view plain cop
数据结构——线索二叉树
zhaoxianyong的专栏
01-01 4071
一、线索二叉树         遍历二叉树实际上是将树中的结点按照一定的规则构成一个线性序列，不同的遍历方式得到的是不同的序列。对于需要经常遍历的二叉树，可以充分利用二叉树的空指针域，保存遍历中的信息，即左右指针分别记录结点的前驱和后继，即二叉树的线索化。         重新定义二叉树结点如下，增加两个标志域： typedef enum PointerTag{Link, Thread};
线索二叉树的基本操作
realfancy的博客
12-17 520
（1）二叉树的线索化（2）对线索二叉树进行中序遍历#include<iostream> using namespace std;typedef char TElemType; enum Status {OK = 1,ERROR = 0}; enum PointerTag{Link = 0,Thread = 1};//typedef struct BiTNode { // TElemType dat
编写创建二叉树的算法
斗锋在干嘛的博客
02-02 1728
①、编写创建二叉树的算法； ②、编写查找节点的算法； ③、编写找孩子节点的算法； ④、编写求二叉树高度的算法； ⑤、编写输出二叉树的算法； ⑥、编写先序遍历递归算法； ⑦、编写主函数。 代码如下： #include #include #include #include #define MaxSize 50 //①： void CreateBTNode(BTNode * &b,cha
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
C语言数据结构之线索二叉树及其遍历
08-29
线索二叉树是一种特殊的二叉树结构，它的设计目的是为了在非递归方式下更高效地查找二叉树中节点的前驱和后继。在普通的二叉链表中，节点仅通过...理解线索二叉树的原理和实现，对于深入学习数据结构和算法至关重要。
数据结构之线索二叉树详细解释
最新发布
01-15
线索二叉树是一种在二叉树中添加额外线索来辅助遍历的数据...理解和掌握线索二叉树的构造和操作，对于提升数据结构和算法的应用能力大有裨益。在实际编程中，根据具体需求选择合适的数据结构和方法，是解决问题的关键。
线索二叉树基本操作
gaokuiyuan的博客
09-08 1287
线索二叉树的基本操作，包括二叉树的线索化，中序，前序，后序线索二叉树找指定结点p的前驱和后继等代码，运行截图，图解等。
数据结构——线索二叉树的基本操作
一个巨大的博客
11-28 499
线索二叉树的基本操作 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct Node{ //二叉树的链式存储结点 char data; struct Node *Lchild; struct Node *Rchild; int Ltag; int Rtag; }BiTNode,*BiTree; ...
二叉树的线索化
热门推荐
编程小霸王的Blog
12-05 2万+
线索二叉树(Threaded BinaryTree) 1.线索二叉树的基本概念       遍历二叉树是以一定规则将二叉树中的结点排列成一个线性序列，得到二叉树中结点的先序序列、中序序列或后序序列。 这实质上是对一个非线性结构进行线性化操作。使每个结点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。      例如二叉树结点的中序序列a+b*c-d-e/f中，“c”
线索二叉树的基本操作 C语言
HISS的博客
02-12 250
#include <stdio.h> #include <stdlib.h> typedef char elemType; typedef struct BiTNode { elemType data; struct BiTNode *lchild, *rchild; int LTag, RTag; }BiThreadNode, *BiThreadTree; BiThreadNode * pre; //
【数据结构】二叉树的基本操作
Qregi的博客
02-27 483
二叉树的基本操作 BinTree.h #pragma once #include #include #include typedef char BinTreeType; typedef struct BinTreeNode { BinTreeType data; struct BinTreeNode* lchild; struct BinTreeNode* rch
数据结构精讲：二叉树遍历与线索化
线性表作为一种基本的数据结构，由n个相同类型的数据元素构成，支持多种操作，如初始化、获取长度、定位元素、插入和删除元素等。线性表的顺序表示利用数组实现，提供了随机访问的优势，但插入和删除操作可能需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值