• 线索二叉树


    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>()){}
    
    

    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);
    }
    
    

    test.cpp
    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;
    }
    
  • 相关阅读:
    Java线程的5个使用技巧
    每个Java程序员需要了解的8个Java开发工具
    爱上Java和JVM的10大理由
    Git入门
    建网站的流程
    idea快捷键
    idea中ctrl+alt+方向键问题
    oracle数据库-备份
    rabbitmq路由模式、订阅、主题
    rabbitmq 工作模式、简单模式
  • 原文地址:https://www.cnblogs.com/rollenholt/p/2438058.html
Copyright © 2020-2023  润新知