中序线索二叉树的java版本

package threadbinarytree;


public class ThreadNode<T> {

private ThreadNode<T> leftNode;
private ThreadNode<T> rightNode;
private int lflag;
private int rflag;
private T data;
public ThreadNode(ThreadNode<T> leftNode, ThreadNode<T> rightNode,
int lflag, int rflag) {
this.leftNode = leftNode;
this.rightNode = rightNode;
this.lflag = lflag;
this.rflag = rflag;
}
public ThreadNode() {
this.leftNode=null;
this.rightNode=null;
this.lflag=0;
this.rflag=0;
}
public ThreadNode(T data) {
this();
this.data = data;
}
@Override
public int hashCode() {
return data.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ThreadNode other = (ThreadNode) obj;
if (data == null) {
if (other.data != null)
return false;
} else if (!data.equals(other.data))
return false;
return true;
}
public ThreadNode<T> getLeftNode() {
return leftNode;
}
public void setLeftNode(ThreadNode<T> leftNode) {
this.leftNode = leftNode;
}
public ThreadNode<T> getRightNode() {
return rightNode;
}
public void setRightNode(ThreadNode<T> rightNode) {
this.rightNode = rightNode;
}
public int getLflag() {
return lflag;
}
public void setLflag(int lflag) {
this.lflag = lflag;
}
public int getRflag() {
return rflag;
}
public void setRflag(int rflag) {
this.rflag = rflag;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}

}

package threadbinarytree;


import java.util.Scanner;


public class ThreadTree<T> {


protected ThreadNode<T> head=null;
public static final String ENDFLAG="#";


public ThreadTree() {
}


public ThreadTree(ThreadNode<T> head) {
this.head = head;
}

//初始化根节点
public void initThreadTree(){
String item=null;
Scanner sc=new Scanner(System.in);
System.out.println("请输入根节点");
item=sc.nextLine();
if(!item.equalsIgnoreCase(ENDFLAG)){
head=new ThreadNode(item);
init(head);
}
}
//初始化二叉树
private void init(ThreadNode<T> head){
String item=null;
Scanner sc=new Scanner(System.in);
System.out.println("请输入"+head.getData()+"的左孩子节点");
item=sc.nextLine();
if(!item.equalsIgnoreCase(ENDFLAG)){
head.setLeftNode(new ThreadNode(item));
init(head.getLeftNode());
}
System.out.println("请输入"+head.getData()+"的右孩子节点");
item=sc.nextLine();
if(!item.equalsIgnoreCase(ENDFLAG)){
head.setRightNode(new ThreadNode(item));
init(head.getRightNode());
}
}

//创建线索二叉树
public void createThreadTree(){

}

//中序遍历
public void inTraverse(){

}


// //先序遍历
// public void PreOrder(){
// PreOrder(head);
// }
// private void PreOrder(ThreadNode<T> head){
// if(head!=null){
// System.out.print(head.getData()+" ");
// PreOrder(head.getLeftNode());
// PreOrder(head.getRightNode());
// }
// }


}

package threadbinarytree;


//中序线索二叉树类
public class InThreadTree<T>  extends ThreadTree<T>{


//全局的前驱
private ThreadNode<T> pre=null;

public InThreadTree(){
super();
}


@Override
public void initThreadTree() {
super.initThreadTree();
}




//创建线索二叉树
@Override
public void createThreadTree() {
inThread(head);
}

//将二叉树进行线索化
public void inThread(ThreadNode<T> root){
if(root != null){
inThread(root.getLeftNode()) ;//线索化左孩子
if(null == root.getLeftNode()&&(0==root.getLflag())){//左孩子为空
root.setLflag(1) ;//将左孩子设置为线索
root.setLeftNode(pre) ;
}
if(pre!=null&&null == pre.getRightNode()){//右孩子为空
pre.setRflag(1);
pre.setRightNode(root) ;
}
pre = root ;
inThread(root.getRightNode()) ;//线索化右孩子
}
}


/**
* 中序遍历线索二叉树
* @param root
*/
   @Override
public void inTraverse(){
   ThreadNode<T> root=this.head;
if(root != null){
while(root!=null && (root.getLflag()==0)){//如果左孩子不是线索
root = root.getLeftNode() ;//
}


do{
System.out.print(root.getData() + ",");
if(root.getRflag()==1){//如果右孩子是线索
root = root.getRightNode();
}else{//有右孩子
root = root.getRightNode() ;
while(root!=null && (root.getLflag()==0)){
root = root.getLeftNode() ;
}
}
}while(root != null) ; 
}
}

public static void main(String[] args) {
ThreadTree<String> tree=new InThreadTree<String>();
tree.initThreadTree();
tree.createThreadTree();
tree.inTraverse();
}

}