二叉树的先序中序后序遍历 （递归和非递归）

package Tree;

public class TreeNode {
int val=0;
TreeNode left=null;
TreeNode right=null;
public TreeNode(int val) {
this.val=val;
}

}

package Tree;

import java.util.LinkedList;
import java.util.Stack;

public class BinaryTree {

//创建二叉树
public void createBinTree(TreeNode root,int count){

LinkedList<TreeNode>list=new LinkedList<TreeNode>();
list.add(root);
for(int i=2;i<count;i++){
TreeNode leftNode = new TreeNode(i);
TreeNode rightNode = new TreeNode(++i);
TreeNode tree=list.pop();
tree.left=leftNode;
tree.right=rightNode;
list.add(tree.left);
list.add(tree.right);
}
}

//先序遍历   递归实现
public void preOrderTree(TreeNode root){

if(root!=null){
System.out.print(root.val);
preOrderTree(root.left);
preOrderTree(root.right);
}

}

//先序遍历  非递归实现
public String nonRecPreOrder(TreeNode root){
StringBuilder sb=new StringBuilder();
LinkedList<TreeNode> stack=new LinkedList<TreeNode>();//jdk5之后  尽量少用Stack，使用LinkList  完全可以替代Stack  且效率比Stack高
while(root!=null||stack.size()>0){
while(root!=null){
sb.append(root.val);
stack.offerFirst(root);//压栈
root=root.left;
}

root=stack.pop();//出栈

root=root.right;

}

return sb.toString();
}

//中序遍历  递归实现
public void InOrderTree(TreeNode root){
StringBuilder sb=new StringBuilder();
if(root!=null){
InOrderTree(root.left);
System.out.print(root.val);
InOrderTree(root.right);

}

}
//中序遍历  非递归的形式
public String nonRecInOrderTree(TreeNode root){
StringBuilder sb=new StringBuilder();
LinkedList<TreeNode> stack=new LinkedList<TreeNode>();
while(root!=null||stack.size()>0){
while(root!=null){
stack.offerFirst(root);
root=root.left;
}
root=stack.pop();
sb.append(root.val);
root=root.right;
}

return sb.toString();
}
//后续遍历  递归实现
public void postOrderTree(TreeNode root){

if(root!=null){
postOrderTree(root.left);
postOrderTree(root.right);
System.out.print(root.val);

}

}

//后序遍历  非递归实现
public String nonRecpostOrderTree(TreeNode root){
StringBuilder sb=new StringBuilder();
LinkedList<TreeNode>stack=new LinkedList<TreeNode>();
TreeNode node=null;
while(root!=null){
//若节点有左孩子则将节点压栈
while(root.left!=null){
stack.offerFirst(root);
root=root.left;
}//最终得出  叶子节点  没有左孩子

//节点不为空  且  节点没有右孩子 或者节点的右孩子已经遍历
while(root!=null&&(root.right==null||root.right==node)){
sb.append(root.val);
node=root;
if(stack.isEmpty()){
return sb.toString();
}
root=stack.pop();

}

//如果以上不符合条件  说明有右子树   所以要将当前节点压栈  指针移到 右边子树上
stack.offerFirst(root);
root=root.right;

}

return sb.toString();
}

//判断两个二叉树  是否是  属于子树的关系
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
String tree1=PreOrder(root1);
String tree2=PreOrder(root2);
if(tree1.equals("")||tree2.equals("")){
return false;
}
if(tree1.length()>=tree2.length()){
if(tree1.contains(tree2))
return true;
}else{
if(tree2.contains(tree1))
return true;
}

return false;
}

public String PreOrder(TreeNode p){
Stack<TreeNode> stack=new Stack<TreeNode>();
TreeNode node=p;
StringBuilder sb=new StringBuilder();
while(node!=null||stack.size()>0){
while(node!=null){
sb.append(node.val);
stack.push(node);
node=node.left;
}
if(stack.size()>0){
node=stack.pop();
node=node.right;
}
}

return sb.toString();
}

public static void main(String[]args){
BinaryTree BT=new BinaryTree();
TreeNode root=new TreeNode(1);
BT.createBinTree(root,7);

System.out.println("---------------先序遍历---------------递归 ");
BT.preOrderTree(root);
System.out.println("");
System.out.println("非递归");
System.out.println(BT.nonRecPreOrder(root));
System.out.println("---------------中序遍历----------------递归");
BT.InOrderTree(root);
System.out.println("");
System.out.println("非递归");
System.out.println(BT.nonRecInOrderTree(root));

System.out.println("---------------后序遍历------------------递归");
BT.postOrderTree(root);
System.out.println(" ");
System.out.println("非递归");
System.out.println(BT.nonRecpostOrderTree(root));

}

}