首页 > 其他分享> > 二叉树，二叉搜索树，二叉平衡树，红黑树，b+树，b*树遍历、搜索、先序、中序、后序，布隆过滤器，TCP/IP五层，OSI七层模型

二叉树，二叉搜索树，二叉平衡树，红黑树，b+树，b*树遍历、搜索、先序、中序、后序，布隆过滤器，TCP/IP五层，OSI七层模型

2019-06-13 14:52:57 作者：互联网

1. 树结构示意图

补充：

兄弟节点：具有相同父节点的节点互称为兄弟节点。
树的深度：从根节点开始（其深度为0）自顶向下逐层累加的。上图中，3的深度是1，6的深度是2，10的深度是3。
节点高度：从叶子节点开始（其高度为0）自底向上逐层累加的。6的高度是1，根节点1的高度是3。

2. 二叉树（Binary Tree）

任何一个节点的子节点数量不超过2（子节点分为左节点与右节点）。

2.1 满二叉树（Full Binary Tree）

所有叶子结点都在最后一层。
节点的总数为2^n-1 （n为树的高度）。

2.2 完全二叉树（Complete Binary Tree）

所有叶子结点都在最后一层或倒数第二层。
最后一层的叶子结点在左边连续，倒数第二节的叶子结点在右侧连续。

2.3 平衡二叉树（Balanced Binary Tree）

也叫 AVL 树。
它是一颗空树或左右两个子树的高度差的绝对值不超过1。
左右两个子树均为平衡二叉树。

2.4 二叉搜索树（Binary Search Tree）

也叫二叉查找树、二叉排序树。
若子树不空，则子树上所有节点的值均小于或等于根节点的值。
若右子树不空，则右子树所有节点的值均大于或等于根节点的值。
左、右子树也分别为二叉排序树，或是一颗空树。

2.5 红黑树（Red Black Tree）

每个节点都带有颜色属性（颜色为红或黑）的平衡二叉查找树。
节点是红色或黑色。
根节点是黑色。
所有叶子结点都是黑色。
每个红色节点必须有两个黑色的子节点（从每个叶子到根的所有路径上不能有两个连续的红色节点）。
从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

3. B 树

B-tree（多路搜索树，并不是二叉的）是一种常见的数据结构。使用B-tree结构可以显著减少定位记录时所经历的中间过程，从而加快存取速度。按照翻译，B 通常认为是Balance的简称。这个数据结构一般用于数据库的索引，综合效率较高。

3.1 B- 树

B-树就是指 B树，也是一种用于查找的平衡树，但是它不是二叉树，B树可以拥有多于2个子节点，能够用来存储排序后的数据。这种数据结构能够让查找数据、循序存取、插入数据及删除的动作，都在对数时间内完成。这种数据结构常被应用在数据库和文件系统的实作上。

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

3.2 B+ 树

B+树是 B树的变体，也是一种多路搜索树

其定义基本与B-树相同，除了：
非叶子结点的子树指针与关键字个数相同。
非叶子结点的子树指针P[i]，指向关键字值属于[K[i], K[i+1])的子树（B-树是开区间）。
为所有叶子结点增加一个链指针。
所有关键字都在叶子结点出现。

特性：

所有关键字都出现在叶子结点的链表中（稠密索引），且链表中的关键字恰好是有序的。
不可能在非叶子结点命中。
非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层。
B+树的分裂：当一个结点满时，分配一个新的结点，并将原结点中1/2的数据复制到新结点，最后在父结点中增加新结点的指针；B+树的分裂只影响原结点和父结点，而不会影响兄弟结点，所以它不需要指向兄弟的指针。
更适合文件索引系统。

3.3 B* 树

是 B+树的变体，在 B+树的非根和非叶子结点再增加指向兄弟的指针

特性：

B*树定义了非叶子结点关键字个数至少为(2/3)M，即块的最低使用率为2/3（代替B+树的1/2）。
B*树的分裂：当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字（因为兄弟结点的关键字范围改变了）；如果兄弟也满了，则在原结点与兄弟结点之间增加新结点，并各复制1/3的数据到新结点，最后在父结点增加新结点的指针。

所以，B*树分配新结点的概率比B+树要低，空间使用率更高。

布隆过滤器概念引入

（Bloom Filter）是由布隆（Burton Howard Bloom）在1970年提出的。它实际上是由一个很长的二进制向量和一系列随机映射函数组成，布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率（假正例False positives，即Bloom Filter报告某一元素存在于某集合中，但是实际上该元素并不在集合中）和删除困难，但是没有识别错误的情形（即假反例False negatives，如果某个元素确实在该集合中，那么Bloom Filter 是不会报告该元素不存在于集合中的，所以不会漏报）。

下面从简单的排序谈到BitMap算法，再谈到数据去重问题，谈到大数据量处理利器：布隆过滤器。

对无重复的数据进行排序

给定数据（2，4，1，12，9，7，6）如何对它排序？

方法1：基本的排序方法包括冒泡，快排等。

方法2：使用BitMap算法

方法1就不介绍了，方法2中所谓的BitMap是一个位数组，跟平时使用的数组的唯一差别在于操作的是位。首先是开辟2个字节大小的位数组，长度为12（该长度由上述数据中最大的数字12决定的),然后，读取数据，2存放在位数组中下标为1的地方，值从0改为1，4存放在下标为3的地方，值从0改为1....最后，读取该位数组，得到排好序的数据是：（1，2，4，6，7，9，12）。

比较方法1和方法2的差别：方法2中，排序需要的时间复杂度和空间复杂度很依赖与数据中最大的数字比如12，因此空间上讲需要开2个字节大小的内存，时间上需要遍历完整个数组。当数据类似（1，1000，10万）只有3个数据的时候，显然用方法2，时间复杂度和空间复杂度相当大，但是当数据比较密集时该方法就会显示出来优势。

对有重复的数据进行判重

数据（2，4，1，12，2，9，7，6，1，4）如何找出重复出现的数字？

首先是开辟2个字节大小的位数组，长度为12（该长度由上述数据中最大的数字12决定的,当读取完12后，当读取2的时候，发现数组中的值是1，则判断出2是重复出现的。

二、布隆过滤器原理

布隆过滤器需要的是一个位数组（这个和位图有点类似）和k个映射函数（和Hash表类似），在初始状态时，对于长度为m的位数组array，它的所有位都被置为0。对于有n个元素的集合S={s1,s2......sn}，通过k个映射函数{f1,f2,......fk}，将集合S中的每个元素sj(1<=j<=n)映射为k个值{g1,g2......gk}，然后再将位数组array中相对应的array[g1],array[g2]......array[gk]置为1；如果要查找某个元素item是否在S中，则通过映射函数{f1,f2.....fk}得到k个值{g1,g2.....gk}，然后再判断array[g1],array[g2]......array[gk]是否都为1，若全为1，则item在S中，否则item不在S中。这个就是布隆过滤器的实现原理。

当然有读者可能会问：即使array[g1],array[g2]......array[gk]都为1，能代表item一定在集合S中吗？不一定，因为有这个可能：就是集合中的若干个元素通过映射之后得到的数值恰巧包括g1,g2,.....gk，那么这种情况下可能会造成误判，但是这个概率很小，一般在万分之一以下。

很显然，布隆过滤器的误判率和这k个映射函数的设计有关，到目前为止，有很多人设计出了很多高效实用的hash函数。尤其要注意的是，布隆过滤器是不允许删除元素的(实际就是因为多个str可能都应设在同一点，而判断str存在的话是所有映射点都存在，所以不能删除)，因为若删除一个元素，可能会发生漏判的情况。不过有一种布隆过滤器的变体Counter Bloom Filter，可以支持删除元素，感兴趣的读者可以查阅相关文献资料。

三、布隆过滤器False positives 概率推导

假设 Hash 函数以等概率条件选择并设置 Bit Array 中的某一位，m 是该位数组的大小，k 是 Hash 函数的个数，那么位数组中某一特定的位在进行元素插入时的 Hash 操作中没有被置位为1的概率是：；那么在所有 k 次 Hash 操作后该位都没有被置 "1" 的概率是：；如果我们插入了 n 个元素，那么某一位仍然为 "0" 的概率是：因而该位为 "1"的概率是：；现在检测某一元素是否在该集合中。标明某个元素是否在集合中所需的 k 个位置都按照如上的方法设置为 "1"，但是该方法可能会使算法错误的认为某一原本不在集合中的元素却被检测为在该集合中（False Positives），该概率由以下公式确定：。

其实上述结果是在假定由每个 Hash 计算出需要设置的位（bit）的位置是相互独立为前提计算出来的，不难看出，随着 m （位数组大小）的增加，假正例（False Positives）的概率会下降，同时随着插入元素个数 n 的增加，False Positives的概率又会上升，对于给定的m，n，如何选择Hash函数个数 k 由以下公式确定：；此时False Positives的概率为：；而对于给定的False Positives概率 p，如何选择最优的位数组大小 m 呢，；该式表明，位数组的大小最好与插入元素的个数成线性关系，对于给定的 m，n，k，假正例概率最大为：。

四、布隆过滤器应用

布隆过滤器在很多场合能发挥很好的效果，比如：网页URL的去重，垃圾邮件的判别，集合重复元素的判别，查询加速（比如基于key-value的存储系统）等，下面举几个例子：

有两个URL集合A,B，每个集合中大约有1亿个URL，每个URL占64字节，有1G的内存，如何找出两个集合中重复的URL。

很显然，直接利用Hash表会超出内存限制的范围。这里给出两种思路：

第一种：如果不允许一定的错误率的话，只有用分治的思想去解决，将A,B两个集合中的URL分别存到若干个文件中{f1,f2...fk}和{g1,g2....gk}中，然后取f1和g1的内容读入内存，将f1的内容存储到hash_map当中，然后再取g1中的url，若有相同的url，则写入到文件中，然后直到g1的内容读取完毕，再取g2...gk。然后再取f2的内容读入内存。。。依次类推，知道找出所有的重复url。

第二种：如果允许一定错误率的话，则可以用布隆过滤器的思想。

在进行网页爬虫时，其中有一个很重要的过程是重复URL的判别，如果将所有的url存入到数据库中，当数据库中URL的数

量很多时，在判重时会造成效率低下，此时常见的一种做法就是利用布隆过滤器，还有一种方法是利用berkeley db来存储url，Berkeley db是一种基于key-value存储的非关系数据库引擎，能够大大提高url判重的效率。

布隆过滤器主要运用在过滤恶意网址用的，将所有的恶意网址建立在一个布隆过滤器上，然后对用户的访问的网址进行检测，如果在恶意网址中那么就通知用户。这样的话，我们还可以对一些常出现判断错误的网址设定一个白名单，然后对出现判断存在的网址再和白名单中的网址进行匹配，如果在白名单中，那么就放行。当然这个白名单不能太大，也不会太大，布隆过滤器错误的概率是很小的。

五、布隆过滤器简单Java实现

package a;

import java.util.BitSet;

/*

* 存在的问题

* DEFAULT_LEN长度设置为多少合适呢？

* 我发现result和DEFAULT_LEN有关，不应该啊，没发现原因

*/

public class BloomFilterTest {

//30位，表示2^2^30种字符

static int DEFAULT_LEN = 1<<30;

//要用质数

static int[] seeds = {3,5,7,11,17,31};

static BitSet bitset = new BitSet(DEFAULT_LEN);

static MyHash[] myselfHash = new MyHash[seeds.length];

public static void main(String[] args) {

String str = "791909235@qq.com";

//生成一次就够了

for(int i=0; i<seeds.length; i++) {

myselfHash[i] = new MyHash(DEFAULT_LEN, seeds[i]);

}

bitset.clear();

for(int i=0; i<myselfHash.length; i++) {

bitset.set(myselfHash[i].myHash(str),true);

}

boolean flag = containsStr(str);

//System.out.println("========================");

System.out.println(flag);

}

private static boolean containsStr(String str) {

// TODO Auto-generated method stub

if(null==str)

return false;

for(int i=0; i<seeds.length; i++) {

if(bitset.get(myselfHash[i].myHash(str))==false)

return false;

}

return true;

}

class MyHash {

int len;

int seed;

public MyHash(int len, int seed) {

super();

this.len = len;

this.seed = seed;

}

public int myHash(String str) {

int len = str.length();

int result = 0;

//这的len就是str的len，不是成员变量的len

for(int i=0; i<len; i++) {

//System.out.println(seed+"oooooooooooo");

result = result*seed + str.charAt(i);

//System.out.println(result);

//长度就是1<<24，如果大于这个数感觉结果不准确

//<0就是大于了0x7ffffff

if(result>(1<<30) || result<0) {

//System.out.println("-----"+(1<<30));

System.out.println(result+"myHash数据越界！！！");

break;

}

return (len-1)&result;

}

Java实现二叉树的前序、中序、后序、层序遍历（递归方法）

在数据结构中，二叉树是树中我们见得最多的，二叉查找树可以加速我们查找的效率，那么输出一个二叉树也变得尤为重要了。
二叉树的遍历方法分为四种，分别为前序遍历、中序遍历、后序、层序遍历。下图即为一个二叉树。

前序遍历：先遍历根结点，然后遍历左子树，最后遍历右子树。
结果为:4 2 1 3 6 5 7 8 10
中序遍历:先遍历左子树，然后遍历根结点，最后遍历右子树。
结果为：1 2 3 4 5 6 7 8 10
后序遍历:先遍历左子树，然后遍历右子树，最后遍历根节点。
结果为：1 3 2 5 10 8 7 6 4
层序遍历：逐层遍历。
结果为：4 2 6 1 3 5 7 8 10

按照上面的规则，就可以很快地对一颗二叉树进行遍历，并且快速写出结果，下面我附上我使用递归的方法对二叉树实施四种遍历的Java代码。

public class Tree<AnyType extends Comparable<? super AnyType>>
{
    private static class BinaryNode<AnyType>
    {
        BinaryNode(AnyType theElement)
        {
            this(theElement, null, null);
        }

        BinaryNode(AnyType theElement, BinaryNode<AnyType> lt, BinaryNode<AnyType> rt)
        {
            element = theElement;
            left = lt;
            right = rt;
        }

        AnyType element;
        BinaryNode<AnyType> left;
        BinaryNode<AnyType> right;
    }

    private BinaryNode<AnyType> root;

    public void insert(AnyType x)
    {
        root = insert(x, root);
    }

    private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t)
    {
        if(t == null)
        {
            return new BinaryNode<>(x, null, null);
        }

        int compareResult = x.compareTo(t.element);

        if(compareResult < 0)
        {
            t.left = insert(x, t.left);
        }
        else if(compareResult > 0)
        {
            t.right = insert(x, t.right);
        }
        else
        {
            ;
        }

        return t;
    }

    /**
     * 前序遍历
     */
    public void preOrder(BinaryNode<AnyType> Node)
    {
        if (Node != null)
        {
            System.out.print(Node.element + " ");
            preOrder(Node.left);
            preOrder(Node.right);
        }
    }

    /**
     * 中序遍历
     */
    public void midOrder(BinaryNode<AnyType> Node)
    {
        if (Node != null)
        {
            midOrder(Node.left);
            System.out.print(Node.element + " ");
            midOrder(Node.right);
        }
    }

    /**
     * 后序遍历
     */
    public void posOrder(BinaryNode<AnyType> Node)
    {
        if (Node != null)
        {
            posOrder(Node.left);
            posOrder(Node.right);
            System.out.print(Node.element + " ");
        }
    }

    /*
     * 层序遍历
     * 递归
     */
    public void levelOrder(BinaryNode<AnyType> Node) {
        if (Node == null) {
            return;
        }

        int depth = depth(Node);

        for (int i = 1; i <= depth; i++) {
            levelOrder(Node, i);
        }
    }

    private void levelOrder(BinaryNode<AnyType> Node, int level) {
        if (Node == null || level < 1) {
            return;
        }

        if (level == 1) {
            System.out.print(Node.element + "  ");
            return;
        }

        // 左子树
        levelOrder(Node.left, level - 1);

        // 右子树
        levelOrder(Node.right, level - 1);
    }

    public int depth(BinaryNode<AnyType> Node) {
        if (Node == null) {
            return 0;
        }

        int l = depth(Node.left);
        int r = depth(Node.right);
        if (l > r) {
            return l + 1;
        } else {
            return r + 1;
        }
    }

    public static void main( String[] args )
    {
        int[] input = {4, 2, 6, 1, 3, 5, 7, 8, 10};
        Tree<Integer> tree = new Tree<>();
        for(int i = 0; i < input.length; i++)
        {
            tree.insert(input[i]);
        }
        System.out.print( "前序遍历 ：" );
        tree.preOrder(tree.root);
        System.out.print( "\n中序遍历 ：" );
        tree.midOrder(tree.root);
        System.out.print( "\n后序遍历 ：" );
        tree.posOrder(tree.root);
        System.out.print("\n递归层序遍历：");
        tree.levelOrder(tree.root);
    }
}

两主机通信的过程，从发送者（以下简称A）到接收者（以下简称B），属于从7层（应用层）->1层（物理层）封装，然后传输到远端，再从1层（物理层）->7层（应用层）解封装的过程。
1、当A打开了QQ这个软件，相当就到达应用层了；因为软件会根据你的操作调动机器底层的硬件工作了。
2、当A往QQ这个软件的聊天窗口里面输入信息，发出后，QQ会将这个信息保存在本地聊天记录文件MSGEX.db（一般就保存在QQ目录下以你的QQ号码为文件夹里）。以某种格式编码/保存某种信息，这可以理解为表示层了。
3、当A打开与B的聊天窗口，输入信息，按下“输入”按钮，用户的操作就完结了，剩下都是机器自己的操作了。实际传输之前QQ会先建立A与B的会话连接，才真正开始传输信息/数据（你可以理解借传输文件理解：你发送文件给对方，要等待对方按下接收，才算建立了会话，然后才开始传输。）这算会话层了。
4、会话建立后，会将A发的信息斩件，如A发送“你吃了饭没有”？传输层将这句话斩成“你”“吃”“了”“饭”“没”“有”6个数据段，标记好使用的端口号，然后准备发出去。
5、接上一层，信息还未发出去，这时候在网络层做路由选路，可以理解为，从A家出去，可以分别经“联通”“电信”“移动”3个网络中的一个再到B家。网络层根据路由协议负责选路（根据链路质量、带宽、开销等方法论）。假设最后选了2条，可能就A->联通->B发送“你”“吃”“了”3个数据段，A->电信->B发送“饭”“没”“有”3个数据段。选路后，这一层要标记IP包头，包头主要内容是源IP地址，目的IP地址，使用什么协议。其中源、目的IP相当于你寄信的时候的收发的地址与邮政编码，标记出发送者与接收者。而协议相当于这封信到底用什么语言书写。（只有保证2端使用同种语言，才能确保通信起来，否则你用英文写信给大妈，大妈怎么看得懂呢？）
6、然后再到数据链路层，数据链路层主要是负责同一个子网内的通信的。例如A、B连接在同一台二层交换机，就属于同一个子网，那么数据帧的通信室是不需要通过网络层的（即三层交换机或者路由器），直接在这台二层交换机就过去了。这一层打的是MAC地址的帧头，对于上述通信过程来说，就是为数据帧打上A的机器的MAC与A的网关的MAC。这一层的工作就完成了。
7、最后一层了，经过上述斩件、打完各层标签后的6个数据帧，物理层将他们翻译文6段0、1表示的比特流，然后通过光纤、铜缆进行传输。8、当比特流传输到了远端，接着B的机器按照上述的1~7的步骤反方向运行一次即可（即有物理层到应用层）。就是一层层读取标签，传输给标签标记着的相应对象，然后摘除标签，再读取上一层标签，直到最后B的应用程序能够读到A往应用程序输入的数据为止。

以TCP/IP协议五层模型的计算机网络率先出现，硬件接口实现“物理层”、“数据链路层”，操作系统内核里的TCP/IP协议栈实现“网络层”、“传输层”，所有依赖于TCP/IP协议栈的应用程序实现广泛意义上的“应用层”，这个广泛意义的“应用层”既实现了会话ID、心跳keepalive，又实现了诸如文字、图片、音频、视频、文件的不同表示。后来才有以TCP/IP为现实素材的OSI七层参考模型，希望将“会话层”、“表示层”从广泛意义上的应用层里独立出来，但这两层在实际应用中很难保持统一性，应用通常会选择不同的加解密方式，不同的语义和时序，谈不上复用的东西作为协议的一部分自然是没有意义的，所以这两层的功能交给应用开发者作为应用层的一部分功能开发是比较合适的。

在每一层都工作着不同的设备，常用的交换机就工作在数据链路层的，一般的路由器是工作在网络层的。

每一层实现的协议也各不同，即每一层的服务也不同。

（安全层）
作为一个提供安全加密服务层，很多人都使用过，只是一直没有人想去划分层次结构，它的名字叫SSL/TLS，有了它的加入，我们可以将TCP/IP五层结构看成六层：
应用层
安全层（TLS）
传输层（TCP/UDP）
网络层（IP）
数据链路层（ppp）
物理层
有了安全层提供的服务，位于应用层的HTTP/SMTP/FTP，都可以在其名字后加一个S（Security），比如HTTPS，其实这个世界压根不存在HTTPS协议，只有HTTP协议，加上S的后缀只是告诉大家HTTP使用的是六层结构，有了SSL/TLS的安全保护。
---------------------

标签：Node,结点,遍历,int,二叉,搜索,二叉树,节点,BinaryNode
来源： https://blog.csdn.net/samHuangLiang/article/details/91859733