.如何不用递归实现二叉树的前序/后序/中序遍历？

import java.lang.Thread.State;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

public class BinaryTree {

private Node root;

private Node list;

private Node current;

public void print(){
if(this.root!=null){
this.root.print();
}
}
/**       非递归中序遍历
*    思想是：用一个栈，先保存跟节点，然后循环保存的它的左子树，
*    接着做出栈操作，pop出的内容的先判断他是否有右子树，如果有右子树
*    做如栈操作，然后接着判断如栈的元素是否有左子树，如果有的话，循环加入栈中
*
*              5
*             / \
*            3   7
*           /\   /\
*          2  4  6
*         /
*         1
*
*   stack
*
*  例子  左子树入栈 然后出站
*        |1|           【1】pop
*        |2|           【2】pop
*        |3|           【3】pop 注意呀，这个时候就得判断【3】的右子树了
*        |5|            因为3有右子树，所以的把它的右子树入栈 栈的结构图如下
*                        stack
*                        【4】
*                        【5】
*                        接着同理了
*/

public void midPint(){
Stack<Node> stack=new Stack<>();
Node temp=root;
if(temp!=null){
stack.push(temp);
}
while(temp.left!=null){
stack.push(temp.left);
temp=temp.left;
}
while(stack.size()>0){
temp=stack.pop();
System.out.println(temp.data);
if(temp.right!=null){
temp=temp.right;
stack.push(temp);
while(temp!=null){
if(temp.left!=null){
stack.push(temp.left);
}
temp=temp.left;
}
}
}

}

public List<Node> breadFirst(){
List<Node> list=new ArrayList<Node>();
Queue<Node> queue=new ArrayDeque<Node>();
if(root!=null){
queue.add(root);
}
while(!queue.isEmpty()){
list.add(queue.peek());
Node node=queue.poll();
if(node.left!=null){
queue.offer(node.left);
}

if(node.right!=null){
queue.offer(node.right);
}
}
return list;
}

public List<Node> breadFirst2(){
List<Node> list=new ArrayList<>();
Queue<Node> queue=new ArrayDeque<>();
if(root!=null){
queue.offer(root);
}
while(!queue.isEmpty()){
list.add(queue.peek());
Node curren=queue.poll();
if(curren.left!=null){
queue.offer(curren.left);
}
if(curren.right!=null){
queue.offer(curren.right);
}

}
return list;

}
/**             5           镜像后          5
*             / \                        / \
*            3   7                      7  3
*           /\   /\                    /\  /
*          2  4  6                    4  2 6
*         /                          / \
*         1                             1
* @param root
*/

public static void preOrder(Node root){
if(root==null){
return;
}
Node temp=root.left;
root.left=root.right;
root.right=temp;
preOrder(root.left);
preOrder(root.right);

}

public List<Node> midPrint(Node node){
List<Node> list=new ArrayList<Node>();
if(node.left!=null){
list.addAll(midPrint(node.left));
}
list.add(node);
if(node.right!=null){
list.addAll(midPrint(node.right));
}
return list;

}

public void converList(){
if(this.root!=null){
this.root.convertList();
}

}

public void addList(Node  node){
if(list==null){
System.out.println("cao"+node.data);
list=node;
current=node;
}else{
current.right=node;
node.left=current;
current=node;
}

}

public void add(int data){
if(root==null){
root=new Node(data, null, null);
}else{
Node parent = null;

Node current=root;
while(current!=null){
parent=current;
if(current.data>data){
current=current.left;
}else{
current=current.right;
}

}

if(parent.data>data){
Node node=new Node(data, null, null);
parent.left=node;
}else{
Node node=new Node(data, null, null);
parent.right=node;
}
}
}

class Node{
int data;
Node left;
Node right;
public Node(int data,Node left,Node right){
this.data=data;
this.left=left;
this.right=right;
}

/**
* 二差数转化成有序的链表
*/
public void convertList(){
if(this.left!=null){
this.left.convertList();
}
addList(this);
//			System.out.println(this.data);
if(this.right!=null){
this.right.convertList();
}

}

public void print(){
if(this.left!=null){
this.left.print();
}
System.out.println(this.data);
if(this.right!=null){
this.right.print();
}
}
@Override
public String toString() {
// TODO Auto-generated method stub
return ""+this.data;
}

}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

BinaryTree bt = new BinaryTree();
bt.add(5);
bt.add(7);
bt.add(3);
bt.add(2);
bt.add(1);
bt.add(6);
bt.add(4);
System.out.println("************************");
bt.midPint();
//        bt.preOrder(bt.root);
System.out.println("************************");

//        System.out.println(bt.breadFipreOrderrst());
bt.converList();
System.out.println("head"+bt.list.data);
Node current1=bt.list;

while(current1!=null){
System.out.println(current1.data);
current1=current1.right;
}

/* List<Node> list=bt.breadFirst2();
for(Node node:list){
System.out.println(node.data);
}
*/
}

}