线索化二叉树的非递归遍历（用前驱结点和后继访问）

#pragma once
#include<iostream>
using namespace std;
enum PointTag
{
THREAD,
LINK
};
template<class T>
struct BinaryTreeNodeThd
{
T _data;
BinaryTreeNodeThd<T>* _left;
BinaryTreeNodeThd<T>* _right;
BinaryTreeNodeThd<T>* _parent;
PointTag _leftTag;
PointTag _rightTag;
BinaryTreeNodeThd(const T& x)
:_data(x)
, _left(NULL)
, _right(NULL)
, _parent(NULL)
, _leftTag(LINK)
, _rightTag(LINK)
{}
};
template<class T>
class BinaryTreeThd
{
protected:
BinaryTreeNodeThd<T>* _CreateBinaryTree(T* a, size_t& index, const size_t size)
{
BinaryTreeNodeThd<T>* root = NULL;
if (index < size&&a[index] != '#')
{
root = new BinaryTreeNodeThd<T>(a[index]);
root->_left = _CreateBinaryTree(a, ++index, size);
if (root->_left)
root->_left->_parent = root;
root->_right = _CreateBinaryTree(a, ++index, size);
if (root->_right)
root->_right->_parent = root;
}
return root;
}
void _Clear(BinaryTreeNodeThd<T>* root)
{
if (root)
{
if (root->_leftTag == LINK)
_Clear(root->_left);
if (root->_rightTag == LINK)
_Clear(root->_right);
delete root;
}
}
void _InOrderThreading(BinaryTreeNodeThd<T>* cur, BinaryTreeNodeThd<T>*& prev)
{
if (cur == NULL)
return;

_InOrderThreading(cur->_left, prev);
if (cur->_left==NULL)
{
cur->_leftTag = THREAD;
cur->_left = prev;
}
if (prev&&prev->_right == NULL)
{
prev->_rightTag = THREAD;
prev->_right = cur;
}
prev = cur;

_InOrderThreading(cur->_right, prev);
}

void _PreOrderThreading(BinaryTreeNodeThd<T>* cur, BinaryTreeNodeThd<T>*& prev)
{
if (cur == NULL)
return;

if (cur->_left == NULL)
{
cur->_leftTag = THREAD;
cur->_left = prev;
}
if (prev&&prev->_right == NULL)
{
prev->_rightTag = THREAD;
prev->_right = cur;
}
prev = cur;
if (cur->_leftTag == LINK)
_PreOrderThreading(cur->_left, prev);
if (cur->_rightTag == LINK)
_PreOrderThreading(cur->_right, prev);
}
void _PostOrderThreading(BinaryTreeNodeThd<T>* cur, BinaryTreeNodeThd<T>*& prev)
{
if (cur == NULL)
return;
_PostOrderThreading(cur->_left, prev);
_PostOrderThreading(cur->_right, prev);
if (cur&&cur->_left == NULL)
{
cur->_leftTag = THREAD;
cur->_left = prev;
}
if (prev&&prev->_right == NULL)
{
prev->_rightTag = THREAD;
prev->_right = cur;
}
prev = cur;
}
public:
BinaryTreeThd()
:_root(NULL)
{}
BinaryTreeThd(T* a,size_t size)
{
size_t index = 0;
_root=_CreateBinaryTree(a, index, size);
}
~BinaryTreeThd()
{
_Clear(_root);
_root = NULL;
}
void  PreOrderThreading()
{
BinaryTreeNodeThd<T>* prev = NULL;
_PreOrderThreading(_root, prev);
}
/*void PreOrderThd()
{
if (_root == NULL)
return;
BinaryTreeNodeThd<T>* cur = _root;

while (cur)
{

cout << cur->_data << " ";
while (cur&&cur->_leftTag != THREAD)
{
cur = cur->_left;
cout << cur->_data << " ";
}

while (cur&&cur->_rightTag != LINK)
{
cur = cur->_right;
cout << cur->_data << " ";
}
if (cur->_leftTag == LINK)
cur = cur->_left;
else
cur = cur->_right;
}
cout << endl;
}*/
//优化版前序遍历，发现规律，注意观察
void PreOrderThd()
{
if (_root == NULL)
return;
BinaryTreeNodeThd<T>*cur = _root;
while (cur)
{
while (cur&&cur->_leftTag == LINK)
{
cout << cur->_data << " ";
cur = cur->_left;
}
cout << cur->_data << " ";
cur = cur->_right;
}
cout << endl;
}
void  InOrderThreading()
{
BinaryTreeNodeThd<T>* prev = NULL;
_InOrderThreading(_root, prev);
}
void InOrderThd()
{
if (_root == NULL)
return;
BinaryTreeNodeThd<T>* cur = _root;
while (cur)
{
while (cur&&cur->_leftTag != THREAD)
cur = cur->_left;
cout << cur->_data << " ";
while (cur&&cur->_rightTag != LINK)
{
cur = cur->_right;
cout << cur->_data << " ";
}
cur = cur->_right;
}
cout << endl;
}
void PostOrderThreading()
{
BinaryTreeNodeThd<T>* prev = NULL;
_PostOrderThreading(_root, prev);
}
//重点
void PostOrderThd()
{
if (_root == NULL)
return;
BinaryTreeNodeThd<T>* cur = _root->_left;
BinaryTreeNodeThd<T>* prev = NULL;
int flag = 0;
while (cur != _root)
{
while (cur&&cur->_leftTag == LINK)
{
cur = cur->_left;
}
while (cur&&cur->_rightTag == THREAD)
{
cout << cur->_data << " ";
prev = cur;
cur = cur->_right;
}
if (_root == cur)
{
cout << _root->_data << " ";
prev = _root;
break;
}
while(cur&&_root!=cur&&cur->_rightTag == LINK&&cur->_right == prev)
{
cout << cur->_data << " ";
prev = cur;
cur = cur->_parent;
}
if (cur == _root)
{
if (flag == 0)
flag = 1;
else
break;
}
if (cur&&cur->_rightTag == LINK&&cur != prev)
cur = cur->_right;
else
{
cout << cur->_data << " ";
prev = cur;
cur = cur->_parent;
}

}
if(prev!=_root)
cout << _root->_data << " ";
cout << endl;
}
protected:
BinaryTreeNodeThd<T>* _root;
};
void  Test3()
{
//注意测试用例
//int array[18] = { 1, 2, 3, 7, '#','#','#',4,8,'#','#',9,'#','#',5,6,'#',10};

int array[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
//int array[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
BinaryTreeThd<int> b2(array, 10);
/*b2.InOrderThreading();
b2.InOrderThd();*/
/*b2.PreOrderThreading();
b2.PreOrderThd();*/
b2.PostOrderThreading();
b2.PostOrderThd();
}
int main()
{
Test3();
system("pause");
return 0;
}