Java数据结构之二叉树

一、树形结构

（一）树的概念

树是一种非线性的数据结构，它是由n（n >= 0）个有限节点组成的一个具有层次关系的集合，之所以称之为树，就是因为它像一棵倒挂着的树，即跟朝上，叶朝下，，它具有以下的特点：

1. 有一个特殊的节点，称为根节点，根节点没有前驱节点
2. 除根节点外，其余节点被分成M（M > 0）个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti（1 <= i <= m）又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继
3. 树是递归定义的

注意：

1. 树形结构中，子树之间不能有交集
2. 除了根节点外，每个节点有且只有一个父节点
3. 一棵N个节点的树有N - 1条边

（二）树中的众多基本概念

重要概念

1. 节点的度：一个节点含有子树的个数称为该节点的度；
2. 树的度：一棵树中，所有节点度的最大值称为树的度；
3. 叶子节点或终端节点：度为0的节点称为叶节点；
4. 双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
5. 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
6. 根节点：一棵树中，没有双亲节点的节点；
7. 节点的层次：从根节点开始定义起，根为第1层，根的子节点为第2层，以此类推
8. 树的高度或深度：树中节点的最大层次；

只需了解的概念

1. 非终端节点或分支节点：度不为0的结点；
2. 兄弟结点：具有相同父结点的结点互称为兄弟结点；
3. 堂兄弟节点：双亲在同一层的结点互为堂兄弟；
4. 节点的祖先：从根到该结点所经分支上的所有结点；
5. 子孙：以某结点为根的子树中任一结点都称为该结点的子孙。
6. 森林：由m（m>=0）棵互不相交的树组成的集合称为森林

（三）树的表示形式（了解）

树的结构相比较线性表会复杂一些，且并不是只有一种表示方法。比如：双亲表示法，孩子表示法，孩子双亲表示法，孩子兄弟表示法等等，我们只简单介绍其中最常用的孩子兄弟表示法

//节点的形式
class Node {
        int val;
        Node firstChild;
        Node nextBrother;
    }

树可以应用于文件系统管理等结构

二、二叉树（重点）

（一）概念

一棵二叉树是结点的一个有限集合，该集合：

1. 或者为空
2. 或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成

需要知道的是：

1. 二叉树不存在度大于 2 的节点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

（二）两种特殊的二叉树

1.满二叉树

满二叉树：一棵每层的节点都达到了最大值的二叉树，换言之，如果一棵树的层次为K,且节点总数为2 ^ k - 1，则它就是满二叉树

2.完全二叉树

完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是从满二叉树中引出来的，对于深度为K的，有n个节点的二叉树，当且仅当其每一个节点都与深度为K的满二叉树中编号从0至n - 1的节点一一对应时称之为完全二叉树，由此可知，满二叉树是一种特殊的完全二叉树

（三）二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层最多有2 ^ (i - 1)(i > 0)个节点
2. 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是x ^ k - 1 (k>=0)
3. 对任何一棵二叉树,如果其叶结点个数为 n0, 度为2的非叶结点个数为n2,则有n0＝n2＋1
4. 具有n个结点的完全二叉树的深度k为 log(n + 1)上取整
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i
   的结点有:

• 若i > 0，双亲序号为：(i - 1) /2;i == 0,i为根节点编号，无双亲节点
• 若2 * i + 1 < n，左孩子序号为: 2 * i + 1，否则无左孩子
• 若2 * i + 2 < n，右孩子序号为：2 * i + 2，否则无右孩子

（四）二叉树的存储

二叉树的存储结构分为：顺序存储和类似于链表的链式存储
顺序存储我们主要是在优先级队列（堆）应用
二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式，具体如下：

//孩子表示法
class TreeNode {
    int val;
    TreeNode left; //左孩子的引用
    TreeNode right; //右孩子的引用
}

//孩子双亲表示法
class TreeNode {
    int val;
    TreeNode left; //左孩子的引用
    TreeNode right; //右孩子的引用
    TreeNode prent; //当前节点的根节点的引用
}

孩子双亲表示法在平衡树的地方应用较多，而一般情况下都是使用孩子表示法来构建二叉树

（五）二叉树的基本操作

1.说明

二叉树的创建很简单，但是难就难在操作上，我们为了简便，先自己手动创建一个简陋的二叉树的结构，着重介绍二叉树的操作，先创建一棵二叉树

public class MyBinaryTree {

    public static class TreeNode {
        public char val;
        public TreeNode left;//左孩子的引用
        public TreeNode right;//右孩子的引用

        public TreeNode(char val) {
            this.val = val;
        }
    }

    public static int nodeSize;


    /**
     * 创建一棵二叉树 返回这棵树的根节点
     *
     * @return
     */
    public TreeNode createTree() {
        TreeNode root = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        root.left = B;
        root.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        return root;
    }
}

这棵二叉树的图形就是这样的：

注意：上述代码并不是创建二叉树的方式
我们有前面的概念可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照递归实现的

2.二叉树的遍历

（1）前中后序遍历

遍历是最简单，也是最快理解二叉树的结构的操作。遍历（Traversal）就是指沿着某条搜索路线，依次对树中每个节点均做一次且仅做一次的访问。访问节点所做的操作依赖于具体的应用问题（比如：打印节点内容、节点内容 + 1）。 遍历是二叉树上最重要的操作之一，是二叉树进行其他运算的基础

关于二叉树的遍历，我们做出了约定。根据遍历根节点的先后次序有以下遍历方式：

• NLR：前序遍历（Preorder Traversal 也叫先序遍历）——访问根节点-> 根的左子树 -> 根的右子树
• LNR：中序遍历（Inorder Traversal）——根的左子树-> 根节点 -> 根的右子树
• LRN：后序遍历（Postorder Traversal）——根的左子树-> 根的右子树 -> 根节点

代码示例：

// 前序遍历
    public void preOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

    // 中序遍历
    void inOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        preOrder(root.left);
        System.out.print(root.val + " ");
        preOrder(root.right);
    }

    // 后序遍历
    void postOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        preOrder(root.left);
        preOrder(root.right);
        System.out.print(root.val + " ");
    }

我们通过画图来理解先序遍历，中序和后序类似

先序遍历结果：A B D E C F G
中序遍历结果：D B E A F C G
后序遍历结果：D E B F G C A

（2）层序遍历

层序遍历：除了先序，中序，后序遍历外，还可以对二叉树进行层序遍历。顾名思义，就是自上而下，从左到右逐层对二叉树的节点进行访问

代码示例：

//需要借助一个队列
void levelOrder(TreeNode root) {
    if(root == null) {
        return;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while(!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        System.out.print(cur.val + " ");
        if(cur.left != null) {
            queue.offer(cur.left);
        }
        if(cur.right != null) {
            queue.offer(cur.right);
        }
    }
}

3.二叉树的基本操作

/**
 * 获取树中节点的个数：遍历思路
 */
void size(TreeNode root) {
    if(root == null) {
        return;
    }
    nodeSize++;
    preOrder(root.left);
    preOrder(root.right);
}

/**
 * 获取节点的个数：子问题的思路
 *
 * @param root
 * @return
 */
int size2(TreeNode root) {
    if(root == null) {
        return 0;
    }
    return size2(root.left) + size2(root.right) + 1;
}


/**
 *获取叶子节点的个数：遍历思路
 */
public static int leafSize = 0;

void getLeafNodeCount1(TreeNode root) {
    if(root == null) {
        return;
    }
    if(root.left == null && root.right == null) {
        nodeSize++;
    }
    getLeafNodeCount1(root.left);
    getLeafNodeCount1(root.right);
}

/*
 获取叶子节点的个数：子问题
 */
int getLeafNodeCount2(TreeNode root) {
    if(root == null) {
        return 0;
    }
    if(root.left == null && root.right == null) {
        return 1;
    }
    return getLeafNodeCount2(root.left) +
            getLeafNodeCount2(root.right);
}

/*
获取第K层节点的个数
 */
int getKLevelNodeCount(TreeNode root, int k) {
    if(root == null || k < 1) {
        return 0;
    }
    if(k == 1) {
        return 1;
    }
    return getKLevelNodeCount(root.left,k - 1) +
            getKLevelNodeCount(root.right,k - 1);
}

/*
 获取二叉树的高度
 时间复杂度：O(N)
 */
int getHeight(TreeNode root) {
    if(root == null){
        return 0;
    }
    int left = getHeight(root.left);
    int right = getHeight(root.right);
    return Math.max(left, right) + 1;
}


// 检测值为value的元素是否存在
TreeNode find(TreeNode root, char val) {
    if(root == null) {
       return null;
    }
    if(root.val == val) {
        return root;
    }
    TreeNode ret = find(root.left,val);
    if(ret != null) {
        return ret;
    }
    ret = find(root.right,val);
    if(ret != null) {
        return ret;
    }
    return null;
}

//层序遍历并实现分层
public List<List<Integer>> levelOrder2(TreeNode root) {
    List<List<Integer>> list = new LinkedList<>();
    Queue<TreeNode> queue = new LinkedList<>();
    if(root == null) {
        return list;
    }
    queue.offer(root);
    while(!queue.isEmpty()) {
        int size = queue.size();
        List<Integer> level = new ArrayList<>();
        for(int i = 0; i < size; i++) {
            TreeNode cur = queue.poll();
            level.add((int) cur.val);
            if(cur.left != null) {
                queue.offer(cur.left);
            }
            if(cur.right != null) {
                queue.offer(cur.right);
            }
        }
        list.add(level);
    }
    return list;
}

// 判断一棵树是不是完全二叉树
boolean isCompleteTree(TreeNode root) {
    if(root == null) {
        return false;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while(!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        if(cur != null) {
            queue.offer(cur.left);
            queue.offer(cur.right);
        } else {
            break;
        }
    }
    while(!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        if(cur != null) {
            return false;
        }
    }
    return true;
}