计算机基础-数据结构

树

1 搜索二叉树：每个节点有两个子节点，数据量的增大必然导致高度的快速增加，显然这个不适合作为大量数据存储的基础结构。
　　2 B树：一棵m阶B树是一棵平衡的m路搜索树。最重要的性质是每个非根节点所包含的关键字个数 j 满足：┌m/2┐ - 1 <= j <= m - 1；一个节点的子节点数量会比关键字个数多1，这样关键字就变成了子节点的分割标志。一般会在图示中把关键字画到子节点中间，非常形象，也容易和后面的B+树区分。由于数据同时存在于叶子节点和非叶子结点中，无法简单完成按顺序遍历B树中的关键字，必须用中序遍历的方法。
　　3 B+树：一棵m阶B树是一棵平衡的m路搜索树。最重要的性质是每个非根节点所包含的关键字个数 j 满足：┌m/2┐ - 1 <= j <= m；子树的个数最多可以与关键字一样多。非叶节点存储的是子树里最小的关键字。同时数据节点只存在于叶子节点中，且叶子节点间增加了横向的指针，这样顺

二叉树

叶子节点都在最后一层 节点总是是2N次方-1 n层数

节点
根节点
父节点
子节点
叶子节点 没有子节点
节点值 节点的权
路径 从root节点找到该节点的路线
层
子树
树的高度（最大层数）
森林 多颗子树构成森林

最多只有两个子节点

完全二叉树

完全二叉树 叶子节点在最后一层或倒数第二层
最后一层的叶子节点在左边连续
倒数第二层的叶子节点在右边连续

连续 不连续

只考虑完全二叉树
第n个元素的左子节点下标为2n+1
第n个元素的右子节点下标为2n+2
第n个元素的父节点下标为(n-1)/2
n表示二叉树的第几个元素 按0开始编号

顺序存储二叉树

数组存储方式和数的存储方式 相互转换
数组可以转换成树 树可以转换成数组
要求：
1)二叉树右图的数据节点 要求以数组的方式存放
[1,2,3,4,5,6,7]
遍历这棵树 以树的方式遍历
前序遍历 中序遍历 后续遍历
遍历数组arr 仍然可以以前序遍历 中序遍历 后续遍历方式
完成数据节点的遍历
数组顺序结构遍历

线索化二叉树

{1,3,6,8,10,14}
完全二叉树
问题 指针没有充分利用
二叉树中序遍历 数列为{8,3,10,1,6,14}

n+1
空指针
二叉树
n+1=7个空指针
存放指向该节点的遍历次序下的前驱和后续结点
线索化二叉树
n个节点 二叉链表 中含有n+1公式2n-(n-1)=n+1个空指针
利用二叉链表中的空指针阈
存放指向结点在某种遍历次序下的前驱和
将数列{1,3,6,8,10,14}构成一颗二叉树
各个节点可以指向自己的前后节点

下一个节点 中序遍历 后面的每一个节点 指向该节点的
在某种遍历次序下的前驱和后继节点

2n-(n-1)=n+1个空指针阈
存放指向该节点某种遍历次序下的前驱和后继结点的指针
附加指针叫线索

赫夫曼树

赫夫曼编码

1从小到大排序 将每一个数据（节点）看成是一颗简单的二叉树
2取出根节点权值最小的两颗二叉树 3组成一颗新的二叉树
该新的二叉树根节点的权值 是前面两颗二叉树根节点权值的和
4再将这颗新的二叉树 以根节点的权值大小再排序 不断重复1-2-3-4步骤 直到数列中
所有的数据都被处理 就得到一颗赫夫曼树

字符-个数 次数作为权值
给各个字符编码
向左路径0 向右路径1
0 1
Y权值 最小 100011
前缀编码 每一个字符的编码 不会是另一个编码的前缀
匹配的时候 不会出现 独立性
无损压缩
匹配
空格
另一个

通过赫夫曼编码 长度133

排序方法不同可能不一样
权值不同

赫夫曼编码不一样 wpl是一样的
最终的wpl是最小 大小

编码不一样 长度是一样的
无损压缩

二叉排序树BST

数组
链式存储 链表
树存储

{7,3,10,15,19}
任何一个非叶子节点 左子节点比当前节点小
右子节点比当前节点的值大
如果有相同的值 将该节点放在左子节点或右子节点
尽量避免

平衡二叉树AVL

左子树全部为空 单链表
查询速度明显降低
二叉搜索树
空树 两个子树的高度差的绝对值不超过1 左右子树都是平衡二叉树

2-3最简单的B树

叶子节点在同一层
有两个子节点的节点叫二节点
二节点要么没有子节点 要么有两个字节点
三个子节点 要么没有 要么有三个子节点
2-3树是由二节点和三节点树
234树

B树 B+树 B星 多路查找

是平衡 搜索排序树
B-树 就是B树
B树的阶：节点的最多子节点个数 2-3-4树

搜索：根节点->二分查找->儿子节点->叶子节点
叶子节点和非叶子节点都存放数据
性能等价于在关键字全集内做二分查找
线性对数阶

B+树

所有数据在叶子节点
关键字在叶子节点的链表中 关键字有序
稠密索引

上面代表索引
非叶子节点 是叶子节点的索引 稀疏索引
叶子节点 相当于数据层 稠密索引
适合文件索引系统
28 99
从头开始
表分割几个部分 目录的目录
降低索引的高度

B*树

在B+树的非根和非叶子节点添加兄弟关系
增加指向兄弟的指针
定义了非叶子节点关键字个数至少为（2/3）*M
即块的最低使用率为2/3
而B+树的块的最低使用率为B+树的1/2

B*树分配新节点的概率比B+树低
空间使用率更高
2^6<100<27

升序
降序

稀疏数组

(大写）
row col val
0 11 11 2 个数 有效数据
1 2 1 有效数坐标 数值
2 3 2 有效数坐标 数值

二维数组->稀疏数组
1.遍历原始的二维数组 得到有效 数据个数sum
2.根据sum 可以创建稀疏数组 [sum+1] [3]
3 将二维数组的有效数据存入到稀疏数组中

稀疏数组->保存到磁盘

磁盘文件->稀疏数组->二维数组
1、读取稀疏数组的第一行 根据第一行的数据 创建原始的二维数组
2 读取稀疏数组后几行的数组 赋值给原始的二维数组

队列

数组实现
maxSize 最大容量
class front rear
前后端 处理
记录队列的前后端
front随着数据输出改变

addQueue

尾指针 rear+1 front==rear 空的 未满 
rear < maxSize -1 
maxSize 最大容量 

数组模拟环形队列
取模 %

取出数据 空间能再次使用
rear
front

思路
front 变量含义 做调整 front->队列的第一个元素
arr[front] 队列的第一个元素

rear 指向队列的最后一个元素的后一个位置
希望留空一个空间作为约定

当队列满时 条件 (rear+1) % maxSize = front [满]
队列为空的条件 rear = front 空

队列中有效的数据个数 (rear+maxSize- front) & maxSize

单向链表

添加到链表的尾部

单链表 创建示意图
显示单向链表的一个分析

指向下一个节点阈值
head节点
1 不存放放具体的数据
2 表示单链表的头

Hero节点 node节点
next阈值
数据
next

最后一个节点默认为null

添加（创建）
1、先创建一个head节点 作用表示单链表的头部
2、后面每添加一个节点 就直接加入到链表的最后遍历
遍历
通过一个辅助变量 帮助遍历整个链表

class HeroNode{
int no
String name
String nickName
HeroNode.next
}

插入指定位置 有这个排名 添加失败

需要按照编号的顺序添加
找到新添加的节点的位置 通过辅助遍历（指针）遍历
新的节点next = temp.next
将temp.next = 新的节点

修改节点代码实现
思路
先找到该节点 通过遍历
temp.name = newHeroNode.name
temp.nickname = newHero.NickName

删除节点
找到需要删除的节点的前一个节点temp
temp.next = temp.netx.next
被删除的节点 将不会有其他引用指向 GC

存在的问题
查找的方向 只能是一个方向
删除节点 靠辅助节点 找前一个节点 不能实现自我删除
找到待删除的
temp 是带删除节点的前一个节点

双向链表

head
不存放数据
表示单链表头next

尾结点
pre 指向前一个节点
next null

遍历方式和单链表一样 可以向前 也可以向后

添加(默认添加到双向链表的最后)
先找到双向链表的最后节点
temp.next=newHeroNode
newHeroNode.pre=temp;

修改和单向链表

删除
找到删除节点
temp.pre.next.temp = next
temp.next.pre = temp.pre

使用数组模拟
定义一个top表示栈顶 初始化为-1
入栈的操作 当有数据加入栈 top++ stack[top]=data;
出栈
int value = stack[top];
top --;
return value

二分查找

二分查找 只适用于有序数列查找 数列排序然后查找
O(log2n)

数据必须有序
思路分析
1.确定该数组中间的下标 mid
mid = (left+right)/2
2.然后让需要查找的数findval和arr(mid)比较
2.1. findVal>arr[mid] 要查找的数在mid的右边
需要递归 向右查找
如果 findval <arr[mid]
你要查找的数在mid的左边 递归向左查找

findval == arr[mid]说明找到 就返回

退出递归
1 找到结束
2 找不到 递归完 整个数组 仍然没找到findvalue
也需要结束递归

当left>right就需要退出 重合 还不行 移动
不使用递归实现（while循环）

/**
	 * 不使用递归的二分查找
	 *title:commonBinarySearch
	 *@param arr
	 *@param key
	 *@return 关键字位置
	 */
	public static int commonBinarySearch(int[] arr,int key){
		int low = 0;
		int high = arr.length - 1;
		int middle = 0;			//定义middle
		
		if(key < arr[low] || key > arr[high] || low > high){
			return -1;				
		}
		
		while(low <= high){
			middle = (low + high) / 2;
			if(arr[middle] > key){
				//比关键字大则关键字在左区域
				high = middle - 1;
			}else if(arr[middle] < key){
				//比关键字小则关键字在右区域
				low = middle + 1;
			}else{
				return middle;
			}
		}
		
		return -1;		//最后仍然没有找到，则返回-1
	}

插值查找

1,2,3,4,5,6,7,8,9,10

自适应的方案 快速定位 查找的值

插值查找算法 工作原理
二分查找
自适应mid开始查找

left right
1/2

查找的值
插值索引
int mid=left+(right-left)*(finval-arr[left])/(arr[right]-arr[left])

arr = [1,2,3,4…]

黄金分割法

斐波那契数列
0.618
无线
前面两个数之和
改变中间结点的位置 位于黄金分割点附近
mid=low+F(k-1)-1 F数列 k第几个元素
F(K)=F(K-1)+F(k-2)
F[K]-1=(F[K-1]-1 + F[k-2]-1)+1
顺序表n不一定等于F[k]-1 增加至F[k}-1
while(n>fib(k)-1) k++
需要扩容

哈希表

数组+链表
数组+二叉排序树
二级缓存 再哈希 rehash

布隆过滤器

布隆过滤器
在日常生活中，包括在设计计算机软件时，我们经常要判断一个元素是否在一个集合中。比如在字处理软件中，需要检查一个英语单词是否拼写正确（也就是要判断它是否在已知的字典中）；在 FBI，一个嫌疑人的名字是否已经在嫌疑名单上；在网络爬虫里，一个网址是否被访问过等等。最直接的方法就是将集合中全部的元素存在计算机中，遇到一个新元素时，将它和集合中的元素直接比较即可。一般来讲，计算机中的集合是用哈希表（hash table）来存储的。它的好处是快速准确，缺点是费存储空间。当集合比较小时，这个问题不显著，但是当集合巨大时，哈希表存储效率低的问题就显现出来了。比如说，一个像 Yahoo,Hotmail 和 Gmai 那样的公众电子邮件（email）提供商，总是需要过滤来自发送垃圾邮件的人（spamer）的垃圾邮件。一个办法就是记录下那些发垃圾邮件的 email 地址。由于那些发送者不停地在注册新的地址，全世界少说也有几十亿个发垃圾邮件的地址，将他们都存起来则需要大量的网络服务器。如果用哈希表，每存储一亿个 email 地址， 就需要 1.6GB 的内存（用哈希表实现的具体办法是将每一个 email 地址对应成一个八字节的信息指纹googlechinablog.com/2006/08/blog-post.html，然后将这些信息指纹存入哈希表，由于哈希表的存储效率一般只有 50%，因此一个 email 地址需要占用十六个字节。一亿个地址大约要 1.6GB， 即十六亿字节的内存）。因此存贮几十亿个邮件地址可能需要上百 GB 的内存。除非是超级计算机，一般服务器是无法存储的。
布隆过滤器只需要哈希表 1/8 到 1/4 的大小就能解决同样的问题。
Bloom Filter是一种空间效率很高的随机数据结构，它利用位数组很简洁地表示一个集合，并能判断一个元素是否属于这个集合。Bloom Filter的这种高效是有一定代价的：在判断一个元素是否属于某个集合时，有可能会把不属于这个集合的元素误认为属于这个集合（false positive）。因此，Bloom Filter不适合那些“零错误”的应用场合。而在能容忍低错误率的应用场合下，Bloom Filter通过极少的错误换取了存储空间的极大节省。
下面我们具体来看Bloom Filter是如何用位数组表示集合的。初始状态时，Bloom Filter是一个包含m位的位数组，每一位都置为0，如图9-5所示。

为了表达S={x1, x2,…,xn}这样一个n个元素的集合，Bloom Filter使用k个相互独立的哈希函数（Hash Function），它们分别将集合中的每个元素映射到{1,…,m}的范围中。对任意一个元素x，第i个哈希函数映射的位置hi(x)就会被置为1（1≤i≤k）。注意，如果一个位置多次被置为1，那么只有第一次会起作用，后面几次将没有任何效果。如图9-6所示，k=3，且有两个哈希函数选中同一个位置（从左边数第五位）。

在判断y是否属于这个集合时，我们对y应用k次哈希函数，如果所有hi(y)的位置都是1（1≤i≤k），那么我们就认为y是集合中的元素，否则就认为y不是集合中的元素。如图9-7所示y1就不是集合中的元素。y2或者属于这个集合，或者刚好是一个false positive。

为了add一个元素，用k个hash function将它hash得到bloom filter中k个bit位，将这k个bit位置1。
· 为了query一个元素，即判断它是否在集合中，用k个hash function将它hash得到k个bit位。若这k bits全为1，则此元素在集合中；若其中任一位不为1，则此元素比不在集合中（因为如果在，则在add时已经把对应的k个bits位置为1）。
· 不允许remove元素，因为那样的话会把相应的k个bits位置为0，而其中很有可能有其他元素对应的位。因此remove会引入false negative，这是绝对不被允许的。
布隆过滤器决不会漏掉任何一个在黑名单中的可疑地址。但是，它有一条不足之处，也就是它有极小的可能将一个不在黑名单中的电子邮件地址判定为在黑名单中，因为有可能某个好的邮件地址正巧对应一个八个都被设置成一的二进制位。好在这种可能性很小，我们把它称为误识概率。
布隆过滤器的好处在于快速，省空间，但是有一定的误识别率，常见的补救办法是在建立一个小的白名单，存储那些可能个别误判的邮件地址。
布隆过滤器具体算法高级内容，如错误率估计，最优哈希函数个数计算，位数组大小计算，请参见http://blog.csdn.net/jiaomeng/article/details/1495500。