二叉树遍历

二叉树遍历

理解递归，可以参考：https://www.cnblogs.com/HuyuhaoSimple/p/14537995.html

package com.example.mybatis.binarytree.demo;

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


/**     前序遍历：ABDEGCF 中序遍历：DBGEACF 后序遍历：DGEBFCA
 * 第一层:A 第二层：B、C 第三层:D、E、F 第四层：G
 *          A
 *      B       C
 *   D      E        F
 *        G
 */
public  class Node {
    public String value;
    public Node left;
    public Node right;

    public Node() {
    }
    public Node(String value){
        this.value=value;
    }

    @Override
    public String toString() {
        return "Node{" +
                "value='" + value + '\'' +
                ", left=" + left +
                ", right=" + right +
                '}';
    }

    // 创建二叉树
    public static Node getNodeList(){
        Node a = new Node("A");
        Node b = new Node("B");
        Node c = new Node("C");
        Node d = new Node("D");
        Node e = new Node("E");
        Node f = new Node("F");
        Node g = new Node("G");
        a.left=b;
        a.right=c;
        b.left=d;
        b.right=e;
        c.right=f;
        e.left=g;
        return a;
    }

    public static void main(String [] args){
        Node nodeList = Node.getNodeList();
        System.out.println("二叉树："+nodeList);

        // 先序遍历
        List<String> listPre = Node.recursionPre(nodeList,null);
        System.out.println("先序遍历(方式一)："+listPre.toString());

        // 先序遍历
        List<String> listPre2 = Node.recursionPre(nodeList,null);
        System.out.println("先序遍历(方式二)："+listPre2.toString());

        // 中序遍历（也可以按照先序方式二写）
        List<String> listIn = Node.recursionIn(nodeList, null);
        System.out.println("中序遍历："+listIn);

        // 后序遍历（也可以按照先序方式二写）
        List<String> listPos = Node.recursionPos(nodeList, null);
        System.out.println("后续遍历："+listPos);

    }

    // 先序遍历（方式一） 注意： 存储节点值的集合要传递到下一个递归中，所以递归函数的参数中要有valueList集合
    public static List<String> recursionPre(Node head,List<String> valueList){
        // 第一次进来时创建集合（存放节点值），后面递归调用时就不用（也不能）再创建存节点值的集合了
        if (valueList==null){
            valueList = new ArrayList<>();
        }

        // 节点存在，将节点的值存入集合
        if (head!=null){
            // 前序遍历：A B D E G C F
            valueList.add(head.value);
        }
        if (head.left!=null){
            recursionPre(head.left,valueList);
        }
        if (head.right!=null){
            recursionPre(head.right,valueList);
        }

        return valueList;
    }

    // 先序遍历（方式二） 注意： 存储节点值的集合要传递到下一个递归中，所以递归函数的参数中要有valueList集合
    public static List<String> recursionPre2(Node head,List<String> valueList){
        if (head == null){
            return valueList;
        }
        // 第一次进来时创建集合（存放节点值），后面递归调用时就不用（也不能）再创建存节点值的集合了
        if (valueList==null){
            valueList = new ArrayList<>();
        }
        // 将节点的值存入集合
        valueList.add(head.value);
        recursionIn(head.left,valueList);
        recursionIn(head.right,valueList);
        return valueList;
    }

    // 中序遍历
    public static List<String> recursionIn(Node head,List<String> valueList){
        if (head == null){
            return valueList;
        }
        // 第一次进来时创建集合（存放节点值），后面递归调用时就不用（也不能）再创建存节点值的集合了
        if (valueList==null){
            valueList = new ArrayList<>();
        }
        // 将节点的值存入集合
        recursionIn(head.left,valueList);
        // 中序遍历：DBGEACF
        valueList.add(head.value);
        recursionIn(head.right,valueList);
        return valueList;
    }

    // 后序遍历
    public static List<String> recursionPos(Node head,List<String> valueList){
        if (head==null) {
            return valueList;
        }
        // 第一次进来时创建集合（存放节点值），后面递归调用时就不用（也不能）再创建存节点值的集合了
        if (valueList==null){
            valueList = new ArrayList<>();
        }
        recursionPos(head.left,valueList);
        recursionPos(head.right,valueList);
        // 后序遍历：DGEBFCA
        valueList.add(head.value);
        return valueList;
    }


}