二叉树排序

public class BinaryTree {
    BinaryTree left;
    BinaryTree right;
    Integer val;
    public BinaryTree getLeft() {
        return left;
    }
    public void setLeft(BinaryTree left) {
        this.left = left;
    }
    public BinaryTree getRight() {
        return right;
    }
    public void setRight(BinaryTree right) {
        this.right = right;
    }
    public Integer getVal() {
        return val;
    }
    public void setVal(Integer val) {
        this.val = val;
    }
}

  /**
     * 二叉树层次遍历
     * @param root
     * @return
     */
    public List<BinaryTree> levelOrder(BinaryTree root){
        Queue<BinaryTree> queue = new LinkedList<>();
        List<BinaryTree> list = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            BinaryTree head = queue.poll();
            if(head.getLeft() != null){
                queue.offer(head.getLeft());
            }
            if(head.getRight() != null){
                queue.offer(head.getRight());
            }
            list.add(head);
        }
        return list;
    }

   /**
     * 二叉树递归中序遍历
     * @param root
     */
    public void midOrderRecur(BinaryTree root){
        if (root == null){
            return;
        }
        midOrderRecur(root.left);
        System.out.print(root.getVal());
        midOrderRecur(root.right);
    }

  /**
     * 二叉树中序遍历
     * @param root
     */
    public void midOrder(BinaryTree root){
        BinaryTree current = root;
        LinkedList<BinaryTree> list = new LinkedList<>();
        while(current != null || !list.isEmpty()){
            while(current != null){
                list.addFirst(current);
                current = current.left;
            }
            if(!list.isEmpty()){
                current = list.removeFirst();
                System.out.print(current.getVal());
                current = current.right;
            }
        }
    }