数据结构与算法-二叉树，前序，后续，中序遍历

树的几个重要元素
1，节点：树里面的元素
2，父子关系：节点之间相连的关系
3，子树：当节点大于1是，其余不相交的节点的集合称作子树
4，度：一个节点拥有子树的数量称作度
5，孩子：节点的子节点
6，双亲节点
7，兄弟节点
9，森林：由N个不相交的树组成

节点的高度：节点到叶子节点的最长路径
节点的深度：根节点到该节点的边个数
节点的层数：节点的深度+1
树的高度：根节点的高度

二叉树
1，每个节点最多有两个节点
2，第N层最多有2^(N-1)个节点
满二叉树：除叶子结点外，每个结点都有左右两个子结点。
完全二叉树：除最后一层外，其他的结点个数必须达到最大，并且最后一层结点都连续靠左排列。

执行结果如下：

堆就是一个完全二叉树，主要原因是想借用数组，数组开辟的是连续的空间，可以使用CPU的缓存行

package edu.tree;

/**
 * @author: LHT
 * @date: 2020/12/28 17:53
 */
public class BinaryTree {
    /**
     * 前序遍历  根 左 右
     *
     * @param root
     */
    public void pre(MyTreeNode root) {
        print(root);
        if (root.getLeft() != null) {
            //将左边看做一个新树，根左右
            pre(root.getLeft());
        }
        if (root.getRight() != null) {
            pre(root.getRight());
        }
    }

    /**
     * 中序遍历
     * 左中右
     *
     * @param root
     */
    public void in(MyTreeNode root) {

        if (root.getLeft() != null) {
            //将左边看做一个新树，根左右
            in(root.getLeft());
        }
        print(root);
        if (root.getRight() != null) {
            in(root.getRight());
        }
    }

    /**
     * 后续遍历
     * 左右中
     * O(n)
     *
     * @param root
     */
    public void post(MyTreeNode root) {

        if (root.getLeft() != null) {
            //将左边看做一个新树，根左右
            post(root.getLeft());
        }
        if (root.getRight() != null) {
            post(root.getRight());
        }
        print(root);
    }

    public void print(MyTreeNode node) {
        System.out.print(node.getData() + "  ");
    }

    public static void main(String[] args) {
        MyTreeNode D = new MyTreeNode('D', null, null);
        MyTreeNode H = new MyTreeNode('H', null, null);
        MyTreeNode K = new MyTreeNode('K', null, null);
        MyTreeNode C = new MyTreeNode('C', D, null);
        MyTreeNode G = new MyTreeNode('G', H, K);
        MyTreeNode B = new MyTreeNode('B', null, C);
        MyTreeNode F = new MyTreeNode('F', G, null);
        MyTreeNode E = new MyTreeNode('E', null, F);
        MyTreeNode A = new MyTreeNode('A', B, E);
        BinaryTree binaryTree = new BinaryTree();
        binaryTree.pre(A);
        System.out.print("前");
        System.out.println();
        binaryTree.in(A);
        System.out.println("中");
        binaryTree.post(A);
        System.out.println("后");

    }
}

/**
 * 二叉树定义
 */
class MyTreeNode {

    char data;
    private MyTreeNode left;
    private MyTreeNode right;

    public MyTreeNode(char data, MyTreeNode left, MyTreeNode right) {
        super();
        this.data = data;
        this.left = left;
        this.right = right;
    }

    public char getData() {
        return data;
    }

    public void setData(char data) {
        this.data = data;
    }

    public MyTreeNode getLeft() {
        return left;
    }

    public void setLeft(MyTreeNode left) {
        this.left = left;
    }

    public MyTreeNode getRight() {
        return right;
    }

    public void setRight(MyTreeNode right) {
        this.right = right;
    }
}