线索二叉树

    今天，我们一起用C++实现一颗线索二叉树，具体代码如下：

ThreadInorderIterator.h具体内容如下：

#include "ThreadTree.h"

template<typename Type> class ThreadInorderIterator{
public:
	ThreadInorderIterator(ThreadTree<Type> &tree) :m_ptree(tree), m_pcurrent(tree.m_proot){
		//InThread(m_ptree.m_proot->m_pleft,m_ptree.m_proot);
	}

	ThreadNode<Type> *First();
	ThreadNode<Type> *Prior();
	ThreadNode<Type> *Next();

	void Print();
	void Print(ThreadNode<Type> *start, int n = 0);
	void InOrder();
	void InsertLeft(ThreadNode<Type> *left);
	void InsertRight(ThreadNode<Type> *right);
	ThreadNode<Type> *GetParent(ThreadNode<Type> *current);


private:
	ThreadTree<Type> &m_ptree;
	ThreadNode<Type> *m_pcurrent;
	void InThread(ThreadNode<Type> *current, ThreadNode<Type> *pre);
};

template<typename Type> void ThreadInorderIterator<Type>::InThread(
	ThreadNode<Type> *current, ThreadNode<Type> *pre){
	if (current != m_ptree.m_proot){
		InThread(current->m_pleft, pre);
		if (current->m_pleft == NULL){
			current->m_pleft = pre;
			current->m_nleftthread = 1;
		}
		if (pre->m_pright == NULL){
			pre->m_pright = current;
			pre->m_nrightthread = 1;
		}

		pre = current;
		InThread(current->m_pright, pre);
	}
}

template<typename Type> ThreadNode<Type>* ThreadInorderIterator<Type>::First(){
	while (m_pcurrent->m_nleftthread == 0){
		m_pcurrent = m_pcurrent->m_pleft;
	}
	return m_pcurrent;
}

template<typename Type> ThreadNode<Type>* ThreadInorderIterator<Type>::Prior(){
	ThreadNode<Type> *pmove = m_pcurrent->m_pleft;
	if (0 == m_pcurrent->m_nleftthread){
		while (0 == pmove->m_nrightthread){
			pmove = pmove->m_pright;
		}
	}
	m_pcurrent = pmove;
	if (m_pcurrent == m_ptree.m_proot){
		return NULL;
	}
	return m_pcurrent;
}

template<typename Type> ThreadNode<Type>* ThreadInorderIterator<Type>::Next(){
	ThreadNode<Type> *pmove = m_pcurrent->m_pright;
	if (0 == m_pcurrent->m_nrightthread){
		while (0 == pmove->m_nleftthread){
			pmove = pmove->m_pleft;
		}
	}
	m_pcurrent = pmove;
	if (m_pcurrent == m_ptree.m_proot){
		return NULL;
	}
	return m_pcurrent;
}

template<typename Type> void ThreadInorderIterator<Type>::InOrder(){
	ThreadNode<Type> *pmove = m_ptree.m_proot;
	while (pmove->m_pleft != m_ptree.m_proot){
		pmove = pmove->m_pleft;
	}
	m_pcurrent = pmove;
	cout << "root";
	while (pmove != m_ptree.m_proot&&pmove){
		cout << "--->" << pmove->m_data;
		pmove = this->Next();
	}
	cout << "--->end";
}

template<typename Type> void ThreadInorderIterator<Type>::InsertLeft(ThreadNode<Type> *left){
	left->m_pleft = m_pcurrent->m_pleft;
	left->m_nleftthread = m_pcurrent->m_nleftthread;
	left->m_pright = m_pcurrent;
	left->m_nrightthread = 1;
	m_pcurrent->m_pleft = left;
	m_pcurrent->m_nleftthread = 0;
	if (0 == left->m_nleftthread){
		m_pcurrent = left->m_pleft;
		ThreadNode<Type> *temp = First();
		temp->m_pright = left;
	}
	m_pcurrent = left;
}

template<typename Type> void ThreadInorderIterator<Type>::InsertRight(ThreadNode<Type> *right){
	right->m_pright = m_pcurrent->m_pright;
	right->m_nrightthread = m_pcurrent->m_nrightthread;
	right->m_pleft = m_pcurrent;
	right->m_nleftthread = 1;
	m_pcurrent->m_pright = right;
	m_pcurrent->m_nrightthread = 0;
	if (0 == right->m_nrightthread){
		m_pcurrent = right->m_pright;
		ThreadNode<Type> *temp = First();
		temp->m_pleft = right;
	}
	m_pcurrent = right;
}

template<typename Type> ThreadNode<Type>* ThreadInorderIterator<Type>::GetParent(
	ThreadNode<Type> *current){
	ThreadNode<Type> *pmove = current;
	while (0 == pmove->m_nleftthread){
		pmove = pmove->m_pleft;
	}
	pmove = pmove->m_pleft;
	if (pmove == m_ptree.m_proot){
		if (pmove->m_pleft == current){
			return NULL;
		}
	}
	if (pmove->m_pright == current){
		return pmove;
	}
	pmove = pmove->m_pright;
	while (pmove->m_pleft != current){
		pmove = pmove->m_pleft;
	}
	return pmove;
}

template<typename Type> void ThreadInorderIterator<Type>::Print(ThreadNode<Type> *start, int n){
	if (start->m_nleftthread&&start->m_nrightthread){
		for (int i = 0; i < n; i++){
			cout << "     ";
		}
		if (n >= 0){
			cout << start->m_data << "--->" << endl;
		}

		return;
	}
	if (start->m_nrightthread == 0){
		Print(start->m_pright, n + 1);
	}
	for (int i = 0; i < n; i++){
		cout << "     ";
	}
	if (n >= 0){
		cout << start->m_data << "--->" << endl;
	}
	if (start->m_nleftthread == 0){
		Print(start->m_pleft, n + 1);
	}
}

template<typename Type> void ThreadInorderIterator<Type>::Print(){
	Print(m_ptree.m_proot->m_pleft);
}

ThreadNode.h具体内容如下：

template<typename Type> class ThreadTree;
template<typename Type> class ThreadInorderIterator;

template<typename Type> class ThreadNode{
public:
	friend class ThreadTree < Type > ;
	friend class ThreadInorderIterator < Type > ;
	ThreadNode() :m_nleftthread(1), m_nrightthread(1){
		m_pleft = this;
		m_pright = this;
	}
	ThreadNode(const Type item) :m_data(item), m_pleft(NULL), m_pright(NULL)
		, m_nleftthread(0), m_nrightthread(0){}

private:
	int m_nleftthread, m_nrightthread;
	ThreadNode<Type> *m_pleft, *m_pright;
	Type m_data;
};

ThreadTree.h具体内容如下：

#include "ThreadNode.h"

template<typename Type> class ThreadInorderIterator;

template<typename Type> class ThreadTree{
public:
	friend class ThreadInorderIterator < Type > ;
	ThreadTree() :m_proot(new ThreadNode<Type>()){}

private:
	ThreadNode<Type> *m_proot;
};

main.cpp具体内容如下：

#include <iostream>

using namespace std;

#include "ThreadInorderIterator.h"

int main(){
	ThreadTree<int> tree;
	ThreadInorderIterator<int> threadtree(tree);
	int init[10] = { 3, 6, 0, 2, 8, 4, 9, 1, 5, 7 };
	for (int i = 0; i < 10;){
		threadtree.InsertLeft(new ThreadNode<int>(init[i++]));
		threadtree.InsertRight(new ThreadNode<int>(init[i++]));
	}
	threadtree.Print();
	cout << endl << endl;

	threadtree.InOrder();
	return 0;
}

运行效果如图1所示：

图1 运行效果