汉诺塔+二叉树（前序，中序，后序）

   /**
     * 汉诺塔
     *
     * @param n      盘子的个数
     * @param start  开始的柱子
     * @param middle 中介柱子
     * @param end    结果柱子
     */
    public static void towerOfHanoi(int n, int start, int middle, int end) {
        if (n <= 1) {
            System.out.println(start + "----->" + end);
        } else {
            towerOfHanoi(n - 1, start, end, middle);
            System.out.println(start + "----->" + end);
            towerOfHanoi(n - 1, middle, start, end);
        }
    }

测试打印结果：

二叉树

 Node<String> root = new Node<>(null, null, null);

    /**
     * 中序访问树的所有节点
     */
    public void midOrderTraverse(Node root) {//逻辑
        if (root == null) {
            return;
        }
        //LDR
        midOrderTraverse(root.leftChild);//逻辑
        System.out.println("mid:" + root.data);//输出
        midOrderTraverse(root.rightChild);//逻辑
    }

    /**
     * 前序访问树的所有节点  
     */
    public void preOrderTraverse(Node root) {
        if (root == null) {
            return;
        }
        //DLR
        System.out.println("pre:" + root.data);
        preOrderTraverse(root.leftChild);
        preOrderTraverse(root.rightChild);
    }

    /**
     * 后序访问树的所有节点
     */
    public void postOrderTraverse(Node root) {
        if (root == null) {
            return;
        }
        //LRD
        postOrderTraverse(root.leftChild);
        postOrderTraverse(root.rightChild);
        System.out.println("post:" + root.data);
    }


    /**
     * 节点
     */
    public static class Node<T> {
        T data;
        Node<T> leftChild;
        Node<T> rightChild;

        public Node(T data, Node<T> leftChild, Node<T> rightChild) {
            this.data = data;
            this.leftChild = leftChild;
            this.rightChild = rightChild;
        }
    }