二叉树前序、中序、后序、层次遍历、Z字形遍历等方式《二叉树学习一》

一、遍历方式

方式	介绍	结果
前序遍历	前序遍历首先访问根节点，然后遍历左子树，最后遍历右子树。	FBADCEGIH
中序遍历	中序遍历是先遍历左子树，然后访问根节点，然后遍历右子树。	ABCDEFGHI
后序遍历	后序遍历是先遍历左子树，然后遍历右子树，最后访问树的根节点。	ACEDBHIGF
正序层次遍历	一层一层访问	F BG ADI CEH
倒序层次遍历	从每一层最后一个访问	F GB IDA HEC
Z自行层次遍历	一层正序，一层倒叙	F GB ADI HEC

2、二叉树结构体生成

/***
 * 二叉树基本的方法
 */
public class TreeNode {
   

    private String val;

    private TreeNode left;

    private TreeNode right;

    TreeNode(String x) {
   
        val = x;
    }

    public String getVal() {
   
        return val;
    }

    public TreeNode getLeft() {
   
        return left;
    }

    public TreeNode getRight() {
   
        return right;
    }

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


}

3. 前序遍历

1、前序遍历递归法(最简单的方式)

二叉树的定义本身就是一个递归的过程，二叉树的根节点的左右孩子又分别是二叉树，所以在遍历的过程中，使用递归的思想十分简单。

首先访问当前节点，如果当前节点为空则返回，不为空则将当前节点的值放入结果列表，然后调用自身遍历自己的左孩子和右孩子。

package com.hcg.tree.bianli;

import com.hcg.tree.TreeNode;
import com.sun.org.apache.regexp.internal.RE;

import java.util.ArrayList;
import java.util.List;

public class HeadFind {
   

	 
	
    /***
     * 最后生成的结果方法
     * @param root
     * @return
     */
    public static List<String> findHead(TreeNode root) {
   
        List<String> result = new ArrayList<>();
        headDiGui(root, result);
        return result;
    }

	 /***
     * 循环递归方法
     * @param root
     * @param result
     */
    public static void headDiGui(TreeNode root, List<String> result) {
   
        if (root == null) {
   
            return;
        }
        result.add(root.getVal());
        headDiGui(root.getLeft(), result);
        headDiGui(root.getRight(), result);
    }

 /***
     * 生成一个二叉树的方法
     * @return
     */    
public static TreeNode oneGetter() {
   

        TreeNode d = new TreeNode("D", new TreeNode("C", null, null), new TreeNode("E", null, null));
        TreeNode b = new TreeNode("B", new TreeNode("A", null, null), d);
        TreeNode i = new TreeNode("I", new TreeNode("H", null, null), null);
        TreeNode g = new TreeNode("G", null, i);
        TreeNode root = new TreeNode("F", b, g);
        return root;
    }

     /***
     * main方法
     * @param args
     */
    public static void main(String[] args) {
   
        TreeNode root = oneGetter();
        List<String> result = findHead(root);
        for (String one : result) {
   
            System.out.println(one);
        }
    }
}

前序遍历结果是：FBADCEGIH

2、前序非递归遍历二叉树借助栈实现

package com.hcg.tree.bianli;


import com.hcg.tree.TreeNode;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/***
 * 用非递归（借助栈）的方式实现二叉树的前序遍历
 */
public class HeadFindStack {
   

    /***
     * 生成一个二叉树的方法
     * @return
     */
    public static TreeNode oneGetter() {
   

        TreeNode d = new TreeNode("D", new TreeNode("C", null, null), new TreeNode("E", null, null));
        TreeNode b = new TreeNode("B", new TreeNode("A", null, null), d);
        TreeNode i = new TreeNode("I", new TreeNode("H", null, null), null);
        TreeNode g = new TreeNode("G", null, i);
        TreeNode root = new TreeNode("F", b, g);
        return root;
    }

    /***
     * 最后生成的结果方法
     * @param root
     * @return
     */
    public static List<String> headStack(TreeNode root) {
   
        List<String> result = new ArrayList<>();
        if (root == null) {
   
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        // root不为空先把根节点放入list
        result.add(root.getVal());
        //先不管root的两个子节点是否为空，先放入栈中,注意先放入右边的子节点，因为栈是先进后出
        stack.push(root.getRight());
        stack.push(root.getLeft());
        while (stack.isEmpty() == false) {
   
            TreeNode node = stack.pop();
            if (node != null) {
   
                //result放入根节点
                result.add(node.getVal());
                //先放右边节点
                stack.push(node.getRight());
                //后放左边节点
                stack.push(node.getLeft());
            }
        }
        return result;
    }

    /***
     * main方法
     * @param args
     */
    public static void main(String[] args) {
   
        TreeNode root = oneGetter();
        List<String> result = headStack(root);
        for (String one : result) {
   
            System.out.println(one);
        }
    }
}

4. 中序遍历

4.1. 中序遍历递归实现

   /***
     * 最后生成的结果方法
     * @param root
     * @return
     */
    public static List<String> findMid(TreeNode root) {
   
        List<String> result = new ArrayList<