c++ 二叉树的线索化（前中后序遍历）

#pragma once//.hpp函数头文件

#include<iostream>

using namespace std;

enum BinTreeNodeChildType
{
Thread,
Link
};

template <class T>
struct BinaryTreeThrNode
{
public:
T _data;  //数据域
BinaryTreeThrNode<T>* _leftChild;//做孩子
BinaryTreeThrNode<T>* _rightChild;//右孩子
BinTreeNodeChildType _leftType;//左节点类型
BinTreeNodeChildType _rightType;//右节点类型
BinaryTreeThrNode<T>* _parent;//父节点  （后续线索化 遍历 用到）

public:
BinaryTreeThrNode(const T& data)
:_data(data)
, _leftChild(NULL)
, _rightChild(NULL)
, _leftType(Link)
, _rightType(Link)
, _parent(NULL)
{}

~BinaryTreeThrNode()
{}
};

template <class T>
class BinaryTreeThread
{
public:
BinaryTreeThrNode<T>* _root;
public:
BinaryTreeThread()
:_root(NULL)
{}

BinaryTreeThread(T*a, size_t size)
{
size_t index = 0;
_root = _CreateBiTree(a, index, size);
}

void InOrderThread()
{
BinaryTreeThrNode<T>* prev = NULL;
BinaryTreeThrNode<T>* cur = _root;
_InOrderThread(cur,prev );
}

void PreOrderThread()
{
BinaryTreeThrNode<T>* prev = NULL;
_PreOrderThread(_root,prev);
}

void InOrderThe1()  //cur每次循环跳一次
{
BinaryTreeThrNode<T>* cur = _root;
BinaryTreeThrNode<T>*prev = _root;
while (cur)
{
if (cur->_leftChild&&prev->_rightChild != cur&&cur->_leftType == Link)
cur = cur->_leftChild;
else
{
cout << cur->_data << ' ';
if (cur->_rightType == Thread)
prev = cur;
cur = cur->_rightChild;
}
}
}
void InOrderThe()  //cur每次循环中有循环
{
BinaryTreeThrNode<T>* cur = _root;
while (cur)
{
while (cur&&cur->_leftType == Link)
{
cur = cur->_leftChild;
}
cout << cur->_data << ' ';
while (cur&&cur->_leftType== Thread)
{
cur = cur->_rightChild;
cout << cur->_data<<' ';
}
cur = cur->_rightChild;
}
}

//前序线索遍历
void PreOrderThe()
{
BinaryTreeThrNode<T>* cur = _root;
while (cur&&cur->_rightChild)
{
while (cur->_leftType != Thread)
{
cout << cur->_data << ' ';
cur = cur->_leftChild;
}
while (cur->_rightType == Thread)
{
cout << cur->_data << ' ';
cur = cur->_rightChild;
if (cur->_rightChild == NULL)
cout << cur->_data << ' ';

}
}

}
//后续线索遍历
void PostOrderThe1()//老师的方法
{
if (_root == NULL)
return;

BinaryTreeThrNode<T>* cur = _root->_left;
BinaryTreeThrNode<T>* prev = NULL;

while (cur != _root)
{
// 1.找最左节点
while (cur && cur->_leftTag == LINK)
cur = cur->_left;

while (cur && cur->_rightTag == THREAD)
{
cout << cur->_data << " ";
prev = cur;
cur = cur->_right;
}

// 当跳到root则遍历完成
if (cur == _root)
{
cout << _root->_data << " ";
break;
}

// 一个节点的右树已经访问完成，则跳转到根节点
if (cur && cur->_rightTag == LINK
&& cur->_right == prev)
{
cout << cur->_data << " ";
prev = cur;

cur = cur->_parent;
}

// 往右树跳转
if (cur && cur->_rightTag == LINK)
{
cur = cur->_right;
}
}

cout << endl;
}

void PosOrderThe()//后续线索遍历（借助 父节点）
{
BinaryTreeThrNode<T>* cur = _root;
BinaryTreeThrNode<T>* prev = NULL;//防止死循环的记录指针
while (cur)
{

while (prev!=cur->_leftChild&&cur!=prev&&cur->_leftType != Thread)//左支不为Thread且 prev不为cur坐支且prev！=cur 循环压左
cur = cur->_leftChild;
if (prev==cur&&cur->_rightType == Link)//右支不为Thread类型 压右
cur = cur->_rightChild;
else
{
while (cur->_rightType == Thread)  //右支为Thread类型 循环压右  输出
{

cout << cur->_data << ' ';
cur = cur->_rightChild;
prev= cur;
}
cout << cur->_data << ' ';
cur = cur->_parent;
if (cur&&cur->_rightType == Link&&cur->_leftChild==prev)
{
prev = cur;//prev始终为右支返回的父节点
}
}
if (cur == _root&&prev != cur)//prev是从右支返回的并且 cur为根节点结束循环
{
cout << cur->_data << ' ';
break;
}
}
}
//后续线索化
void PosOrderThread()
{
BinaryTreeThrNode<T>* prev = NULL;
_PosOrderThread(_root,prev);
}

BinaryTreeThrNode<T>* _CreateBiTree(const T* tmp,  size_t& index, size_t size)
{
BinaryTreeThrNode<T>* root = NULL;
BinaryTreeThrNode<T>* parent = NULL;
if (index < size&&tmp[index] != '#')
{

root = new BinaryTreeThrNode<T>(tmp[index]);
parent=_CreateBiTree(tmp, ++index, size);
if (parent)
{
root->_leftChild = parent;
parent->_parent = root;
}
parent = _CreateBiTree(tmp, ++index, size);

}
if (parent)
{
root->_rightChild = parent;
parent->_parent = root;
}
return root;
}

//中序线索化

void _InOrderThread(BinaryTreeThrNode<T>*cur,BinaryTreeThrNode<T>* & prev)
{
if (cur ==NULL)
return;
_InOrderThread(cur->_leftChild,prev);//向左树遍历
if (cur->_leftChild==NULL)            //左为空  改变左类型 左指向prev
{
cur->_leftType = Thread;
cur->_leftChild = prev;

}
if (prev&&prev->_rightChild == NULL) //prev!=NULL 且prev右不空 改变右类型 让右指向当前
{
prev->_rightType = Thread;
prev->_rightChild = cur;
}
prev = cur;                          //prev指向递归返回前的节点
_InOrderThread(cur->_rightChild, prev);  //指向右数节点

}

//前序线索化 自己的笨办法
void _PreOrderThread1(BinaryTreeThrNode<T>* cur, BinaryTreeThrNode<T>* &prev)
{
if (cur == NULL)
return;
if (prev&&prev->_rightType == Thread&&prev->_rightChild==NULL)//给右为空的左节点
prev->_rightChild = cur;
if (cur->_leftChild)//左不空  压左
{
prev = cur;   //prev=上个节点
_PreOrderThread(cur->_leftChild, prev);
}
else
{
cur->_leftType = Thread;//左空  左节点类型为线索类型
cur->_leftChild = prev;//线索指向prev
}
if (cur->_rightChild)//右不为空
{
_PreOrderThread(cur->_rightChild, prev);//压右
}
else
{

if (prev&&prev->_rightType==Thread&&cur->_leftType==Link&&cur->_rightChild==NULL)
cur->_rightChild =prev;//判断是否该节点为只有左分支 是的话使右线索指向左分支
cur->_rightType = Thread;//右分支为线索类型
if (cur->_rightChild==NULL)//不连续压左情况  右分支为空  使prev=cur
prev = cur;
}
}

void _PreOrderThread(BinaryTreeThrNode<T>* cur, BinaryTreeThrNode<T>* &prev)//老师方法
{
if (cur == NULL)//空返回
return;
if (cur->_leftChild == NULL)//左植线索化  当前递归中
{
cur->_leftType = Thread;
cur->_leftChild = prev;
}
if (prev&&prev->_rightChild == NULL)//右植线索化 返回上次递归中
{
prev->_rightType = Thread;
prev->_rightChild = cur;
}

prev = cur; //prev为上次递归cur

if (cur->_leftType==Link)//cur左值类型为节点类型 继续递归
_PreOrderThread(cur->_leftChild, prev);
if (cur->_rightType==Link)//cur右植类型为节点类型 继续递归
_PreOrderThread(cur->_rightChild, prev);
}

//后续线索化
void _PosOrderThread(BinaryTreeThrNode<T>* cur,BinaryTreeThrNode<T>*& prev)
{
if (cur == NULL)
return;

if (cur->_leftChild == NULL)//作为空左支线索化=prev
{
cur->_leftType = Thread;
cur->_leftChild = prev;
}

if (cur->_leftType==Link)//cur左支类型为节点类型  递归左
_PosOrderThread(cur->_leftChild,prev);

if (cur->_rightType==Link)//cur右植为节点类型  递归右
_PosOrderThread(cur->_rightChild,prev);
if (prev&&prev->_rightChild == NULL)  //prev右植为空  prev指向当前
{
prev->_rightType = Thread;
prev->_rightChild = cur;
}
prev = cur;  //子树递归结束 prev=cur

}
};

//测试用例
#include"bintreethread.hpp"
#include"BinaryTreeThreading.h"

using namespace std;

void test()
{
int a[10] = { 1, 2, 3, '#', '#',4, '#', '#', 5, 6 };
int s[18] = { 1, 2, 3, 4, '#', '#', 5, '#', '#', 6, '#', '#', 7, 8, '#', '#', 9, 10 };
int k[14] = { 1, 2, 3, 4, '#','#','#',5,'#','#', 6, 7,'#','#' };
BinaryTreeThread<int> s1;
BinaryTreeThread<int> s2(s,18);
//BinaryTreeThread<int> s2(k, 14);
//BinaryTreeThread<int> s2(a, 10);

/*s2.InOrderThread();
s2.InOrderThe();*/
//s2.PreOrderThread();

s2.PosOrderThread();
s2.PosOrderThe();
}

int main()
{
test();
return 0;
}