数据结构之二叉树

一、树的基本概念

1、定义

树结构的特点是:它的每一个结点都可以有不止一个直接后继，除根结点外的所有结点都有且只有一个直接前趋。以下具体地给出树的定义及树的数据结构表示。
(一）树的定义
树是由一个或多个结点组成的有限集合，其中:
1.必有一个特定的称为根(ROOT)的结点;
2.剩下的结点被分成n >=0个互不相交的集合T1、T2、…n，而且，这些集合的每一个又都是树。树T1、T2、…Tn被称作根的子树(Subtree)。

树的递归定义如下:
（1）至少有一个结点（称为根）；
（2）其它是互不相交的子树.

2、重要概念

节点的度：一个节点含有的子树的个数称为该节点的度；如结点i的度为3。节点t的度为2，节点b的度为1。
树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为3
叶子节点或终端节点：度为0的节点称为叶节点； 如w,h,e,f,s,m,o,n,j,u根结点到每个分支结点或叶结点的路径是唯一的。从根r到结点i的唯一路径为rcti。
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：R是a的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：a是R的孩子节点
根结点：一棵树中，没有双亲结点的结点；如上图：R
节点的层次:从根开始定义起，根为第1层，根的子节点为第2层，以此类推;
树的高度或深度:树中节点的最大层次;如上图:树的高度为5
兄弟节点:具有相同父节点的节点互称为兄弟节点;如上图:a、b是兄弟节点

3、树的表示形式

实际中树有很多种表示方式，如:双亲表示法，孩子表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

class Node {
	int value;//树中存储的数据
	Node firstChild;//第一个孩子引用
    Node nextBrother;//下一个兄弟引用

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

二、二叉树

1、概念

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。

二叉树的特点:
（1）每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
（2）二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。

2、 两种特殊的二叉树

（1）满二叉树:一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。
（2）完全二叉树:完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点——对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

3、 二叉树的性质

（1）在二叉树的第i层上至少有2^（i-1）个结点
（2）深度为k的二叉树至多有2^(k-1)个结点
（3）对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1
（4）具有n个结点的完全二叉树的深度是[log2n]+1（向下取整）
（5）如果对一棵有n个结点的完全二叉树的结点按层序编号，则对任一结点i，有：
　　如果i=1，则结点i是二叉树的根，无双亲；如果i>1，则其双亲是i/2
　　如果2i>n，则结点i无左孩子；如果2i<n，则其左孩子是2i
　　如果2i+1>n，则结点i无右孩子；如果2i+1<n，则其右孩子是2i+1

4、二叉树的表示形式

二叉树有很多种表示方式，如:双亲表示法，孩子表示法等等。我们这里就简单的了解其中最常用的孩子表示法。

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

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

5、二叉树的遍历

二叉树的遍历相对复杂，为了让遍历统一规范，约定出了4种遍历方式：
（1）先序遍历：先访问根节点,然后遍历左子树,然后遍历右子树；
（2）中序遍历：先递归遍历左子树,然后访问根节点,然后递归遍历右子树；
（3）后序遍历：先递归遍历左子树,然后递归遍历右子树,最后访问根节点；
（4）层序遍历：按照从上到下,从左到右的顺序依次遍历即可。

举例说明：

先序遍历：ABDEGCF
中序遍历：DBGEACF
后序遍历：DGEBFCA
层序遍历：ABCDEFG

其中，中序遍历有个简单方法：把树投影下来，即：

6、二叉树的基本操作

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

class Node {
    String val;
    Node left;
    Node right;

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

public class BinaryTree {
    // 创建一个树
    public static Node build() {
        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;
        e.left = g;
        c.right = f;
        return a;
    }

    // 1.先序遍历
    public static void preOrder(Node root) {
        if (root == null) {
            return;
        }
        // 访问根节点. 此处的访问就是打印操作
        System.out.print(root.val);
        // 递归遍历左子树
        preOrder(root.left);
        // 递归遍历右子树
        preOrder(root.right);
    }

    // 2.中序遍历
    public static void inOrder(Node root) {
        if (root == null) {
            return;
        }
        // 先递归处理左子树
        inOrder(root.left);
        // 再访问根节点
        System.out.print(root.val);
        // 最后递归处理右子树
        inOrder(root.right);
    }

    // 3.后序遍历
    public static void postOrder(Node root) {
        if (root == null) {
            return;
        }
        // 先递归处理左子树
        postOrder(root.left);
        // 再递归处理右子树
        postOrder(root.right);
        // 最后打印根节点
        System.out.print(root.val);
    }

    // 4.1 使用这个成员变量 count, 来记录元素的个数
    public static int count = 0;
    public static void length(Node root) {
        if (root == null) {
            return;
        }
        // 访问根节点, 此时的访问操作就是 count++
        count++;
        // 递归处理左子树
        length(root.left);
        // 递归处理右子树
        length(root.right);
    }

    // 4.2 接下来还是实现 length, 此时通过方法的返回值来记录元素个数
    public static int length2(Node root) {
        if (root == null) {
            return 0;
        }
        // 当前树的节点个数 = 根节点的个数 + 左子树的节点个数 + 右子树的节点个数
        return 1 + length2(root.left) + length2(root.right);
    }
    
	//5.1 求叶子结点个数
    public static int leafSize = 0;
    public static void getLeafSize(Node root) {
        // 针对二叉树遍历, 判断当前节点是否是叶子节点. 如果是就 size++
        if (root == null) {
            return;
        }
        // 判断当前节点是否是叶子节点
        if (root.left == null && root.right == null) {
            leafSize++;
        }
        getLeafSize(root.left);
        getLeafSize(root.right);
    }

	//5.2 求叶子结点个数
    public static int getLeafSize2(Node root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
        return getLeafSize2(root.left) + getLeafSize2(root.right);
    }

	//6.求第k层节点个数
    public static int getKLevelSize(Node root, int k) {
        if (root == null || k < 1) {
            return 0;
        }
        if (k == 1) {
            // 如果当前树非空, 第一层节点一定是 1 个元素.
            return 1;
        }
        return getKLevelSize(root.left, k - 1) + getKLevelSize(root.right, k - 1);
    }

	//7.求二叉树的高度
    public static int getHeight(Node root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
    }

	//8.查找val所在的结点
    public static Node find(Node root, String toFind) {
        if (root == null) {
            return null;
        }
        if (root.val.equals(toFind)) {
            return root;
        }
        Node result = find(root.left, toFind);
        if (result != null) {
            return result;
        }
        return find(root.right, toFind);
    }

	 public static void main(String[] args) {
        Node root = build();
//        preOrder(root);
//        inOrder(root);
//        postOrder(root);
//        length(root);
//        System.out.println(count);
//        System.out.println(length2(root));
//        getLeafSize(root);
//        System.out.println(leafSize);
//        System.out.println(getLeafSize2(root));
//        System.out.println(getKLevelSize(root, 3));
        System.out.println(getHeight(root));
    }
}