二叉树-遍历（BFS、DFS）

对于二叉树的操作，首先要自己先建立一个二叉树的节点的类，然后给这个类配置一些基本的功能函数，比如添加左右节点，这样可以通过主函数来构建一棵树，然后再测试这棵树的遍历顺序，可以的话写一个二叉树的打印函数，打印出该节点以下二叉树的立体关系，并不是遍历顺序，因为二叉树不同的遍历顺序输出并不一样。

二叉树节点类设计：

/**
 * 二叉树节点
 */
public class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
     }
     public TreeNode addleft(int val){
          this.left = new TreeNode(val);
          return this.left;
     }
    public TreeNode addright(int val){
        this.right = new TreeNode(val);
        return this.right;
    }

}

二叉树的层序遍历（BFS）：

特点：用队列存储，外层循环记录层，内层循环遍历每一层的节点

借用一个队列，首先将首节点放入队列，然后将其出队放入一个数组中，然后将其左右子节点放入队列，循环清空队列，将出队的元素放入一个数组，这样循环下去每次得到的数组就是二叉树不同层的所有元素，从头到尾放入一个大数组就是层序遍历的结果。

class cengxu {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(queue.size()>0){
            int size = queue.size();
            ArrayList<Integer> tem = new ArrayList<Integer>();
            for(int i=0;i<size;i++){
                TreeNode t = queue.remove();
                tem.add(t.val);
                if(t.left!=null)
                {
                    queue.add(t.left);
                }
                if(t.right!=null){
                    queue.add(t.right);
                }
            }
            res.add(tem);
        }
        return res;

    }

二叉树的先序、中序、后序遍历（DFS）：

特点：用栈存储状态，用递归实现的话，相当于用程序栈记录了。

先序遍历：

/**
 * 二叉树的先序遍历
 */
class xianxu{
    public void recursionPreorderTraversal(TreeNode root) {
        if (root != null) {
            System.out.print(root .val);
            recursionPreorderTraversal(root.left);
            recursionPreorderTraversal(root.right);
        }else{
            return 0;
        }
    }
    public static void main(String[] args){
        TreeNode head = new TreeNode(3);
        TreeNode rl = head.addleft(9);
        TreeNode rr = head.addright(20);
        rr.addleft(15);
        rr.addright(7);
        xianxu x = new xianxu();
        x.recursionPreorderTraversal(head);
    }
}

中序遍历：

/**
 * 二叉树的中序遍历
 */
class zhongxu{
    public static void recursionMiddleorderTraversal(TreeNode root) {
        if (root != null) {
            recursionMiddleorderTraversal(root.left);
            System.out.print("输出节点：" + root.val);
            recursionMiddleorderTraversal(root.right);
        }else{
            return 0;
        }
    }
    public static void main(String[] args){
        TreeNode head = new TreeNode(3);
        TreeNode rl = head.addleft(9);
        TreeNode rr = head.addright(20);
        rr.addleft(15);
        rr.addright(7);
        zhongxu z = new zhongxu();
        z.recursionMiddleorderTraversal(head);
    }
}

后序遍历：

/**
 * 二叉树的后序遍历
 */
class houxu{
    /** —————————— 后序遍历：递归 —————————— */
    public static void recursionPostorderTraversal(TreeNode root) {
        if (root != null) {
            recursionPostorderTraversal(root.left);
            recursionPostorderTraversal(root.right);
            System.out.print("输出节点：" + root.val);
        }else{
            return 0;
        }
    }
    public static void main(String[] args){
        TreeNode head = new TreeNode(3);
        TreeNode rl = head.addleft(9);
        TreeNode rr = head.addright(20);
        rr.addleft(15);
        rr.addright(7);
        houxu h = new houxu();
        h.recursionPostorderTraversal(head);
    }
}