二叉树前序、中序、后序遍历

1、定义：前序、中序、后序的概念

前序遍历： 
    1.访问根节点 
    2.前序遍历左子树 
    3.前序遍历右子树 

中序遍历： 
    1.中序遍历左子树 
    2.访问根节点 
    3.中序遍历右子树 

后序遍历： 
    1.后序遍历左子树 
    2.后序遍历右子树 
    3.访问根节点

 

2、算法图示

前序输出：C A B E F D H G
中序输出：B A F E C H D G
后序输出：B F E A H G D C

 

3、算法实现

稍后更新

定义节点：

 

1. package erchashu_bianli;

2.  

3. /**

4. *

5. * @author zhengchao

6. */

7. public class Node {

8.  

9. public int value;

10.  

11. public Node left;

12.  

13. public Node right;

14.  

15. public Node(int value){

16. this.value = value;

17. }

18. }

定义三个遍历的方法：

 

1. package erchashu_bianli;

2.  

3. /**

4. *

5. * @author zhengchao

6. */

7. public class OrderUtil {

8.  

9. public static void preOrder(Node node){

10. if(node != null){

11. System.out.print(node.value);//先中间，直接输出

12. preOrder(node.left); //再左边

13. preOrder(node.right); //最后左边

14. }

15. }

16.  

17. public static void middleOrder(Node node){

18. if(node != null){

19. middleOrder(node.left); //先左边

20. System.out.print(node.value); //再中间直接输出

21. middleOrder(node.right); //最后右边

22. }

23. }

24.  

25. public static void lastOrder(Node node){

26. if(node != null){

27. lastOrder(node.left); //先左边

28. lastOrder(node.right); //再右边

29. System.out.print(node.value); //最后输出中间

30. }

31. }

32.  

33. }

测试案例：首先需要构造二叉树的数据结构，再进行遍历

 

                           1

                2                    3

           4       5            6       7

      8      9

 

 

1. package erchashu_bianli;

2.  

3. import java.util.*;

4.  

5. /**

6. *

7. * @author zhengchao

8. */

9. public class TestNode {

10.  
11.  

12. private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

13. private static List<Node> nodeList = null;

14.  

15. //有没有发现初始化构建这个二叉树的数据结构是最难的

16. public void createErChaTree() {

17. nodeList = new LinkedList<Node>();

18. // 将一个数组的值依次转换为Node节点

19. for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {

20. nodeList.add(new Node(array[nodeIndex]));

21. }

22. // 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树

23. for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {

24. // 左孩子

25. nodeList.get(parentIndex).left = nodeList.get(parentIndex * 2 + 1);

26. // 右孩子

27. nodeList.get(parentIndex).right = nodeList.get(parentIndex * 2 + 2);

28. }

29. // 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理

30. int lastParentIndex = array.length / 2 - 1;

31. // 左孩子

32. nodeList.get(lastParentIndex).left = nodeList.get(lastParentIndex * 2 + 1);

33. // 右孩子,如果数组的长度为奇数才建立右孩子

34. if (array.length % 2 == 1) {

35. nodeList.get(lastParentIndex).right = nodeList.get(lastParentIndex * 2 + 2);

36. }

37. }

38.  

39. public static void main(String[] args){

40.  

41. TestNode binTree = new TestNode();

42. binTree.createErChaTree();

43.  

44. Node root = nodeList.get(0);

45.  

46. System.out.println("先序遍历：");

47. OrderUtil.preOrder(root);

48. System.out.println();

49.  

50. System.out.println("中序遍历：");

51. OrderUtil.middleOrder(root);

52. System.out.println();

53.  

54. System.out.println("后序遍历：");

55. OrderUtil.lastOrder(root);

56. }

57. }

输出结果：

 

1. run:

2. 先序遍历：

3. 124895367

4. 中序遍历：

5. 849251637

6. 后序遍历：

7. 894526731成功构建 (总时间: 0 秒)