二叉树的遍历

一 概述

树的遍历可分为两类：

1. 深度优先遍历（DFS-Depth First Search）：深度优先遍历是对于每一个可能的分支路径深入到不能再深入为止，而且每一个节点只能访问一次，对于二叉树的深度遍历可以分为三种：

• 先序遍历：先访问树的根，然后遍历左子树，最后遍历右子树。
• 中序遍历：先遍历左子树，然后访问根，最后遍历右子树。
• 后序遍历：先遍历左子树，然后遍历右子树，最后访问根。

2. 广度优先遍历（BFS-Breath First Search）：广度优先遍历也可以称为层序遍历，从上往下对每一层一次访问，在每一层中，从左往右访问结点，访问完一层就进入下一层，直至所有结点均被访问。

二 基于Java语言实现树的结构的定义与树节点初始化

           

1. 树结构的定义

package main.BinaryTree;

import java.util.List;

public class TreeNode {

    String value;
    TreeNode left;
    TreeNode right;

    public TreeNode(String value) {

        this.value = value;
    }

    public TreeNode(String value, TreeNode left, TreeNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }
}

2.树节点的初始化

static TreeNode createBinaryTree() {

        //定义节点
        TreeNode G = new TreeNode("G");
        TreeNode D = new TreeNode("D");
        TreeNode E = new TreeNode("E", G, null);
        TreeNode B = new TreeNode("B", D, E);
        TreeNode H = new TreeNode("H");
        TreeNode I = new TreeNode("I");
        TreeNode F = new TreeNode("F", H, I);
        TreeNode C = new TreeNode("C", null, F);

        // 构造根节点
        TreeNode root = new TreeNode("A", B, C);
        return root;
    }

三 基于深度优先遍历实例

1. 先序遍历

   //先序遍历，即先访问根节点,然后遍历左子树，最后遍历右子树
    public void preOrder(TreeNode treeNode) {
        if (null != treeNode) {

            System.out.print(treeNode.value);

            if (null != treeNode.left) {
                preOrder(treeNode.left);
            }

            if (null != treeNode.right) {
                preOrder(treeNode.right);
            }
        }
    }

先序遍历：ABDEGCFHI

2. 中序遍历

//中序遍历，即先遍历左子树，然后访问根节点，最后遍历右子树
    public void midOrder(TreeNode treeNode) {
        if (null != treeNode) {

            if(null != treeNode.left) {
                midOrder(treeNode.left);
            }

            System.out.print(treeNode.value);

            if(null != treeNode.right) {
                midOrder(treeNode.right);
            }
        }
    }

中序遍历：DBGEACHFI

3. 后序遍历

  //后序遍历，即先遍历左子树，然后遍历右子树，最后访问根节点
    public void postOrder(TreeNode treeNode) {

        if(null != treeNode) {

            if(null != treeNode.left){
                postOrder(treeNode.left);
            }

            if(null != treeNode.right){
                postOrder(treeNode.right);
            }

            System.out.print(treeNode.value);
        }
    }

后序遍历：DGEBHIFCA

四 基于广度优先遍历实例

层序遍历

public void breathOrder(TreeNode treeNode) {

        if (null != treeNode) {

            LinkedList<TreeNode> linkedList = new LinkedList<>();
            linkedList.add(treeNode);
            TreeNode currentNode;

            while (!linkedList.isEmpty()) {

                currentNode = linkedList.poll();
                System.out.print(currentNode.value);

                if (null != currentNode.left) {
                    linkedList.add(currentNode.left);
                }

                if (null != currentNode.right) {
                    linkedList.add(currentNode.right);
                }
            }
        }
    }

层序遍历：ABCDEFGHI

五 森林和树遍历顺序的对应关系

树	二叉树	森林
先根遍历	先序遍历	先根遍历
后根遍历	中序遍历	后根遍历