数据结构之二叉树

概念

在树形结构中最重要的就是二叉树，很多经典的算法与数据结构其实都是通过二叉树发展而来

二叉树	1、一种特殊的树形结构，每个节点至多只有两颗子树 2、在二叉树的第N层上至多有2^(N-1)个结点。 3、最多有2^N-1个结点个数
全二叉树	除最后一层外，其他的结点个数必须达到最大，并且最后一层结点都连续靠左排列
满二叉树	除叶子结点外，每个结点都有左右两个子结点

树形结构的存储

两种存储方式：

1. 数组，性能是高效的，也不需要开额外的指针
2. 链表，稀疏树采用数组浪费空间，链表节省空间，访问慢

基于数组存储：

利用数组下标。假设A为i，则左节点B=2i, 右节点C=2i+1，依次类推

基于链表存储：

class TreeNode<T>{
    T data;
    TreeNode leftNode;
    TreeNode rightNode;
}

如何选择存储方式？分析下图
图1 图2：

图1：可采用数组或链表存储，推荐数组，无空间浪费访问快
图2：发现很多节点只有一个节点，采用数组存储浪费空间，推荐采用链表存储
所以如果是一课完全二叉树的话我们可以用数组来实现，这也是为什么还要分一个完全二叉树出来的根本原因

二叉树的遍历

二叉树的遍历分为两类，一类是深度优先遍历，一类是广度优先遍历

1. 深度优先遍历

深度优先遍历有三种方式，先序（先根次序）、中序（中根次序）和后序（后根次序）遍历。

2. 广度优先遍历

广度优先周游的方式是按层次从上到下，从左到右的逐层访问，不难想到，可以利用一个队列来实现。基

四种遍历方式： 【重要口诀：根节点输出！子树】

前序	根 左 右	ABCDEFGHK
中序	左 根 右	BDCAEHGKF
后序	左 右 根	DCBHKGFEA
层次	层次遍历即为从上到下，从左到右依次访问二叉树的每个结点，借助队列实现	ABECFDGHK

节点定义

public class MyTreeNode<T> {
    public T data;
    public MyTreeNode<T> left;
    public MyTreeNode<T> right;
    public MyTreeNode(T data, MyTreeNode<T> left, MyTreeNode<T> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }
}

构建上图的树

    public static BinaryTree builder() {
        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.root = A;
        return binaryTree;
    }

前中后序遍历

public class BinaryTree {

    MyTreeNode root; // 树的根节点

    /**
     * 前序遍历：根(输出) 左 右 时间复杂度？O(n) N^2 O(2*n)=>O(n);
     */
    public void pre(MyTreeNode root) {
        print(root); // 根
        if (root.left != null) pre(root.left); // 左
        if (root.right != null) pre(root.right); // 右
    }

    /**
     * 中序遍历：左 根(输出)  右
     */
    public void in(MyTreeNode root) {
        if (root.left != null) in(root.left); // 左
        print(root); // 根
        if (root.right != null) in(root.right); // 右
    }

    /**
     * 后序遍历：左  右 根(输出)
     */
    public void post(MyTreeNode root) {
        if (root.left != null) post(root.left); // 左
        if (root.right != null) post(root.right); // 右
        print(root); // 根
    }

	/**
     * 层次遍历
     * 算法思想：
     * （1）我们定义一个队列，先将根结点入队；
     * （2）当前结点是队头结点，将其出队并访问；
     * （3）若当前结点的左结点不为空将左结点入队；若当前结点的右结点不为空将其入队即可。
     */
    private void level(MyTreeNode root) {
        LinkedListQueue<MyTreeNode> queue = new LinkedListQueue<MyTreeNode>(100);
        // 添加元素到队尾
        queue.add(root);
        while (!queue.isEmpty()) {
            // 取出队头元素
            MyTreeNode head = queue.poll();
            print(head);
            // 将左节点添加到队列
            if (head.left != null) queue.add(head.left);
            // 将右边节点添加队列
            if (head.right != null) queue.add(head.right);
        }
    }

    public void print(MyTreeNode node) {
        System.out.print(node.data);
    }
}

测试用例

    public static void main(String[] args) {
        BinaryTree binaryTree = builder();
        MyTreeNode A = binaryTree.root;
        System.out.println("前序遍历");
        binaryTree.pre(A);
        System.out.println();

        System.out.println("中序遍历");
        binaryTree.in(A);
        System.out.println();

        System.out.println("后序遍历");
        binaryTree.post(A);
        System.out.println();

        System.out.println("层次遍历");
        binaryTree.level(A);
        System.out.println();
    }

运行结果

前序遍历
ABCDEFGHK
中序遍历
BDCAEHGKF
后序遍历
DCBHKGFEA
层次遍历
ABECFDGHK