树_树的顶点-CSDN博客

本文链接：https://blog.csdn.net/qq_23211905/article/details/72781842

种类：

无序树：树中任意节点的子结点之间没有顺序关系，这种树称为无序树,也称为自由树;
有序树：树中任意节点的子结点之间有顺序关系，这种树称为有序树；
二叉树：每个节点最多含有两个子树的树称为二叉树；
完全二叉树
满二叉树
霍夫曼树：带权路径最短的二叉树称为哈夫曼树或最优二叉树。
深度：根到ni的唯一的路径长度。
高度：ni到叶子节点的长。
遍历表达法
1.先序遍历：根左右
2.后序遍历：左右根
3.中序遍历：左跟右

二叉树

二叉树是一个连通的无环图，并且每一个顶点的度不大于3。有根二叉树还要满足根结点的度不大于2。有了根结点之后，每个顶点定义了唯一的父结点，和最多2个子结点。然而，没有足够的信息来区分左结点和右结点。如果不考虑连通性，允许图中有多个连通分量，这样的结构叫做森林。
类型
(1)完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。
(2)满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。
(3)平衡二叉树——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
二叉树性质
(1) 在非空二叉树中，第i层的结点总数不超过 $\ 2^{i-1}$
(2) 深度为h的二叉树最多有 $\ 2^h-1$ 个节点
(3) 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1；
(4) 具有n个结点的完全二叉树的深度为log2n+1
(5)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：
若I为结点编号则如果I>1，则其父结点的编号为I/2；
如果2*I<=N，则其左儿子（即左子树的根结点）的编号为2*I；若2*I>N，则无左儿子；
如果2*I+1<=N，则其右儿子的结点编号为2*I+1；若2*I+1>N，则无右儿子。
(6)给定N个节点，能构成h(N)种不同的二叉树。
h(N)为卡特兰数的第N项。h(n)=C(2*n，n)/(n+1)。
(7)设有i个枝点，I为所有枝点的道路长度总和，J为叶的道路长度总和J=I+2i

二叉树存储结构
1.顺序存储结构，一组地址联系的存储单元来存放二叉树的数据元素。
2.链式存储结构，每个节点用链表中的链接点来存储。

public class BinaryTree {
    private Node root;

    //定义二叉树
    private class Node {
        private int data;
        private Node left;
        private Node right;

        public Node(int data) {
            this.left = null;
            this.right = null;
            this.data = data;
        }
    }

    public BinaryTree() {
        root = null;
    }

    /**
     * 递归创建二叉树
     * @param node
     * @param data
     */
    public void createTree(Node node, int data) {
        if (root == null) {
            root = new Node(data);
        } else {
            if (data < node.data) {
                if (node.left == null) {
                    node.left = new Node(data);
                } else {
                    createTree(node.left, data);
                }
            } else {
                if (node.right == null) {
                    node.right = new Node(data);
                } else {
                    createTree(node.right, data);
                }
            }
        }
    }

    /**
     * 前序遍历
     * 根左右
     * @param node
     */
    public void preOrder(Node node) {
        if (node != null) {
            System.out.println(node.data);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    /**
     * 中序遍历
     * 左根右
     * @param node
     */
    public void inOrder(Node node) {
        if (node != null) {
            inOrder(node.left);
            System.out.println(node.data);
            inOrder(node.right);
        }
    }

    /**
     * 后序遍历
     * @param node
     */
    public void postOrder(Node node) {
        if (node != null) {
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.data);
        }
    }

    public Node findNode(Node node, int x) {
        if (node == null) {
            return null;
        } else if (node.data == x) {
            return node;
        } else {
            if (findNode(node.left, x) != null) {
                return findNode(node.left, x);
            } else if (findNode(node.right, x) != null) {
                return findNode(node.right, x);
            } else {
                return null;
            }
        }
    }

    /**
     * 二叉树的高度
     *
     * @param node
     * @return
     */
    public int nodeHigh(Node node) {
        int leftHigh, rightHigh;
        if (node == null) {
            return 0;
        } else {
            leftHigh = nodeHigh(node.left);
            rightHigh = nodeHigh(node.right);
            return (leftHigh > rightHigh) ? (leftHigh + 1) : (rightHigh + 1);
        }
    }

    /**
     * 非递归先序遍历
     * @param node
     */
    public void preOrderByStatck(Node node) {
        Stack<Node> stack=new Stack();
        if (node != null) {
            stack.push(node);
            while (!stack.empty()) {
                node = stack.pop();
                System.out.println(node.data);
                if (node.right != null)
                    stack.push(node.right);
                if (node.left != null)
                    stack.push(node.left);
            }
        }
    }

    /**
     * 层次遍历
     * @param node
     */
    public void levelOrder(Node node){
      Queue<Node> queue=new LinkedBlockingQueue<>();
      queue.offer(node);
      Node current = null;
      while (!queue.isEmpty()){
          current = queue.poll();//出队队头元素并访问
          System.out.print(current.data+" ");
          if(current.left != null)//如果当前节点的左节点不为空入队
          {
              queue.offer(current.left);
          }
          if(current.right != null)//如果当前节点的右节点不为空，把右节点入队
          {
              queue.offer(current.right);
          }
      }
    }
    public static void main(String[] args) {
        int[] a = {12, 4, 6, 45, 21,7, 111};
        BinaryTree bTree = new BinaryTree();
        for (int i = 0; i < a.length; i++) {
            bTree.createTree(bTree.root, a[i]);
        }
        Node b = bTree.findNode(bTree.root, 4);
       // bTree.preOrder(bTree.root);
         // bTree.levelOrder(bTree.root);
        //bTree.preOrderByStatck(bTree.root);
        //bTree.inOrder(bTree.root);
        //bTree.postOrder(bTree.root);
    }

}

B树
是一种多路搜索树（并不是二叉的）：
在B-树中查找给定关键字的方法是，首先把根结点取来，在根结点所包含的关键字K1,…,Kn查找给定的关键字（可用顺序查找或二分查找法），若找到等于给定值的关键字，则查找成功；否则，一定可以确定要查找的关键字在Ki与Ki+1之间，Pi为指向子树根节点的指针，此时取指针Pi所指的结点继续查找，直至找到，或指针Pi为空时查找失败。

1.定义任意非叶子结点最多只有M个儿子；且M>2；
2.根结点的儿子数为[2, M]；
3.除根结点以外的非叶子结点的儿子数为[M/2, M]；
4.每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）
5.非叶子结点的关键字个数=指向儿子的指针个数-1；
6.非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；
7.非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树；
8.所有叶子结点位于同一层；

B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果
命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为
空，或已经是叶子结点；
B-树的特性：
1.关键字集合分布在整颗树中；
2.任何一个关键字出现且只出现在一个结点中；
3.搜索有可能在非叶子结点结束；
4.其搜索性能等价于在关键字全集内做一次二分查找；
5.自动层次控制；

B+-tree：是应文件系统所需而产生的一
种B-tree的变形树。
一棵m阶的B+-tree和m阶的B-tree的差异在于：

   1.有n棵子树的结点中含有n个关键字； (B-tree是n棵子树有n-1个关键字)
   2.所有的叶子结点中包含了全部关键字的信息，及指向含有这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大的顺序链接。
    (B-tree的叶子节点并没有包括全部需要查找的信息)
   3.所有的非终端结点可以看成是索引部分，结点中仅含有其子树根结点中最大（或最小）关键字。 (B-tree的非终节点也包含需要查找的有效信息)
1) B+-tree的磁盘读写代价更低
B+-tree的内部结点并没有指向关键字具体信息的指针。因此其内部结点相对B-tree更小。如果把所有同一内部结点的关键字存放在同一盘块中，那么盘块所能容纳的关键字数量也越多。一次性读入内存中的需要查找的关键字也就越多。相对来说IO读写次数也就降低了。
举个例子，假设磁盘中的一个盘块容纳16bytes，而一个关键字2bytes，一个关键字具体信息指针2bytes。一棵9阶B-tree(一个结点最多8个关键字)的内部结点需要2个盘快。而B+-tree内部结点只需要1个盘快。当需要把内部结点读入内存中的时候，B-tree就比B+-tree多一次盘块查找时间(在磁盘中就是盘片旋转的时间)。
2) B+-tree的查询效率更加稳定
由于非终结点并不是最终指向文件内容的结点，而只是叶子结点中关键字的索引。所以任何关键字的查找必须走一条从根结点到叶子结点的路。所有关键字查询的路径长度相同，导致每一个数据的查询效率相当。
http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html
http://chqz1987.blog.163.com/blog/static/51438311201312013746271/

红黑树的介绍
红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。
红黑树是特殊的二叉查找树，意味着它满足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。
除了具备该特性之外，红黑树还包括许多额外的信息。
红黑树的每个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。
红黑树的特性:
(1) 每个节点或者是黑色，或者是红色。
(2) 根节点是黑色。
(3) 每个叶子节点是黑色。 [注意：这里叶子节点，是指为空的叶子节点！]
(4) 如果一个节点是红色的，则它的子节点必须是黑色的。
(5) 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
关于它的特性，需要注意的是：
第一，特性(3)中的叶子节点，是只为空(NIL或null)的节点。
第二，特性(5)，确保没有一条路径会比其他路径长出俩倍。因而，红黑树是相对是接近平衡的二叉树。
http://www.cnblogs.com/v-July-v/archive/2010/12/29/1983707.html