递归的思路非常简单，只需调整打印位置即可
    非递归思路
    （1）前序遍历
    使用一个栈，先将根节点放入栈，然后出栈，然后分别按照 右节点、左节点的顺序放入栈，继续循环出栈
    （2）中序遍历
    使用一个栈，先不断的遍历最左侧的节点放入栈，如果左边为null了则出栈null的父节点，然后将父节点右子树做相同的操作，最后直到栈为空
    （3）后序遍历
    使用两个栈，先将根节点入栈，然后出栈并放入栈2，然后放入左节点，右节点然后再出栈放入栈2，最后将栈2出栈打印即可

    1. import java.util.*;
    2. /*
    3. public class TreeNode {
    4.     int val = 0;
    5.     TreeNode left = null;
    6.     TreeNode right = null;
    7.     public TreeNode(int val) {
    8.         this.val = val;
    9.     }
    10. }*/
    11. public class TreeToSequence {
    13.     public int[][] convert(TreeNode root) {
    14.         List<Integer> preResult = new ArrayList<>();
    15.         List<Integer> midResult = new ArrayList<>();
    16.         List<Integer> afterResult = new ArrayList<>();
    17.         prePrint(preResult, root);
    18.         midPrint(midResult, root);
    19.         afterPrint(afterResult, root);
    21.          int[][] result = new int[3][preResult.size()];
    22.          for (int i=0; i< preResult.size(); i++) {
    23.              result[0][i] = preResult.get(i);
    24.          }
    25.          for (int i=0; i< midResult.size(); i++) {
    26.              result[1][i] = midResult.get(i);
    27.          }
    28.          for (int i=0; i< afterResult.size(); i++) {
    29.              result[2][i] = afterResult.get(i);
    30.          }
    31.         return result;
    32.     }
    34.      private void prePrint(List<Integer> preResult,TreeNode node) {
    35.         if (node == null) {
    36.             return;
    37.         }
    38.         Stack<TreeNode> stack = new Stack<TreeNode>();
    39.         stack.push(node);
    40.         while (!stack.isEmpty()) {
    41.             TreeNode pop = stack.pop();
    42.             preResult.add(pop.val);
    43.             if (pop.right != null) {
    44.                 stack.push(pop.right);
    45.             }
    46.             if (pop.left != null) {
    47.                 stack.push(pop.left);
    48.             }
    49.         }
    50.     }
    52.     private void midPrint(List<Integer> midResult, TreeNode node) {
    53.         if (node == null) {
    54.             return;
    55.         }
    56.         Stack<TreeNode> stack = new Stack<TreeNode>();
    57.         stack.push(node);
    58.         TreeNode cur = node;
    59.         while (!stack.isEmpty()) {
    60.             if (cur != null) {
    61.                 if (cur.left != null) {
    62.                      stack.push(cur.left);
    63.                      cur = cur.left;
    64.                 } else {
    65.                     cur = null;
    66.                 }
    67.             } else {
    68.                 TreeNode pop = stack.pop();
    69.                 midResult.add(pop.val);
    70.                 if (pop.right != null) {
    71.                     stack.push(pop.right);
    72.                     cur = pop.right;
    73.                 } else {
    74.                     cur = null;
    75.                 }
    76.             }
    77.         }
    78.     }
    80.     private void afterPrint(List<Integer> afterResult, TreeNode node) {
    81.         if (node == null) {
    82.             return;
    83.         }
    84.         Stack<TreeNode> s1 = new Stack<TreeNode>();
    85.         Stack<Integer> s2 = new Stack<Integer>();
    86.         s1.push(node);
    87.         while (!s1.isEmpty()) {
    88.             TreeNode pop = s1.pop();
    89.             s2.push(pop.val);
    90.             if (pop.left != null) {
    91.                 s1.push(pop.left);
    92.             }
    93.             if (pop.right != null) {
    94.                 s1.push(pop.right);
    95.             }
    96.         }
    97.         while (!s2.isEmpty()) {
    98.             afterResult.add(s2.pop());
    99.         }
    100.     }
    102.     /**  下面为递归方式 **
    103.     private void prePrint(List<Integer> preResult,TreeNode node) {
    104.         if (node == null) {
    105.             return;
    106.         }
    107.         preResult.add(node.val);
    108.         prePrint(preResult, node.left);
    109.         prePrint(preResult, node.right);
    110.     }
    112.     private void midPrint(List<Integer> midResult, TreeNode node) {
    113.         if (node == null) {
    114.             return;
    115.         }
    116.         midPrint(midResult, node.left);
    117.         midResult.add(node.val);
    118.         midPrint(midResult, node.right);
    119.     }
    121.     private void afterPrint(List<Integer> afterResult, TreeNode node) {
    122.         if (node == null) {
    123.             return;
    124.         }
    125.         afterPrint(afterResult, node.left);
    126.         afterPrint(afterResult, node.right);
    127.         afterResult.add(node.val);
    128.     }
    129.     **/
    130. }

    image.gif