Java数据结构:树

计算机科学中的树

在计算机科学中，树（英语：tree）是一种抽象数据类型（ADT）或是实现这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>0）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

每个节点都只有有限个子节点或无子节点；

没有父节点的节点称为根节点；

每一个非根节点有且只有一个父节点；

除了根节点外，每个子节点可以分为多个不相交的子树；

树里面没有环路(cycle)

为什么需要树？

因为它结合了另外两种数据结构的优点： 一种是有序数组，另一种是链表。在树中查找数据项的速度和在有序数组中查找一样快， 并且插入数据项和删除数据项的速度也和链表一样。

在有序数组中插入数据项太慢

假设数组中的所有数据项都有序的排列—这就是有序数组，用二分查找法可以在有序数组中快速地查找特定的值。

二分查找法的过程是先査看数组的正中间的数据项，如果那个数据项值比要找的大，就缩小査找范围，在数组的后半段中找；如果小， 就在前半段找。反复这个过程，查找数据所需的时间是O(logN)。同时也可以迅速地遍历有序数组， 按顺序访问每个数据项。

然而，想在有序数组中插入一个新数据项，就必须首先査找新数据项插入的位置，然后把所有 比新数据项大的数据项向后移动一位，来给新数据项腾出空间。这样多次的移动很费时，平均来讲 要移动数组中一半的数据项(N/2次移动)。

删除数据项也需要多次的移动，所以也很慢。 显而易见，如果要做很多的插入和删除操作，就不该选用有序数组。

在链表中查找太慢

链表的插入和删除操作都很快。它们只需要改变一些引用的值就行了。这些操作的时间复杂度是0(1)(是大O表示法中最小的时间复杂度)。

但是在链表中查找数据项可不那么容易。查找必须从头开始，依次访问链表中的每一个数据项，把每个数据项的值和要找的数据项做比较，直到找到该数据项为止，平均需要访问N/2个数据项。这个过程很慢，费时O(N)(注意，对排序来说比较快的，对数据结构操作来说是比较慢的。)。

我们可以通过有序的链表来加快查找速度，链表中的数据项是有序的，但这样做是没有用的。即使是有序的链表还是必须从头开始依次访问数据项，因为链表中不能直接访问某个数据项，必须通过数据项间的链式引用才可以。（当然有序链表访问节点还是比无序链表快多了，但查找任意的数据项时它也无能为力了。）

术语

节点的度：一个节点含有的子树的个数称为该节点的度；

树的度：一棵树中，最大的节点度称为树的度；

叶节点或终端节点：度为零的节点；

非终端节点或分支节点：度不为零的节点；

父亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；

孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；

兄弟节点：具有相同父节点的节点互称为兄弟节点；

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；

深度：对于任意节点n,n的深度为从根到n的唯一路径长，根的深度为0；

高度：对于任意节点n,n的高度为从n到一片树叶的最长路径长，所有树叶的高度为0；

堂兄弟节点：父节点在同一层的节点互为堂兄弟；

节点的祖先：从根到该节点所经分支上的所有节点；

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。

森林：由m（m>=0）棵互不相交的树的集合称为森林；

树的种类

无序树：树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树；

有序树：树中任意节点的子节点之间有顺序关系，这种树称为有序树；

二叉树：每个节点最多含有两个子树的树称为二叉树；

完全二叉树：对于一颗二叉树，假设其深度为d（d>1）。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树；

满二叉树：所有叶节点都在最底层的完全二叉树；

平衡二叉树（AVL树）：当且仅当任何节点的两棵子树的高度差不大于1的二叉树；

排序二叉树(二叉查找树（英语：Binary Search Tree))：也称二叉搜索树、有序二叉树；

霍夫曼树：带权路径最短的二叉树称为哈夫曼树或最优二叉树；

B树：一种对读写操作进行优化的自平衡的二叉查找树，能够保持数据有序，拥有多于两个子树。

树的实现

使用数组实现

树可以使用数组实现，节点在数组中的位置对应于它在树中的位置。下标为0的节点是根，下标为1的节点是根的左子节点，依次类推，按从左到右的顺序存储树的每一层。

树中的每个位置，无论是否存在节点，都对应数组中的一个位置。把节点插入树的一个位置， 意味着要在数组的相应位置插入一个数据项。树中没有节点的位置在数组中的对应位置用0或null来表示。

基于这种思想，找节点的子节点和父节点可以利用简单的算术计算它们在数组中的索引值。设节点索引值为 index ,则节点的左子节点是： 2 * index + 1 ,它的右子节点是 2 * index + 2 ,它的父节点是 (index - 1) / 2

大多数情况下用数组表示树不是很有效率。不满的节点和删除掉的节点在数组中留下了洞，浪费存储空间。更坏的是，删除节点时需要移动子树的话，子树中的每个节点都要移到数组中新的位置去，这在比较大的树中是很费时的。

不过，如果不允许删除操作，数组表示可能会很有用。

树的遍历

所谓树的遍历（Traversal），就是按照某种次序访问树中的节点，且每个节点恰好访问一次。

也就是说，按照被访问的次序，可以得到由树中所有节点排成的一个序列。

前序遍历

根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    List<Integer> a = new ArrayList<Integer>();
    public List<Integer> preorderTraversal(TreeNode root) {
        preorderTraversal1(root);
        return a;
    }
    void preorderTraversal1(TreeNode root){
        if(root == null)
            return;
        a.add(root.val);
        preorderTraversal1(root.left);
        preorderTraversal(root.right);
    }
}

中序遍历

根在中，从左往右，一棵树的左子树永远在根前面，根永远在右子树前面

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    List<Integer> list = new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        dps(root);
        return list;
    }
    void dps(TreeNode root){
        if(root == null)
            return;
        dps(root.left);
        list.add(root.val);
        dps(root.right);
    }
}

后序遍历

根在后，从左往右，一棵树的左子树永远在右子树前面，右子树永远在根前面。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    List<Integer> a = new ArrayList<Integer>();
    public List<Integer> postorderTraversal(TreeNode root) {
        postorderTraversal1(root);
        return a;
    }
    void postorderTraversal1(TreeNode root){
        if(root == null)
            return;
        postorderTraversal1(root.left);
        postorderTraversal1(root.right);
        a.add(root.val);

    }
}

层次遍历

就是按层，从上到下，从左到右遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> a = new ArrayList<>();
        Queue<TreeNode> s = new LinkedList<TreeNode>();
        if(root == null)
                return a;
        ArrayList<Integer> a11 = new ArrayList<Integer>();
        a11.add(root.val);
        a.add(a11);
        s.offer(root.left);
        s.offer(root.right);
        while(root != null){
            ArrayList<Integer> a1 = new ArrayList<Integer>();
            Queue<TreeNode> s1 = new LinkedList<TreeNode>();
            while(!s.isEmpty()){
                TreeNode root1 = s.poll();
                if(root1 != null){
                    a1.add(root1.val);
                    s1.offer(root1.left);
                    s1.offer(root1.right);
                    root = root1;   
                }
            }
            s = s1;
            if(a1.size() > 0)
                a.add(a1);
            if(s.isEmpty()){
                break;
            }
        }
        return a;
    }
}