java实现一颗二叉树，完成层次遍历，两种中序遍历（递归，非递归）

```java
package com.easy.Tree;

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }

    public TreeNode(int val) {
        this.val = val;
    }

    public TreeNode() {
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }
}
```

```java
package com.easy.Tree;

public class tree {
    TreeNode root=null;
}
```

```java
package com.easy.Tree;

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

public class test {
    public static void main(String[] args) {
        tree tree = new tree();
        TreeNode treeNode = new TreeNode(10);
        tree.root = treeNode;
        TreeNode treeNode1 = new TreeNode(6);
        TreeNode treeNode2 = new TreeNode(7);
        TreeNode treeNode3 = new TreeNode(8);
        TreeNode treeNode4 = new TreeNode(9);
        tree.root.left = treeNode1;
        tree.root.right = treeNode2;
        treeNode1.left = treeNode3;
        treeNode2.right = treeNode4;
        inorderTraversal(tree.root);
        leve(tree.root);
        inorderTraversalStack(tree.root);

    }
    public static void leve(TreeNode root){
        if(root==null){
            System.out.println("无元素");
            return;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        int leve=1;
        while (!queue.isEmpty()){
            int len=queue.size();
            while (len>0){
                TreeNode temp=queue.poll();
                System.out.println("第"+leve+"层的元素为:"+temp.val);
                len--;
                if(temp.left!=null) queue.add(temp.left);
                if(temp.right!=null) queue.add(temp.right);
            }
            leve++;
        }
    }
    public static void inorderTraversal(TreeNode root){
        if(root==null){
            return;
        }
        inorderTraversal(root.left);
        System.out.println(root.val);
        inorderTraversal(root.right);
    }
    // 中序遍历顺序: 左-中-右 入栈顺序： 左-右
    // 处理中时弹出栈
    public static void inorderTraversalStack(TreeNode root){
        if(root==null){
            return;
        }
        Stack<TreeNode> s=new Stack<>();
        TreeNode cur=root;
        while (cur!=null||!s.empty()){
            if(cur!=null){
                s.push(cur);
                cur=cur.left;
            }else {
                cur=s.pop();
                System.out.println(cur.val);
                cur=cur.right;
            }
        }
    }
}
```