一 搜索树：
1.概念： 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: (1). 若它的左子树不为空，则 左子树上所有节点的值都小于根节点的值 (2). 若它的右子树不为空，则 右子树上所有节点的值都大于根节点的值 (3). 它的左右子树也分别为二叉搜索树
2.操作：
(1).查找：
你要插入，删除都要先找到要操作的节点；要找到要操作的位置简单来说就是，要查找的key大就往右边找，key小就往左边找，要满足搜索二叉树的概念。
时间复杂度：最坏情况：O(N)
最好情况: O (logN)
图解：
代码：
代码语言：javascript复制/**
* 搜索：
* 时间复杂度：最坏情况 O(N), 最好情况：O(logN)
* @param key
* @return
*/
public TreeNode search(int key) {
TreeNode cur = root;
if (cur == null) {
return null;
}
while (cur != null) {
if (cur.val > key) {
cur = cur.left;
}else if (cur.val < key) {
cur = cur.right;
}else {
return cur;
}
}
return null;
}(2).插入:
插入，为空就直接插入，不为空就找到要插入的位置然后插入，这个时候定义一个变量parent来记录插入的前一个位置。
图解：
代码：
代码语言：javascript复制 //插入
public void insert(int key) {
if (root == null) {
root = new TreeNode(key);
return;
}
TreeNode cur = root;
TreeNode node = new TreeNode(key);
TreeNode parent = null;
//找到要插入的位置
while (cur != null) {
if (cur.val > key) {
parent = cur;
cur = cur.left;
}else if (cur.val < key) {
parent = cur;
cur = cur.right;
}else {
//搜索二叉树，不会插入相同的节点
return;
}
}
//插入
if (parent.val > key) {
parent.left = node;
}else {
parent.right = node;
}
}(3) 删除（难点,情况比较多）:
分为三种情况：
要删除节点左边为空：
(1). cur 是 root，则 root = cur.right
(2). cur 不是 root，cur 是 parent.left，则 parent.left = cur.right
(3). cur 不是 root，cur 是 parent.right，则 parent.right = cur.right
要删除节点右边为空：（情况二和情况一差不多）
(1).cur 是 root，则 root = cur.left
(2).cur 不是 root，cur 是 parent.left，则 parent.left = cur.left
(3).cur 不是 root，cur 是 parent.right，则 parent.right = cur.left
要删除节点左右边都为空：这个我们采用替换删除，就是 左树找到最大值，或者右树找到最小值，来替换，并删除替换节点的原位置。
下图用的是左树找到最大值： （而我写的代码是，t往右边走找最小值）
/**删除有三种情况：
* 1.cur的左边为空
* 2.cur的右边为空
* 1.cur的左右两边都不为空
*/
private void removeNode(TreeNode parent, TreeNode cur) {
if (cur.left == null) {
if (cur == root) {
root = cur.right;
}else if (cur == parent.left) {
parent.left = cur.right;
}else {
parent.right = cur.right;
}
}else if (cur.right == null) {
if (cur == root) {
root = cur.left;
}else if (cur == parent.left) {
parent.left = cur.left;
}else {
parent.right = cur.left;
}
}else {
TreeNode tp = cur;
TreeNode t = cur.right;
while (t.left != null) {
tp = t;
t = t.left;
}
cur.val = t.val;//交换
//删除
if (tp.left == t) {
tp.left = t.right;
}else {
tp.right = t.right;
}
}
}
}3.性能分析： 插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。 对有n 个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即 结点越深，则比较次数越多 。
4.搜索树 java 类集的关系： 1.TreeMap 和 TreeSet 即 java 中利用搜索树实现的 Map 和 Set；实际上用的是红黑树，而红黑树是一棵近似平衡的二叉搜索树，即在二叉搜索树的基础之上 颜色以及红黑树性质验证
二. 搜索相关概念 ：
1.概念及场景 ： Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。 2.模型： 一般把搜索的数据称为关键字（Key），和关键字对应的称为值（Value），将其称之为Key-value的键值对，所以模型会有两种： 1.纯 key 模型 2.Key-Value 模型
三.Map 的说明 ：
1 关于 Map 的说明：
Map是一个接口类 ，该类 没有继承自Collection ，该类中 存储的是<K,V>结构的键值对 ，并且 K 一 定是 唯一的，不能重复。
2.关于 Map.Entry<K, V> 的说明：
Map.Entry<K, V> 是Map内部实现的用来 存放<key, value>键值 对映射关系的 内部类 ， 该内部类中主要提供了 <key, value>的获取，value的设置以及Key的比较方式。
注意：Map.Entry<K,V>并没有提供设置Key的方法
3 Map 的常用方法说明 ：
总结：
1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
2. Map中存放键值对的Key是唯一的，value是可以重复的
3. 在TreeMap中插入键值对时，key不能为空，否则就会抛NullPointerException异常，
value可以为空。但 是HashMap的key和value都可以为空。
4. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
5. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
6. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行 重新插入。
7. TreeMap和HashMap的区别：
4 TreeMap 的使用：
代码语言：javascript复制 public static void main(String[] args) {
Map<String, String> m = new TreeMap<>();
// put(key, value):插入key-value的键值对
// 如果key不存在，会将key-value的键值对插入到map中,返回null
m.put("林冲", "豹子头");
m.put("鲁智深", "花和尚");
m.put("武松", "行者");
m.put("宋江", "及时雨");
String str = m.put("李逵", "黑旋风");
System.out.println(m.size());
System.out.println(m);
// put(key,value): 注意key不能为空，但是value可以为空
// key如果为空，会抛出空指针异常
//m.put(null, "花名");
str = m.put("无名", null);
System.out.println(m.size());
// put(key, value):
// 如果key存在，会使用value替换原来key所对应的value，返回旧value
str = m.put("李逵", "铁牛");
// get(key): 返回key所对应的value
// 如果key存在，返回key所对应的value
// 如果key不存在，返回null
System.out.println(m.get("鲁智深"));
System.out.println(m.get("史进"));
//GetOrDefault(): 如果key存在，返回与key所对应的value，如果key不存在，返回一个默认值
System.out.println(m.getOrDefault("李逵", "铁牛"));
System.out.println(m.getOrDefault("史进", "九纹龙"));
System.out.println(m.size());
}结果：
四. Set 的说明：
1 常见方法说明 ：
注意：
(1). Set是继承自Collection的一个接口类
(2). Set中只存储了key，并且要求key一定要唯一
(3). TreeSet的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
(4) . Set最大的功能就是对集合中的元素进行去重
(5). 实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在HashSet的基础 上维护了一个双向链表来记录元素的插入次序。
(6). Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入
(7). TreeSet中不能插入null的key，HashSet可以。
2 TreeSet 的使用案例：
这里注意： TreeSet可以使用Interator遍历。
代码语言：javascript复制 public static void main(String[] args) {
Set<String> s = new TreeSet<>();
// add(key): 如果key不存在，则插入，返回ture
// 如果key存在，返回false
boolean isIn = s.add("apple");
s.add("orange");
s.add("peach");
s.add("banana");
System.out.println(s.size());
System.out.println(s);
isIn = s.add("apple");
// add(key): key如果是空，抛出空指针异常
//s.add(null);
// contains(key): 如果key存在，返回true，否则返回false
System.out.println(s.contains("apple"));
System.out.println(s.contains("watermelen"));
// remove(key): key存在，删除成功返回true
// key不存在，删除失败返回false
// key为空，抛出空指针异常
s.remove("apple");
System.out.println(s);
s.remove("watermelen");
System.out.println(s);
System.out.println();
Iterator<String> it = s.iterator();
while(it.hasNext()){
System.out.print(it.next() " ");
}
System.out.println();
}
五.哈希表：
1 概念:
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，
即O(logN)，搜索的效率取决于搜索过程中元素的比较次数。
如果构造一种存储结构，通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(或者称散列表)
下面是利用key和散列表长度构建哈希：
公式就是 （你要的放的） key % capcity （列表长度）
方法：根据待插入元素的关键码， 以此公式计算出该元素的存储位置并按此位置进行存放
2 冲突的 概念 ：
对于两个数据元素的关键字ki,kj 和 (i != j)，有 != ，但有：Hash(ki) == Hash(kj)，即： 不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
简单来说就是不同的值通过哈希函数计数出，相同的位置。
3.冲突的 避免 ：
通过调节负载因子，和设计合理的哈希函数。
4.通过负载因子调节避免冲突：
解决哈希冲突两种常见的方法是：闭散列和开散列，这里重点说说开散列（哈希桶）
(1). 散列表的负载因子定义：等于 填入表中的元素个数 / 散列表的长度
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。由散列表的负载因子定义可知，我们通过增加散列表的长度来调节冲突(下面代码会呈现)
5. 解决哈希冲突两种常见的方法是：闭散列和开散列
闭散列： 也叫开放定址法 ，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然 还有空位置，那么可以把 key存放到冲突位置中的“下一个” 空位置 中去。
在这个过程中会发生， 线性探测和二次线性探测（ 线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止 ）。
6.开散列/哈希桶(重点)：
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
如图：
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素
7.哈希桶的实现：
注意：
key：关键码通过散列函数计算出的散列地址
val：节点对应的值
next：向后连接相同散列地址的节点地址
节点和散列表的创建：
代码语言：javascript复制public class MyHashBuck {
static class Node{
public int key;
public int val;
public Node next;
public Node(int key, int val) {
this.key = key;
this.val = val;
}
}
public Node[] array = new Node[10];
public int usedSize;
public static final double DEFAULT_LOAD_FACTOR = 0.75f;//负载因子负载因子的判断：
代码语言：javascript复制//负载因子 == 表中元素个数个数 / 表长
private double doLoadFactor() {
return usedSize*1.0 / array.length;
}插入：
代码语言：javascript复制 public void push(int key, int val) {
//开始哈希
int index = key % array.length;
Node cur = array[index];
while (cur != null) {
//不能有相同的节点
if (cur.key == key) {
cur.val = val;
return;
}
cur = cur.next;
}
//当前链表没有Key这个节点
//头插：
Node node = new Node(key,val);
node.next = array[index];
array[index] = node;
usedSize ;
if (doLoadFactor() >= DEFAULT_LOAD_FACTOR) {
resize();
}
}扩容（降低哈希冲突）：
这里注意不能直接，简单扩容数组，一定要重新哈希，这样才可以把，原来的哈希位置放到正确新对应的散列地址处,。不可以使用cur = cur.next ，因为这里重新扩容了一个数组，重新哈希时要先记录一下cur.next，插入之后再往后，遍历下一个。
代码语言：javascript复制private void resize() {
Node[] newArray = new Node[2*array.length];
for (int i = 0; i < array.length; i ) {
//扩容后要遍历链表的每一个节点
//重新哈希
Node cur = array[i];
while (cur != null) {
int newIndex = cur.key % newArray.length;//重新遍历每一个位置
//头插：
//重新扩容了一个数组，重新哈希时要先记录一下cur.next，插入之后再往后，遍历下一个。
Node curN = cur.next;
cur.next = newArray[newIndex];
newArray[newIndex] = cur;
cur = curN;
}
}
array = newArray;
}获取val:
代码语言：javascript复制public int getVal(int key) {
int index = key % array.length;
Node cur = array[index];
while (cur != null) {
//不能有相同的节点
if (cur.key == key) {
return cur.val;
}
cur = cur.next;
}
return -1;
}8.性能分析 ： 虽然哈希表一直在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的， 也就是每个桶中的链表的长度是一个常数，所以，通常意义下，我们认为哈希表的插入/删除/查找时间复杂度是O(1) 。 9. 哈希表 和 java 类集的关系： 1. HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set 2. java 中使用的是哈希桶方式解决冲突的 3. java 会在冲突链表长度大于一定阈值后(在链表长度超过8，数组长度超过64)，将链表转变为搜索树（红黑树） 4. java 中计算哈希值实际上是调用的类的 hashCode 方法，进行 key 的相等性比较是调用 key 的 equals 方法。所以如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值，必须覆写 hashCode 和 equals 方法，而且要做到 equals 相等的对象，hashCode 一定是一致的。
