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

   /**
     * 汉诺塔
     *
     * @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 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 data;
        Node leftChild;
        Node rightChild;

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

前序   (DLR)

    若二叉树为空，则空操作返回，否则先访问跟结点，然后前序遍历左子树，再前序遍历右子树

   

 中序   (LDR)

        若树为空，则空操作返回，否则从根结点开始（注意并不是先访问根结点），
中序遍历根结点的左子树，然后是访问根结点，最后中序遍历右子树

后续    (LRD)

      若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点

 

注：上述只贴出了部分代码和图，可能需要有点基础的同学。