首先访问根结点，然后前序遍历其左子树，最后前序遍历其右子树。 遍历结果：A B D H I E J C F G

首先中序遍历根结点的左子树，然后访问根结点，最后中序遍历其右子树。 遍历结果：H D I B J E A F C G

首先后序遍历根结点的左子树，然后后序遍历根结点的右子树，最后访问根结点。 遍历结果：H I D J E B F G C A

首先中序遍历根结点的左子树，然后访问根结点，最后中序遍历其右子树。 遍历结果：B D C A E H G K F

我们从根节点 A 看起，遍历 A 的左子树。 A 的左子树存在，找到 B，此时 B 看做根节点，遍历 B 的左子树。 B 的左子树不存在，返回 B，根据 [左根右] 的遍历规则，记录 B，遍历 B 的右子树。 B 的右子树存在，找到 C，此时 C 看做根节点，遍历 C 的左子树。 C 的左子树存在，找到 D。由于 D 是叶子节点，无左子树，记录 D。D 无右子树，返回 C，根据 [左根右] 的遍历规则，记录 C，遍历 C 的右子树。 C 的右子树不存在，返回 B，B 的右子树遍历完，返回 A。A 的左子树遍历完毕，根据 [左根右] 的遍历规则，记录 A，遍历 A 的右子树。

A 的右子树存在，找到 E，此时 E 看做根节点，遍历 E 的左子树。 E 的左子树不存在，返回 E，根据 [左根右] 的遍历规则，记录 E，遍历 E 的右子树。 E 的右子树存在，找到 F，此时 F 看做根节点，遍历 F 的左子树。 F 的左子树存在，找到 G，此时 G 看做根节点，遍历 G 的左子树。 G 的左子树存在，找到 H，由于 H 是叶子节点，无左子树，记录 H。H 无右子树，返回 G，根据 [左根右] 的遍历规则，记录 G，遍历 G 的右子树。 G 的右子树存在，找到 K，由于 K 是叶子节点，无左子树，记录 K。K 无右子树，返回 G，根据 [左根右] 的遍历规则，记录 F，遍历 F的右子树。 F 的右子树不存在，返回 F，E 的右子树遍历完毕，返回 A。A 的右子树也遍历完毕。 遍历结果：B D C A E H G K F

首先访问根结点，然后前序遍历其左子树，最后前序遍历其右子树。 遍历结果：A B D E G H C F

首先中序遍历根结点的左子树，然后访问根结点，最后中序遍历其右子树。 遍历结果：D B G E H A C F

首先后序遍历根结点的左子树，然后后序遍历根结点的右子树，最后访问根结点。 遍历结果：D G H E B F C A

遍历结果：A B C D E F G H

前序、中序、后序是针对根节点而言的，左右子树的遍历顺序不变。前序就是根节点最先遍历，然后左右子树。中序就是根节点放在中间遍历。后序就是把根节点放在最后遍历。

二叉树的深度优先遍历的非递归做法是采用栈 (stack)。 首先访问根结点，然后前序遍历其左子树，最后前序遍历其右子树。

二叉树的深度优先遍历的非递归做法是采用栈 (stack)。 首先中序遍历根结点的左子树，然后访问根结点，最后中序遍历其右子树。

二叉树的深度优先遍历的非递归做法是采用栈 (stack)。 首先后序遍历根结点的左子树，然后后序遍历根结点的右子树，最后访问根结点。