二叉树的创建与遍历

import java.lang.Thread.State;
import java.text.spi.NumberFormatProvider;
import java.util.Stack;


import javax.print.attribute.standard.NumberOfDocuments;


import org.w3c.dom.NodeList;


public class MyBinTree {
private Node root;

public MyBinTree(){
this.root= null;
}
//java的访问权限有下面四种：public--都可访问(公有)   protected--包内和子类可访问（保护）不写(default)--包内可访问 （默认）private--类内可访问（私有）

private class Node{   
int data;         //default修饰符
Node lchild;
Node rchild;

public Node(int data){
this.data= data;
this.lchild=null;
this.rchild=null;
}
}


//创建二叉查找树：所有节点的左子树节点都比根节点小，右子树节点都比根节点大
public void buildTree(Node node,int data) {
if(root==null){
root= new Node(data);
/* if(node==null){      开始没注意写成了这样，发现每次调用buildTree时，node都是null，发现底下传入的参数其实是root
node= new Node(data);*/
}else{
if(data<node.data){  //左孩子
if(node.lchild==null){
node.lchild= new Node(data);
}else{
buildTree(node.lchild, data);
}
}else{
if(node.rchild==null){
node.rchild=new Node(data);
}else{
buildTree(node.rchild, data);
}

}
}
}

//递归前序遍历
    public  void preOrder(Node node){
    if(node!=null){
    System.out.print("  "+node.data);
    preOrder(node.lchild);
    preOrder(node.rchild);
    }
    }
    
    //递归中序遍历
    public void inOrder(Node node){
    if(node!=null){
    inOrder(node.lchild);
    System.out.print(" "+node.data);
    inOrder(node.rchild);
    }
    }
   
    //递归后序遍历
    public void postOrder(Node node){
    if(node!=null){
    postOrder(node.lchild);
    postOrder(node.rchild);
    System.out.print(" "+node.data);
    }
    } 
   
    //非递归前序遍历
    public void preOrder2(Node node){
    Stack<Node> stack = new Stack<>();
    while(node!=null||!stack.isEmpty()){
    //先一路向左走，找到底，把找到的节点都压入栈，并sysout出来。
    while(node!=null){
    System.out.print(node.data+" ");
    stack.push(node);
    node=node.lchild;
    }
    if(!stack.isEmpty()){  //抛出栈顶元素
    node = stack.pop();
    node= node.rchild;
    }  
    }
    }
    
    //非递归的中序遍历
    //和前序遍历的区别就是将输出放在了栈的pop之后
    public void inOrder2(Node node){
    Stack<Node>  stack = new Stack<>();
    while(node!=null||!stack.isEmpty()){
    while(node!=null){
    stack.push(node);
    node=node.lchild;
    }
    if(!stack.isEmpty()){
    node=stack.pop();
    System.out.print(node.data+" ");
    node=node.rchild;
    }
   
    }
    }
    //后续遍历的非递归实现
    public void postOrder2(Node node) {
Stack<Node> stack = new Stack<>();
Node curNode= node;
Node lastNode=node;
while(curNode!=null){
stack.push(curNode);
curNode=curNode.lchild;
}
while(!stack.isEmpty()){
curNode=stack.pop();
if(curNode.rchild==null||curNode.rchild==lastNode){
System.out.print(curNode.data+" ");
lastNode=curNode;
}else{
    stack.push(curNode);
    curNode=curNode.rchild;
    while(curNode!=null){
    stack.push(curNode);
    curNode=curNode.lchild;
    }
}
}

}
    
    
    


public static void main(String[] args) {
int[] a = {2,4,12,45,21,6,111};  
MyBinTree myBinTree= new MyBinTree();
for(int i=0;i<a.length;i++){
myBinTree.buildTree(myBinTree.root, a[i]);
}
myBinTree.preOrder(myBinTree.root);
System.out.println();
myBinTree.preOrder2(myBinTree.root);
System.out.println();
myBinTree.inOrder(myBinTree.root);
System.out.println();
myBinTree.inOrder2(myBinTree.root);
System.out.println();
myBinTree.postOrder(myBinTree.root);
System.out.println();
myBinTree.postOrder2(myBinTree.root);


}


}