数据结构与算法之树

目录

树的基本概念：

树的表示形式和应用

二叉树

---

树的基本概念：

1.树：树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看 起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：每个结点有零个或多个子结点；没 有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树 。

2.节点的度 ：一个节点含有的子树的个数称为该节点的度； 如上图： A 的为 6

 

3.树的度 ：一棵树中，最大的节点的度称为树的度； 如上图：树的度为 6

 

4.叶子节点或终端节点 ：度为 0 的节点称为叶节点； 如上图： B 、 C 、 H 、 I... 等节点为叶节点

 

5.双亲节点或父节点 ：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图： A 是 B 的父节点

 

6.孩子节点或子节点 ：一个节点含有的子树的根节点称为该节点的子节点； 如上图： B 是 A 的孩子节点

 

7.根结点 ：一棵树中，没有双亲结点的结点；如上图： A

 

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

 

9.树的高度或深度 ：树中节点的最大层次； 如上图：树的高度为 4

 

10.非终端节点或分支节点：度不为 0 的节点； 如上图： D 、 E 、 F 、 G... 等节点为分支节点

 

11.兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图： B 、 C 是兄弟节点

 

12.堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图： H 、 I 互为兄弟节点

 

13.节点的祖先：从根到该节点所经分支上的所有节点；如上图： A 是所有节点的祖先

 

14.子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是 A 的子孙

 

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

 

 

树的表示形式和应用

说到这里，树和非树（图）到底有什么区别呢？子树是不相交的，除了根节点外，每个节点有且仅有一个父节点，一颗N个节点的树有N-1条边。

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，如：双亲表示法，

孩子表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的 孩子兄弟表示法 。

 

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

树最常见的应用于文件系统管理（目录和文件）

二叉树

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

树组成。

2.二叉树的特点：

1）  每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。

2）  二叉树的子树有左右之分，其子树的次序不能颠倒。

 

3.两种特殊的二叉树

1） 完全二叉树 : 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为 K 的，有 n

个结点的二叉树，当且仅当其每一个结点都与深度为 K 的满二叉树中编号从 1 至 n 的结点一一对应时称之为完全

二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。 不能有跳过的，必须一一对应。

2） 满二叉树 : 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果

一个二叉树的层数为 K ，且结点总数是 (2^k) -1 ，则它就是满二叉树。

4.二叉树的表示形式：

顺序存储 --》 堆（二叉树）

链式存储：包括二叉链和三叉链

class Node { 
    int val; // 数据域 
    Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树 
    Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
    Node parent; // 可选的，双亲的引用 有为三叉链，无为二叉链
}

5.二叉树的遍历方式

1.）NLR ：前序遍历 (Preorder Traversal 亦称先序遍历 )—— 访问根结点的操作发生在遍历其左右子树之前。

2） LNR ：中序遍历 (Inorder Traversal)—— 访问根结点的操作发生在遍历其左右子树之中（间）。

3.）LRN ：后序遍历 (Postorder Traversal)—— 访问根结点的操作发生在遍历其左右子树之后。

 

4）层序遍历： 设二叉树的根节点所在层数为 1 ，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从

左到右访问第 2 层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是

层序遍历。

 

package tree.com;
class TreeNode {
    char value;
    TreeNode left;
    TreeNode right;
    public TreeNode(char value) {
        this.value = value;
    }
}

public class BinaryTree {

    public BinaryTree() {

    }
    //建造树
    public TreeNode buildTree() {
        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');
        TreeNode H = new TreeNode('H');
        root.left = B;
        root.right = C;
        B.left = D;
        B.right = E;
        E.right = H;
        C.left = F;
        C.right = G;
        return root;
    }

    //前序遍历 A B D E H C F G
    void preOrderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.value + " ");
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
    }

    //中序遍历   //D B E H A C F G 
    void inOrderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrderTraversal(root.left);
        System.out.print(root.value + " ");
        preOrderTraversal(root.right);
    }

    //后序遍历   A B D E H C F G 
    void postOrderTraversal(TreeNode root) {
        inOrderTraversal(root.left);
        preOrderTraversal(root.right);
        System.out.print(root.value + " ");
    }

}

层序遍历：

  public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> ret = new ArrayList<>();
        if(root != null) {
            queue.offer(root);
        }
        while(!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while(size > 0) {
                TreeNode cur = queue.poll();
                list.add(cur.val);
                size--;
                if(cur.left != null) {
                    queue.offer(cur.left);
                }
                if(cur.right != null) {
                    queue.offer(cur.right);
                }
            }
            ret.add(list);
        }
        return ret;
    }