二叉树线索化

线索二叉树


按照某种遍历方式对二叉树进行遍历，可以把二叉树中所有结点排序为一个线性序列。在改序列中，除第一个结点外每个结点有且仅有一个直接前驱结点；除最后一个结点外每一个结点有且仅有一个
直接后继结点。这些指向直接前驱结点和指向直接后续结点的指针被称为线索（Thread），加了线索的二叉树称为线索二叉树。

  当用二叉链表作为二叉树的存储结构时，因为每个结点中只有指向其左、右儿子结点的指针，所以从任一结点出发只能直接找到该结点的左、右儿子。在一般情况下靠它无法直接找到该结点在某种

  遍历序下的前驱和后继结点。如果在每个结点中增加指向其前驱和后继结点的指针，将降低存储空间的效率。

  我们可以证明：在n个结点的二叉链表中含有n+1个空指针。因为含n个结点的二叉链表中含有2n个指针，除了根结点，每个结点都有一个从父结点指向该结点的指针，因此一共使用了n-1个指针，所  以在n个结点的二叉链表中含有n+1个空指针。

  因此可以利用这些空指针，存放指向结点在某种遍历次序下的前驱和后继结点的指针。这种附加的指针称为线索，加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(ThreadedBinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。

程序代码：
  1 #include<iostream>
using namespace std;
typedef enum 
{
　　 LINK,
 　　THREAD
}PointerTag;
template<class T>
struct BinaryTreeNodeThd
{
 　　T _data;
　　 BinaryTreeNodeThd<T>* _left;
　　 BinaryTreeNodeThd<T>* _right;
　　 PointerTag _leftTag;
　　 PointerTag _rightTag;
 　　BinaryTreeNodeThd() : _left(NULL), _right(NULL), _leftTag(LINK), _rightTag(LINK)
 　　{}
 　　BinaryTreeNodeThd(const T&data) 

　　  :_data(data), _left(NULL), _right(NULL), _leftTag(LINK), _rightTag(LINK)
　　 {}
};

template<class T>
class BinaryTreeThd
{
public:
 　　BinaryTreeThd() :_root(NULL)
 　　{}
 　　BinaryTreeThd(const T*a, size_t size)
 　　{
  　　　　size_t index = 0;
  　　　　_root = _CreateTree(a, size, index);
 　　}
 　　BinaryTreeThd(const BinaryTreeThd<T>& t)
 　　{
　　　　  _root = _Copy(t._root);
　　 }
 　　void InOrderThreading()
 　　{
 　　　　  BinaryTreeNodeThd<T>* prev = NULL;
　　　　  _InOrderThreading(_root, prev);
 　　}
 　　void PrevOrderThreading()
 　　{
 　　　　 BinaryTreeNodeThd<T>* prev = NULL;
 　　　　 _PrevOrderThreading(_root, prev);
　　 }
 　　void PostOrderThreading()
 　　{
 　　　　 BinaryTreeNodeThd<T>* prev = NULL;
 　　　　 _PostOrderThreading(_root, prev);
 　　}

public:
 　　void InOrderThd()
　　 {
　　　　  BinaryTreeNodeThd<T>* cur=_root;
 　　　　 while (cur)
 　　　　 {
 　　　　　　  while (cur->_leftTag == LINK)
  　　　　　　 {
  　　　　　　　　  cur = cur->_left;
  　　　　　　 }
  　　　　　　 cout<<cur->_data<<" ";
  　　　　　　 while(cur&&cur->_rightTag == THREAD)
  　　　　　　 {
  　　　　　　　　  cur = cur->_right;
   　　　　　　　　 cout << cur->_data;
  　　　　　　 }
 　　　　　　  cur = cur->_right;
　　　　  }
　　　　  cout << endl;
　　 }
 　　void PrevOrderThd()
 　　{
  　　　　BinaryTreeNodeThd<T> *cur =_root;
  　　　　while (cur)
 　　　　 {
 　　　　　　  while (cur&&cur->_leftTag == LINK)
  　　　　　　 {
  　　　　　　　　  cout << cur->_data << " ";
   　　　　　　　　 cur = cur->_left;
   　　　　　　}
   　　　　　　cout << cur->_data << " ";
  　　　　　　 while (cur&&cur->_rightTag == THREAD)
  　　　　　　 {
  　　　　　　　　  cur = cur->_right;
 　　　　　　　　   cout << cur->_data << " ";
 　　　　　　  }
 　　　　　　  if (cur->_leftTag == LINK)
 　　　　　    cur = cur->_left;
  　　　　　　 else
    　　　　　cur = cur->_right;
 　　　　 }
 　　}

protected:
 　　BinaryTreeNodeThd<T>* _CreateTree(const T*a, size_t size, size_t &index)
　　 {　　
　　　　   BinaryTreeNodeThd<T>* root = NULL;
 　　　　 if (index < size&&a[index] != '#')
 　　　　 {
 　　　　　　  root = new BinaryTreeNodeThd<T>(a[index]);
  　　　　　　 root->_left = _CreateTree(a, size, ++index);
  　　　　　　 root->_right = _CreateTree(a, size, ++index);
  　　　　}
  　　　　return 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->_rightTag == NULL)
  　　　　　　{
  　　　　　　　　 prev->_rightTag = THREAD;
  　　　　　　　　 prev->_right = cur;
  　　　　　　}

　　　　　　prev = cur;  

 　　　　　　_InOrderThreading(cur->_right, prev);

　　 }

 　　void _PrevOrderThreading(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)  

　　　　 {   

　　　　　　 _PrevOrderThreading(cur->_left, prev);  

 　　　　}  

 　　　　if (cur->_rightTag == LINK)   

　　　　{    

　　　　　　_PrevOrderThreading(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->_left == NULL)
 　　　　　　　　 {
  　　　　　　　　　　 cur->_leftTag = THREAD;
  　　　　　　　　　　 cur->_left = prev;
 　　　　　　　　 }
 　　　　　　　　 if (prev&&prev->_right == NULL)
  　　　　　　　　{　　　　　　　　
 　　　　　　　　　　  prev->_rightTag = THREAD;
 　　　　　　　　　　  prev->_right = cur;
  　　　　　　　　}
  　　　　　　　　prev = cur;
　　　　 }

　　BinaryTreeNodeThd<T>* _Copy(BinaryTreeNodeThd<T>* root)
 　　{
 　　　　　　 if (root == NULL)
  　　　　　　 return NULL;
  　　　　　　BinaryTreeNodeThd<T>* newRoot = new BinaryTreeNodeThd<T>(root->_data);
  　　　　　　newRoot->_left = _Copy(root->_left);
  　　　　　　newRoot->_right = _Copy(root->_right);
 　　　　　　 return newRoot;
 　　}

 

　　/*BinaryTreeThd<T>& operator=(BinaryTreeThd<T>*& t)
　　 {
　　　　　　  if (this != &t)
 　　　　　　 {
 　　　　　　　　  this->_Destory(_root);
 　　　　　　　　  _root = _Copy(t._root);
 　　　　　　 }
 　　　　　　 return *this;
　　 }*/
　　 //BinaryTreeNodeThd<T>& operator=(BinaryTreeNodeThd<T> t)
　　 //{
 　　　　// swap(_root, t._root);
　　　　 // return this;
 　　//}

protected:
　　 BinaryTreeNodeThd<T> *_root;
};
int main()
{
　　 int a[] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
 　　BinaryTreeThd<int> t(a, 10);
 　　BinaryTreeThd<int> temp;
 　　t.InOrderThd();
　　 t.InOrderThreading();
 　　//t.PrevOrderThreading();
 　　//t.PostOrderThreading();
 　　cout << endl;
 　　system("pause");
 　　return 0;
}