java二叉树的遍历（非递归）

二叉树作为一个重要的数据结构，我们在调用过程中需要掌它的遍历算法，加深我们对树的理解和栈、队列的应用。
下面是我定义的树的基本结构。

public class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode(int x) { val = x; }
     }

此图是该二叉树的结构

 /**
      * 层次遍历
      * @return
      */
     public List<Integer> levelOrder(){
          //结点队列
          Queue<TreeNode> treeNodes = new LinkedList<>();
          //输出队列
          List<Integer> list = new ArrayList<>();

          treeNodes.add(this);

          while (!treeNodes.isEmpty()){
               //弹出队首元素
               TreeNode node = treeNodes.poll();
               //添加结点值
               list.add(node.val);

               if(node.left!=null){
                    treeNodes.add(node.left);
               }
               if(node.right!=null){
                    treeNodes.add(node.right);
               }
          }

          return list;

     }

     /**
      * 中序遍历 非递归  未判null
      */
     public List<Integer> inorderTraversal(){
          Stack<TreeNode> treeNodes = new Stack<>();
          List<Integer> list = new ArrayList<>();
          TreeNode node = this;
          //栈不为null 就意味着还有结点值
          //node 不为null 代表 树还没有拆解完毕
          while (!treeNodes.isEmpty()||node!=null){
               //入栈
               while (node !=null){
                    treeNodes.push(node);
                    //指向左子树
                    node = node.left;
               }
               //该结点无左子树 出栈
               node = treeNodes.pop();
               list.add(node.val);
               //出栈后指向右子树
               node = node.right;
          }

          return list;
     }

     /**
      * 先序遍历
      * @return list
      */
     public List<Integer> preorderTraversal(){
          List<Integer> list = new ArrayList<>();

          Stack<TreeNode> treeNodes = new Stack<>();

          TreeNode node = this;

          treeNodes.push(node);

          while (!treeNodes.isEmpty()){
               node = treeNodes.pop();
               list.add(node.val);

               if(node.right!=null){
                    treeNodes.push(node.right);
               }
               if(node.left!=null){
                    treeNodes.push(node.left);
               }
          }

          return list;
     }

   /**
      * 后序遍历
      * @return
      */

     public List<Integer> postOrder() {

          Stack<TreeNode> treeNodeStack = new Stack<>();
          Stack<Integer> integerStack = new Stack<>();
          List<Integer> list = new ArrayList<>();

          TreeNode node = this;

          while (!treeNodeStack.isEmpty()||node!=null){
               while (node!=null){
                    treeNodeStack.push(node);
                    integerStack.push(node.val);
                    node =node.right;
               }
               if(!treeNodeStack.isEmpty()){
                    node = treeNodeStack.pop();
                    node = node.left;
               }

          }


          while (!integerStack.isEmpty()){
               list.add(integerStack.pop());
          }
          return list;
     }

运行结果