面向丈母娘编程
面向丈母娘编程

高阶查找算法第一篇

文章目录

  • 顺序表查找
    • 顺序表查找算法
    • 顺序表查找优化
  • 有序表查找
    • 折半查找
    • 差值查找
    • 斐波那契查找
    • 总结
  • 线性索引查找
    • 稠密索引查找
    • 分块索引
    • 倒排索引
  • 二叉排序树
    • 二叉排序树查找操作
    • 二叉排序树插入操作
    • 二叉排序树删除操作
    • 二叉排序树总结
  • 散列表(哈希表)
    • 散列表查找定义
    • 散列表查找步骤
    • 散列表函数的构造方法
      • 直接定址法
      • 数字分析法
      • 平方取中法
      • 折叠法
      • 除留余数法
      • 随机数法
    • 处理散列冲突的方法
      • 开放定址法
      • 再散列函数法
      • 链地址法
      • 公共溢出区法
    • 散列表查找算法实现
    • 散列表查找性能分析
  • 位图
    • 面试题
    • 位图的数据结构
    • 位图的实现
    • 位图的应用
    • 位图的缺陷
  • 布隆过滤器
    • 布隆过滤器数据结构
    • 布隆过滤器的实现
    • 布隆过滤器的应用
    • 布隆过滤器的缺陷
    • 扩展部分
      • 一致性哈希
        • 普通哈希
        • 一致性哈希算法
      • 一致性哈希优点
      • 哈希环的倾斜与虚拟节点
      • 哈希与加密
        • 穷举法模拟一次简单的哈希加密破解
  • 并查集
    • 并查集数据结构
    • 并查集实现
  • LRUCache
    • LRUCache数据结构
    • LRUCache实现
      • 通过继承LinkedHashMap实现
      • 手写双向链表借助HashMap实现
    • [146. LRU 缓存](https://leetcode.cn/problems/lru-cache/)
  • 初阶查找算法总结

顺序表查找

顺序表查找算法

C代码

/*顺序表查找: a为数组, n为要查找的数组个数, key为要查找的关键字*/
int Sequence_Search(int *a, int n, int key){
    int i = 0;
    for(i = 0; i < n; ++i){
        if(a[i] == key){
            return i;
        }
    }
    return -1;
}

Java代码

/*顺序表查找: a为数组, key为要查找的关键字*/
private static int Sequence_Search(int[] a, int key){
    for (int i = 0; i < a.length; i++) {
        if (a[i] == key){
            return i;
        }
    }
    return -1;
}

这段代码很简单, 就是遍历数组a, 与关键字相等即返回下标 i; 遍历结束没有遇到相等就返回 -1

顺序表查找优化

到这里, 并不完美, 因为每次循环的时候都需要对 i是否越界 i 进行判断. 事实上有一个更好的办法, 可以设置一个 哨兵 就解决了每次不需要对 越界 的比较.

演示C代码

int Sequence_Search(int *a, int n, int key) {
    while (a[n-1] != key){
        --n;
    }
    return n-1;
}

免去了查找过程中每一次比较后要判断查找位置是否越界的小技巧, 看似与原先差别不大, 但在总数据较多时, 效率提高很大. 当然哨兵也并不一定非要放在数组开头也可以在数组末端.

算法时间复杂度
最好 O(1)
最坏 O(N)
平均 (N+1)/2 --> O(N)

当查找任何一个位置的概率相同时, 如果 n 很大, 查找效率极为低下, 有点是算法简单, 对静态表的记录没有任何要求, 在一些小型数据查找是可以适用.
由于查找效率不同, 完全可以吧容易查找到的记录放在前面, 而不常用的记录放置在后面, 效率也可以提高.

有序表查找

折半查找

C代码

/*折半查找*/
int Binary_Search(int *a, int n, int key) {
    int low = 0, high = n - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (a[mid] < key) {
            low = mid + 1;
        } else if (a[mid] > key) {
            high = mid - 1;
        } else {
            return mid;
        }
    }
    return -1;
}

Java代码

private static int Binary_Search(int a[], int key) {
    int low = 0, high = a.length - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (a[mid] < key) {
            low = mid + 1;
        } else if (a[mid] > key) {
            high = mid - 1;
        } else {
            return mid;
        }
    }
    return -1;
}
时间复杂度
最好 O(1)
最坏 O(logN)
平均 (1+logN)/2 --> logN

O(logN) 的复杂度远好于顺序表查找的 O(N), 对于静态查找表, 一次排序后不再变化, 这样的算法已经比较好了. 但是对于需要频繁执行插入或删除操作的数据集来说, 维护有序的排序会带来不小的工作量, 建议不要使用.

差值查找

从折半查照中可以看出，折半查找的查找效率还是不错的。可是为什么要折半呢？为什么不是四分之一、八分之一呢？打个比方，在牛津词典里要查找“apple”这个单词，会首先翻开字典的中间部分，然后继续折半吗？肯定不会，对于查找单词“apple”，我们肯定是下意识的往字典的最前部分翻去，而查找单词“zero”则相反，我们会下意识的往字典的最后部分翻去。所以在折半查找法的基础上进行改造就出现了插值查找法，也叫做按比例查找。所以插值查找与折半查找唯一不同的是在于mid的计算方式上

C代码

int Binary_Search(int *a, int n, int key) {
    int low = 0, high = n - 1;
    while (low <= high) {
        int mid = low + (int)((1.0 * key - a[low]) / (a[high] - a[low]) * (high - low));
        if (a[mid] == key) {
            return mid;
        } else if (a[mid] > key) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    return -1;
}

mid方法

mid = (low+high)/2 --略微变换得--> mid = low+1/2*(high-low)
再把 1/2 改为 (key-a[low])/(a[high]-a[low])
mid = low + (key-[a[low])/(a[high]-a[low])*(high-low)

通过改 mid 值就得到了 差值查找, 其核心在于要查找的关键字 key 与查找表中最大记录和最小记录的关键字比较后的查找算法, 核心在于差值公式比例 (key-a[low])/(a[high]-a[low]). , 该算法的时间复杂度也是O(logN), 对于表长较大, 关键字分布比较均匀的查找表来说, 差值查找的平均性能会比折半查找要好得多. 如果分布类似于[0, 1, 2, 2000, 2001, …, 99999, 9999999] 这样的极端不均匀的数据使用二分查找会更有效率

Java代码

private static int Binary_Search(int a[], int key) {
   int low = 0, high = a.length - 1;
   while (low <= high) {
       int mid = low + (int)((1.0*key-a[low])/(a[high]-a[low])*(high-low));
       if (a[mid] == key) {
           return mid;
       } else if (a[mid] > key) {
           high = mid - 1;
       } else {
           low = mid + 1;
       }
   }
   return -1;
}

斐波那契查找

斐波那契查找利用列黄金分割的原理实现的.

C代码

private static void ProduceFib(int[] F) {
    F[0] = 1;
    F[1] = 1;
    for (int i = 2; i < F.length; i++) {
        F[i] = F[i - 1] + F[i - 2];
    }
}

private static int Fibonacci_Search(int[] arr, int key) {
    int low = 0, high = arr.length - 1, mid = 0, k = 0, n = arr.length;
    int[] F = new int[n];
    ProduceFib(F);
    while (n > F[k] - 1) {
        ++k;
    }
    /*
    由于C语言可以用指针访问额外内存不会越界, 所以Java需要重新创建一个临时数组来保存原有数组且扩容
     */
    int[] tmp=new int[F[k]];
    System.arraycopy(arr,0,tmp,0, arr.length);
    for (int i = arr.length; i < F[k-1]; i++) {
        tmp[i]=arr[high];
    }
    while (low <= high) {
        mid = low + F[k - 1] - 1;
        if (tmp[mid] == key) {
            if (mid <= key) {
                return mid;
            } else {
                return high;
            }
        } else if (tmp[mid] < key) {
            low = mid + 1;
            k -= 2;
        } else {
            high = mid - 1;
            k -= 1;
        }
    }
    return -1;
}

区间示意图：
高阶查找算法第一篇_第1张图片

斐波那契查找算法的核心在于:

  1. a[mid] == key 时查找成功
  2. a[mid] < key 时, 查找范围就是 [low, mid+1], 此时查找范围个数就是 F[k-1]-1 个
  3. a[mid] > key 时, 查找范围就是 [mid+1, high], 此时查找范围个数就是 F[k-2]-1 个

总结

斐波那契如果查找记录在右侧, 则左侧的数据都不用判断, 不断反复进行下去, 对处于当中的大部分数据, 其工作效率会高一点. 所以尽管斐波那契数列查找的复杂时间都是O(logN)但就平均性能来说, 斐波那契查找要优于折半查找. 缺点: 当 key=1, 那么始终都处于左侧长半区查找, 则查找效率要慢于折半查找

  1. 折半查找进行加法与除法运算: low+1.0*(high-low)/2
  2. 插值查找复杂度是四则运算: low+1.0*(high-low)*(key-a[low])/(a[high]-a[low])
  3. 斐波那契查找是简单的加减运算: low+F[k-1]-1

线性索引查找

索引概念: 就是一个关键字于它对应的记录相关联的过程.
索引按照结构可以分为线性索引, 树形索引和多级索引. 这里参考的是《大话数据结构》中的内容, 因此就只介绍线性索引技术.线性索引: 就是将索引项集合组织为线性结构, 也称为索引表.

稠密索引查找

稠密索引: 在线性索引中, 将数据集中的每个记录对应一个索引项
高阶查找算法第一篇_第2张图片
稠密索引对应的数据可能是成千上万的是数据，因此对于稠密索引这个索引表来说，索引项一定是按照关键码有序的排列.

优点: 索引项有序也就意味着, 我们要查找关键字时, 可以用到折半, 插值, 斐波那契查找,等有序查找算法.
缺点: 如果数据非常大, 比如上亿, 也就意味着索引页的同样的数据长度规模, 对于内存有限的计算机来说, 可能就需要反复去访问磁盘, 查找性能反而大大下降.

分块索引

回想一下图书馆是如何藏书的. 显然她它会是顺序摆放后, 给我们一个稠密索引表去查, 然后再找到书给你. 图书馆的图书分摆放是一门非常完整的科学体系, 而他是最重要的一个特点就是分块.
稠密索引因为索引项与数据集的记录个数相同, 所以空间代价很大. 为了减少索引个数, 我么们可以对数据集进行分块, 使其分块有序, 然后再对每一块建立一个索引项, 从而减少索引项的个数.
分块有序是把数据集的记录分成了若干块, 并且这些块需要满足两个条件

  1. 块内无序, 即每一块内的记录不要求有序. 要求有序的话需要大量的时间和空间代价, 因此不要求块内有序
  2. 块间有序, 列如要求第二块所有记录的关键字均要大于第一块中所有记录的关键字, 第三块所有记录的关键字均要大于第二块所有记录的关键字. 因为只有块间有序, 才有可能在查找时带来效率.

示意图
高阶查找算法第一篇_第3张图片

最大关键码 存储每一块中的最大关键字, 这样的好处就是使得在它之后的下一块中的最小关键字也能比这一块最大关键字还要大
块长 记录块中元素个数, 便于循环遍历使用
指针 指向块首元素的指针, 便于开始对这一块中记录进行遍历

在分块索引表中查找, 分两步进行:

  1. 分块索引表中查找关键所在的块. 由于块间有序所以可以使用有序表查找
  2. 根据块首指针找到相应的块, 并在块间顺序查找关键码. 块间无序, 因此只能顺序查找

数学分析平均查找长度

假设有 n 个记录的数据被平均分成 m 块, 每个块中有 t 条记录. 显然 n=m*t, 或者说 m=n/t. 再假设 Lb 为查找索引表的平均长度, 因为最好与最差的概率相等, 所以 Lb 的平均长度为 (m+1)/2. Lw 为块中查找记录的平均长度, 同理可知它的平均查找长度为 (t+1)/2
这样分块索引查找的平均长度: ASLw=Lb+Lw=(m+1)/2+(t+1)/2=(m+t)/2+1=(n/t+t)/2+1
因此整个查找效率就与记录数 n 和和每一个块的记录个数 t有关
当n和t相等时, 即: n=m*t=t2, ASLw=(n/t+t)/2+=t+1= n \sqrt{n} n ​+1

由此可见分块索引的效率比顺序查找的 O(N) 是高了不少, 不过显然它与折半查找的 O(logN) 相比还有不少的差距. 因此在确定所在块的过程中, 由于块间有序, 所以可以应用折半, 插值等查找方法来提高效率.
总的来说, 分块索引在兼顾了对细分块不需要有序的情况下, 大大增加了整体查找的速度, 所欲i普遍被用于数据库表查找等技术的应用当中.

倒排索引

在这里介绍最简单的，也算是最基础的搜索技术: 倒排索引。
我们来看样例，现在有两篇极短的英文“文章”一其实 只能算是句子，我们暂认为它是文章，编号分别是1和2。

1.Books and friends should be few but good
2.A good book is a good friend
我们统计每个单词出现在那个文章中, 如图所示:

高阶查找算法第一篇_第4张图片
有了这样一张单词表，我们要搜索文章，就非常方便了。如果你在搜索框中填写“book”关键字。系统就先在这张单词表中有序查找“book" ，找到后将它对应的文章编号1和2的文章地址(通常在搜索引擎中就是网页的标题和链接)返回，并告诉你，查找到两条记录，用时0.0001秒。由于单词表是有序的，查找效率很高，返回的又只是文章的编号，所以整体速度都非常快。

如果没有这张单词表，为了能证实所有的文章中有还是没有关键字“book”, 则需要对每一篇文章每一个单词顺序查找。在文章数是海量的情况下，这样的做法只存在理论.上可行性，现实中是没有人愿意使用的。
在这里这张单词表就是索引表，索引项的通用结构是:

  1. 次关键码，例如上面的“英文单词”
  2. 记录号表，例如上面的“文章编号”

其中记录号表存储具有相同次关键字的所有记录的记录号(可以是指向记录的指针或者是该记录的主关键字)。这样的索引方法就是倒排索引(inverted index) 。倒排索引源于实际应用中需要根据属性(或字段、次关键码)的值来查找记录。这种索引表中的每- -项都包括-一个属性值和具有该属性值的各记录的地址。由于不是由记录来确定属性值，而是由属性值来确定记录的位置，因而称为倒排索引。
优缺点:

优点: 倒排索引的优点显然就是查找记录非常快，基本等于生成索引表后，查找时都不用去读取记录，就可以得到结果。但它的缺点是这个记录号不定长，比如上例有7个单词的文章编号只有一个，而"book", “friend”, “good” 有两个文章编号
缺点: 若是对多篇文章所有单词建立倒排索引，那每个单词都将对应相当多的文章编号,维护比较困难，插入和删除操作都需要作相应的处理。

二叉排序树

二叉排序树查找操作

C

#include 

#define TRUE 1
#define FALSE 0

typedef int Status;
typedef struct BitNode {//二叉排序树结构体
    int data;
    struct BitNode *lchild, *rchild;
} BitNode, *BiTree;

/*
 * 递归版本查找
 * f: 指向 T 的双亲, 其初始调用值为 NULL
 * 查找成功, 指针 p 指向该元素数据节点, 并返回 TRUE
 * 否则指针 p 指向查找路劲上访问的最后一个节点并返回 FALSE
 */
Status SearchBST(BiTree T, int key, BiTree f, BiTree *p) {
    if (!T) {//查找不成功
        *p = f;
        return FALSE;
    } else if (T->data == key) {
        *p = T;
        return TRUE;
    } else if (T->data < key) {
        SearchBST(T->rchild, key, T, p);//当前值 < key 就在右子树查找
    } else {
        SearchBST(T->lchild, key, T, p);//当前值 > key 就在左子树查找
    }
}

Java

/*
非递归版本
*/
private static BitNode SearchBST(BitNode root, int key) {
    while (root != null) {
        if (root.data < key) {
            root = root.rchild;
        } else if (root.data > key) {
            root = root.lchild;
        } else {
            break;
        }
    }
    return root;
}

二叉排序树插入操作

C

Status InsertBST(BiTree *T, int key){
    BiTree p, s;
    if(!SearchBST(*T, key, NULL, &p)){// 查找不成功
        s=(BiTree) malloc(sizeof(BitNode));
        s->data = key;
        s->lchild=s->rchild=NULL;
        if(!p){// 如果插入的节点为新节点
            *T = s;
        }else if(p->data < key){
            p->rchild=s;
        }else{
            p->lchild=s;
        }
        return TRUE;
    }else{
        return FALSE;//树中已有关键字 key
    }
}

Java

private static BitNode InsertBST(BitNode root, int val) {
    if (root == null) {
        return new BitNode(val);
    } else {
        /*
        非递归
         */
        BitNode par = null;
        BitNode cur = root;
        while (cur != null) {
            par = cur;
            if (cur.data < val) {
                cur = cur.rchild;
            } else if (cur.data > val) {
                cur = cur.lchild;
            }
        }
        if (par.data < val) {
            cur.rchild = new BitNode(val);
        } else {
            cur.lchild = new BitNode(val);
        }

        /*
        递归
        if (root.data < val){
            root.lchild=InsertBST(root.lchild, val);
        }else{
            root.rchild=InsertBST(root.rchild, val);
        }
        */
        return null;
    }

二叉排序树删除操作

C

// 递归版本
Status DeleteBST(BiTree *T, int key){
    if(!T){
        return FALSE;
    }else{
        if((*T)->data == key){/*找到关键字*/
            return DeleteBST(T, key);
        }else if((*T)->data < key){
            return DeleteBST(&(*T)->lchild, key);
        }else{
            return DeleteBST(&(*T)->rchild, key);
        }
    }
}

// 非递归
// 删除节点p, 并重接它的左或右子树
Status DeleteBST(BiTree *p) {
    BiTree targetParent, target;
    if ((*p)->lchild == NULL) {// 左子树为空
        targetParent = *p;
        *p = (*p)->rchild;
        free(targetParent);
    } else if ((*p)->rchild == NULL) {// 右子树为空
        targetParent = *p;
        *p = (*p)->lchild;
        free(targetParent);
    } else {// 均不为空
        targetParent = *p;
        target = (*p)->rchild;
        while (target->lchild) {
            targetParent = target;
            target = target->rchild;
        }
        (*p)->data = target->data;
        if (targetParent != *p) {
            targetParent->rchild = target->lchild;
        } else {
            targetParent->lchild = target->lchild;
        }
    }
}

Java

private static void DeleteBST(BitNode T, int key) {
    BitNode cur = T, par = null;
    while (cur != null) {
        par = cur;
        if (cur.data < key) {
            cur = cur.rchild;
        } else if (cur.data > key) {
            cur = cur.lchild;
        } else {/*找到关键字*/
            if (cur.lchild == null) {/*只有右子树*/
                if (cur == T) {
                    T = cur.rchild;
                } else if (cur == par.lchild) {
                    par.lchild = cur.rchild;
                } else if (cur == par.rchild) {
                    par.rchild = cur.rchild;
                }
            }else if (cur.rchild == null){/*只有左子树*/
                if (cur == T){
                    T = cur.lchild;
                }else if (cur == par.lchild){
                    par.lchild=cur.lchild;
                }else if (cur == par.rchild){
                    par.rchild=cur.lchild;
                }
            }else if (cur.rchild != null && cur.lchild != null){/*左右子树均有*/
                // 左子树找最大值或者右子树找最小值
                BitNode targetParent = cur;
                BitNode target = cur.rchild;
                while (target.lchild != null){
                    targetParent = target;
                    target = target.lchild;
                }
                cur.data = target.data;
                if (target == targetParent.lchild){
                    targetParent.lchild = target.rchild;
                }else{
                    targetParent.rchild = target.rchild;
                }
            }
        }
    }
}

二叉排序树总结

总之，二叉排序树是以链接的方式存储，保持了链接存储结构在执行插入或删除操作时不用移动元素的优点，只要找到合适的插入和删除位置后，仅需修改链接指针即可。插入删除的时间性能比较好。而对于二叉排序树的查找，走的就是从根结点到要查找的结点的路径，其比较次数等于给定值的结点在二叉排序树的层数。极端情况，最少为1次，即根结点就是要找的结点，最多也不会超过树的深度。也就是说，二叉排序树的查找性能取决于二叉排序树的形状。可问题就在于，二叉排序树的形状是不确定的。

也就是说, 我们希望二叉排序树是比较平衡的, 即其深度与完全二叉树相同, 均为log2n+1, 那么查找的时间复杂度也就为O(logn), 近似于折半查找. 因此, 如果我们希望对一个集合按二叉排序树查找, 最好是把它构建成一颗平衡的二叉排序树.

散列表(哈希表)

之前所有的查找都是基于 “比较” 进行的, 能否直接通过关键字 key 得到要查找的记录内存存储位置呢?

散列表查找定义

一个公式: 存储位置=f(关键字)

散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使得每个关键字key对应一个存储位置f (key)。 查找时，根据这个确定的对应关系找到给定值key 的映射f (key)，若查找集合中存在这个记录，则必定在f (key)的位置上。

这里我们把这种对应关系f称为散列函数，又称为哈希(Hash) 函数。按这个思想，采用散列技术将记录存储在一块连续的存储空间中, 这块连续存储空间称为散列表或哈希表(Hash table)。那么关键字对应的记录存储位置我们称为散列地址。

散列表查找步骤

整个过程分为两步

  1. 在存储时: 通过散列函数计算记录的散列地址，并按此散列地址存储该记录.
  2. 当查找记录时，通过同样的散列函数计算记录的散列地址，按此散列地址访问该纪录

散列技术最适合的求解问题是查找与给定值相等的记录，但散列表不具备常规数据结构的能力

散列表缺陷一
比如，同样的关键字能对应很多记录，却不适合用散列技术。一个班级几十个学生，他们的性别有男有女，用关键字“男”去查找就会对应很多的记录，这显然不合适。只有用班级学生的学号或者身份证号来散列存储，此时一个号码唯一对应一个学生才合适。

散列表缺陷二
散列表不适合范围查找，比如查找一个班级18~22岁的学生，在散列表中无法进行。获取表中记录的排序也不可能，最值问题也无法从散列表中计算出来。

散列表设计要求： 简单，均匀，存储利用率高

另一个问题是冲突。在理想的情况下，每一个关键字，通过散列函数计算出来的地址都是不一样的，可现实中，这只是一个理想。我们时常会碰到两个关键字key1≠key2,但是却有f (key1) =f (key2), 这种现象我们称为冲突(collision), 并把key1 和key2称为这个散列函数的同义词(synonym)。 出现了冲突当然非常糟糕，那将造成数据查找错误。尽管我们可以通过精心设计的散列函数让冲突尽可能的少，但是不能完全避免。

散列表函数的构造方法

直接定址法

如果我们现在要对0~ 100岁的人口数字统计表，那么我们对
年龄这个关键字就可以直接用年龄的数字作为地址。此时f (key) =key。
高阶查找算法第一篇_第5张图片
如果我们现在要统计的是80后出生年份的人口数，如表8-10-2所示，那么我们
对出生年份这个关键字可以用年份减去1980来作为地址。此时f (key) =key-1980。
高阶查找算法第一篇_第6张图片
也就是说，我们可以取关键字的某个线性函数值为散列地址，即

f(key)=a*key+b 【a、b为常数】

这样的散列函数优点就是简单、均匀，也不会产生冲突，但问题是这需要事先知道关键字的分布情况，适合查找表较小且连续的情况。由于这样的限制，在现实应用中，此方法虽然简单，但却并不常用。

数字分析法

如果我们的关键字是位数较多的数字，比如我们的11位手机号“130xxxx1234” ，其中前三位是接入号, 一般对应不同运营商公司的子品牌，如130是联通如意通、136 是移动神州行、153 是电信等;中间四位是HLR识别号,表示用户号的归属地;后四位才是真正的用户号，如表所示。
高阶查找算法第一篇_第7张图片
如果对员工进行登记，用手机号作为关键字那么极有可能前7位极有可能相等。算则后四位成为散列地址就是不错的选择。如果还是容易出现问题，我们可以对抽取出来的数字进行反转(1234改成4321)，右环位移，甚至前两位数与后两位数叠加(1234改成12+34=46)。总的目的就是提供一个散列函数，能够合理将关键字分分配到三列表的各个位置。

抽取：使用关键字的一部分来计算散列存储位置的方法，这再散列函数中是常用的方法

数字分析法通常是和处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布均匀，就可以考虑使用该方法

平方取中法

这个方法计算很简单，假设关键字是1234,那么它的平方就是1522756，再抽取中间的3位就是227, 用做散列地址。再比如关键字是4321,那么它的平方就是18671041,抽取中间的3位就可以是671,也可以是710，用做散列地址。

平方取中法比较适合于不知道关键字的分布，而位数又不是很大的情况。

折叠法

折叠法是将关键字从左到右分割成位数相等的几部分(注意最后一部分位数不够时可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。比如我们的关键字是9876543210, 散列表表长为三位，我们将它分为四组,987|654|321|0,然后将它们叠加求和987+654+321+0=1962,再求后3位得到散列地址为962。

有时可能这还不能够保证分布均匀，不妨从一端向另一端来回折叠后对齐相加。比如我们将987和321反转，再与654和0相加，变成789+654+123+0=1566,此时散列地址为566。

折叠法事先不需要知道关键字的分布，适合关键字位数较多的情况。

除留余数法

此方法为最常用的构造散列函数方法。对于散列表长为m的散列函数公式为:

f(key) = key mod p (p≤m )

mod是取模(求余数)的意思。事实上，这方法不仅可以对关键字直接取模，也可在折叠、平方取中后再取模。

很显然，本方法的关键就在于选择合适的p, p如果选得不好，就可能会容易产生同义词。

例如我们对于有12个记录的关键字构造散列表时，就用了f (key)=key.mod 12的方法。比如29 mod12=5,所以它存储在下标为5的位置。
在这里插入图片描述
不过这也是存在冲突的可能的，因为12=2*6=3*4.如果关键字中有像18 (3*6)、30 (5*6)、42 (7*6)等数字，它们的余数都为6,这就和78所对应的下标位置冲突了。

甚至极端一些，对于表中的关键字，如果我们让p为12的话，就可能出现下面的情况，所有的关键字都得到了0这个地址数，这未免也太糟糕了点。
在这里插入图片描述
我们不选用p=12而是11来做除留余数法如图所示
在这里插入图片描述
此就只有12和144有冲突，相对来说，就要好很多。

因此根据前辈们的经验，若散列表表长为m,通常p为小于或等于表长(最好接近m)的最小质数或不包含小于20质因子的合数。

随机数法

根据关键字的随机函数值作为它的散列地址。也就是f(key)=random(key)。当关键字长度不等时，采用这个方法构造散列函数是比较合适的。

对于字符串而言，无论是英语字母还是中文字符也包括各种各样的符号，他们都可以转为某种数字来对待，比如ASCII或者Unicode等。

总之，现实中，应该视不同的情况采用不同的散列函数。给出一些考虑的因素来提供参考:

  1. 计算散列地址所需的时间。
  2. 关键字的长度。
  3. 散列表的大小。
  4. 关键字的分布情况。
  5. 记录查找的频率。

综合这些因素，才能决策选择哪种散列函数更合适。

处理散列冲突的方法

就像误差无法避免只能减少一样，散列冲突也是无法避免只能减少的。

那么当我们在使用散列函数后发现两个关键字key1≠key2,但是却有f (key1) =f(key2)，即有冲突时，怎么办呢？有以下几种方案。

开放定址法

发生冲突的时候去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到到并将记录存入

公式是：

fi(key)=(f(key) +di) MOD m ( di=1,2,3…m-1 )

比如说，我们的关键字集合为{12,67,56,16,25,37,22,29,15,47,48,34}，表长为12。我们用散列函数f (key) =key mod 12。

当计算前5个数{12,67,56,16,25}时， 都是没有冲突的散列地址，直接存入，如图所示
在这里插入图片描述
计算key=37时，发现f (37) =1，此时就与25所在的位置冲突。于是我们应用上面的公式f (37) = (f (37) +1) mod 12=2。于是将37存入下标为2的位置。这其实就是寻找下一个空散列地址的做法
在这里插入图片描述
接下来22,29,15,47都没有冲突，正常的存入。
在这里插入图片描述
到了key=48,我们计算得到f (48) =0，与12所在的0位置冲突了，不要紧，我们f (48) = (f (48) +1) mod 12=1， 此时又与25所在的位置冲突。于是f(48) = (f (48) +2) mod 12=2，还是冲突… 直到f (48) = (f (48) +6) mod12=6时，才有空位存入。
在这里插入图片描述
我们把这种解决冲突的方法称为线性探测法
在解决冲突的时候会碰到48和37这种key不同但f(key)相同的个情况，这种现象称为堆积。堆积的出现，使得我们需要不断处理冲突，无论是存入还是查找效率都会大大降低。

考虑深一步，如果最后一个 key=34，f(34)=10，与22所在的位置冲突，但22后面没有位置前面有一个空位，尽管可以不断求余后得到结果，但效率会很差。因此我们可以改进di=12, -12, 22, -22, … q2, -q2. 这样就可以双向寻找可能的位置。额外增加的平方运算，缪是为了不让关键字都聚集在某一块区域内。此方法为二次探测法

fi(key)=(f(key)+di) MOD m 【di=12, -12, 22, -22, … q2, -q2, q≤m/2】

还有一种方法是在冲突时，对于位移量**di**采用随机函数计算得到，称为随机探测法
这里的随机是伪随机

如果我们设置随机种子相同，则不断调用随机函数可以生成不会重复的数列，在查找时用同样的随机种子，每次得到的数列是相同的，相同荣的di 当然可以得到相同的个散列地址

公式：

f(key)= (f(key) +di) MOD m (di是一个随机数列)

总之，开放定址法只要在散列表未填满时，总是能找到不发生冲突的地址，是我们常用的解决冲突的办法。

再散列函数法

对于我们的散列表来说，我们事先准备多个散列函数。

f(key) =RHi(key) (i=1,2,…,k)

这里RHi就是不同的散列函数，把前面说的什么除留余数、折叠、平方取中全部用上。每当发生散列地址冲突时，就换一个 散列函数计算，相信总会有一个可以把冲突解决掉。这种方法能够使得关键字不产生聚集，当然，相应地也增加了计算的时间。

链地址法

对于关键字集{12,67,56,16,25,37,22,29,15,47,48,34},我们用前面同样的12为除数，进行除留余数法，可得到如图，此时，已经不存在什么冲突换址的问题，无论有多少个冲突，都只是在当前位置给单链表增加结点的问题。
高阶查找算法第一篇_第8张图片
链地址法对于可能会造成很多冲突的散列函数来说，提供了绝不会出现找不到地址的保障。当然，这也就带来了查找时需要遍历单链表的性能损耗。

公共溢出区法

这个方法其实就更加好理解，你不是冲突吗?好吧，凡是冲突的都跟我走，我给你们这些冲突找个地儿待着。这就如同孤儿院收留所有无家可归的孩子一样，我们为所有冲突的关键字建立了一个公共的溢出区来存放。就前面的例子而言，我们共有三个关键字{37,48,34}与之前的关键字位置有冲突，那么就将它们存储到溢出表中，如图所示。
高阶查找算法第一篇_第9张图片
在查找时，对给定值通过散列函数计算出散列地址后，先与基本表的相应位置进行比对，如果相等，则查找成功;如果不相等，则到溢出表去进行顺序查找。如果相对于基本表而言，有冲突的数据很少的情况下，公共溢出区的结构对查找性能来说还是非常高的。

散列表查找算法实现

C

#include 

#define OK 1
#define SUCCESS 1
#define UNSUCCESS 0
#define HASHSIZE 12 /*散列表长度*/
#define NULLKEY -32768

typedef int Status;
typedef struct {
    int *elem; /*数据元素存储基址，动态分配数组*/
    int count; /*当前数据元素个数*/
} HashTable;

int m = 0; /*散列表表长，全局变量*/

/*散列表初始化*/
Status InitHashTable(HashTable *H) {
    H->elem = (int *) malloc(sizeof(int));
    for (int i = 0; i < HASHSIZE; ++i) {
        H->elem[i] = NULLKEY;
    }
    m = H->count = HASHSIZE;
    return OK;
}

/*散列函数*/
int Hash(int key) {
    return key % m;/*除留余数法*/
}

/*散列表的插入*/
void InsertHash(HashTable *H, int key){
    int addr= Hash(key);
    while (H->elem[addr] != NULLKEY){/*如果不为空，则不冲突*/
        addr=(addr+1)%m;
        ++H->count;
    }
    H->elem[addr]=key;
}

/*散列表查找*/
Status SearchHash(HashTable H, int key, int *addr){
    *addr = Hash(key);/*求散列地址*/
    while (H.elem[*addr] != key){/*如果不为空，则冲突*/
        *addr=(*addr+1)%m;/*开放地址发的线性探测*/
        if(H.elem[*addr] == NULLKEY || *addr== Hash(key)){/*如果循环回到原点*/
            return UNSUCCESS;
        }
    }
    return SUCCESS;
}

Java

public class Main {
    /*构建哈希类*/
    private static class HashNode {
        int key;
        int value;
        HashNode next;

        public HashNode(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    HashNode[] array = new HashNode[12];
    private int count = 0;

    /*构建哈希函数*/
    private int hashCode(int key) {
        return key % array.length;
    }

    /*负载因子α*/
    private double loadFactor() {
        return (double) count / array.length;
    }

    /*插入*/
    private void put(int key, int value) {
        int addr = key % array.length;/*计算地址*/
        HashNode cur = array[addr];
        for (; cur != null; cur = cur.next) {/*看看 key 是否在于 hash 表中*/
            if (cur.key == key) {/*存在就修改*/
                cur.value = value;
                return;
            }
        }
        /*不存在就插入新节点, JDK1.7之前是头插, JDK1.8之后是尾插[这里演示的是尾插]*/
        HashNode newNode = new HashNode(key, value);
        cur = array[addr];
        if (cur == null) {
            array[addr] = newNode;
        } else {
            while (cur != null) {
                cur = cur.next;
            }
            cur.next = newNode;
        }
        ++count;
        /*负载因子过大就扩容*/
        if (loadFactor() >= 0.75) {
            resize();
        }
    }

    /*散列表的扩容函数*/
    private void resize() {
        /*构建新的哈希数组*/
        HashNode[] newArray = new HashNode[array.length << 1];
        // 1.数据复制:旧哈希表搬运到新哈希表
        for (int i = 0; i < array.length; i++) {
            HashNode cur = array[i];
            while (cur != null) {
                HashNode curNext = cur.next;// 提前保留下一节点，便于遍历
                // 2.计算当前 key 在新哈希数组中的下标
//                int addr = hashCode(cur.key);// 不可以使用hashCOde函数进行设置散列存储下标，应该使用新的数组来计算
                int addr = cur.key % newArray.length;
                HashNode curN = newArray[addr];
                // 3.找到新哈希表的尾巴
                if (curN == null) {
                    newArray[addr] = cur;
                } else {
                    while (curN != null) {
                        curN = curN.next;
                    }
                    curN.next = cur;
                }
                // 每个节点都是尾插，next设置为null
                cur.next = null;
                cur = curNext;
            }
        }
        // 不要忘记进行引用切换
        array = newArray;
    }

    /*散列查找*/
    private boolean SearchHash(int key){
        int addr=hashCode(key);
        HashNode cur=array[addr];
        while (cur != null){
            if (cur.key == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    public static void main(String[] args) {
        Main main = new Main();
        main.put(1, 1);
    }
}

如果相对JDK8版本的HashMap深入了解，可以查看我之前的博客

散列表查找性能分析

最后，我们对散列表查找的性能作-一个简单分析。如果没有冲突，散列查找是我们本章介绍的所有查找中效率最高的，因为它的时间复杂度为0(1)。 没有冲突的散列只是理想，在实际的应用中，冲突是不可避免的。那么散列查找的平均查找长度取决于哪些因素呢?

1. 散列函数是否均匀
散列函数的好坏直接影响着出现冲突的频繁程度，不过，由于不同的散列函数对同一组随机的关键字,产生冲突的可能性是相同的，因此我们可以不考虑它对平均查找长度的影响。

2. 处理冲突的方法
相同的关键字、相同的散列函数，但处理冲突的方法不同，会使得平均查找长度不同。比如线性探测处理冲突可能会产生堆积，显然就没有二次探测法好，而链地址法处理冲突不会产生任何堆积，因而具有更佳的平均查找性能。

3. 散列表的装填因子
所谓的装填因子α=填入表中的记录个数 / 散列表长度。a标志着散列表的装满的程度。当填入表中的记录越多，a就越大，产生冲突的可能性就越大。比如前面的例子散列表长度是12，而填入表中的记录个数为11,那么此时的装填因子x=11/12=0.9167,再填入最后一个关键字产生冲突的可能性就非常之大。也就是说，散列表的平均查找长度取决于装填因子，而不是取决于查找集合中的记录个数。

不管记录个数n有多大，我们总可以选择一个合适的装填因子以便将平均查找长度限定在一个范围之内，此时我们散列查找的时间复杂度就真的是0(1)了。为了做到这一点，通常我们都是将散列表的空间设置得比查找集合大，此时虽然是浪费了一定的空间，但换来的是查找效率的大大提升，总的来说，还是非常值得的。

位图

面试题

给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。

  1. 遍历: 时间复杂度O(N)
  2. 排序: 快排O(N*log2N)；二分查找：O(log2N)
  3. 位图解决: 整形数据是否存在给定的整形数据中，状态只能是在或不在。【那么就可以是用二进制比特位来代表是否存在。1:存在；0:不存在】

位图的数据结构

高阶查找算法第一篇_第10张图片

上图中就是一组数据的存储方案

  1. 方案一用数组，消耗40字节
  2. 方案二用位图，消耗3字节

发现位图1字节存储8个int；数组而言4字节存储1个int

猜想：如果把40亿个整数全放在位图中，需要多少内存？

∵ x 32 = 42 _ 9496 _ 7296 \because x^{32}=42\_9496\_7296 ∵x32=42_9496_7296

∴ log ⁡ 2 40 _ 0000 _ 0000 ≈ 32 \therefore \log_2 40\_0000\_0000 \approx32 ∴log2​40_0000_0000≈32

∵ 由于我们设计的位图每 8 个整数消耗 1 字节 \because 由于我们设计的位图每8个整数消耗1字节 ∵由于我们设计的位图每8个整数消耗1字节

∴ 40 _ 0000 _ 0000 ÷ 8 ÷ 102 4 2 = 476.837158203125 M B ≈ 476.9 M B \therefore 40\_0000\_0000 \div 8 \div 1024^2 = 476.837158203125MB \approx 476.9MB ∴40_0000_0000÷8÷10242=476.837158203125MB≈476.9MB

∴ 40 亿个整数，位图 0.43 G 就可以存储 \therefore 40亿个整数，位图0.43G就可以存储 ∴40亿个整数，位图0.43G就可以存储

数组形式常用数据存储量

10亿个比特位需要128mb【 10 _ 00000000 ÷ 8 ÷ 102 4 2 = 119.20928955078125 M B ≈ 119.3 10\_00000000 \div 8 \div 1024^2 = 119.20928955078125MB \approx 119.3 10_00000000÷8÷10242=119.20928955078125MB≈119.3】

10亿个字节需要1G【 10 _ 00000000 ÷ 102 4 2 = 953.67431640625 M B ≈ 953.7 M B 10\_00000000 \div 1024^2 = 953.67431640625MB \approx 953.7MB 10_00000000÷10242=953.67431640625MB≈953.7MB】】

10亿个整数需要4G【 10 _ 00000000 × 4 ÷ 102 4 2 = 3.725290298461914 G ≈ 3.8 G 10\_00000000 \times 4 \div 1024^2 = 3.725290298461914G \approx 3.8G 10_00000000×4÷10242=3.725290298461914G≈3.8G】】

40亿个整数需要16G【 40 _ 00000000 × 4 ÷ 102 4 2 = 14.901161193847656 G ≈ 15 G 40\_00000000 \times 4 \div 1024^2 = 14.901161193847656G \approx 15G 40_00000000×4÷10242=14.901161193847656G≈15G】】

位图的实现

看了位图的示意图之后，发现 num/8决定落在位图的哪个字节；num%8决定落在位图的哪个字节哪个位

举例：22

22 ÷ 8 = 2 ； 22 % 8 = 6 22 \div 8=2；22 \% 8 = 6 22÷8=2；22%8=6

2: 22 落在下标位2的字节段

6: 根据2字节段，22 落在其 6 下标 地址

package bitSet;

import java.util.Arrays;

public class MyBitSet {
    public final int BIT = 8;
    public byte[] elem;
    public int usedSize;

    public MyBitSet() {
        // 默人给1子节：也就是8位
        this.elem = new byte[1];
    }

    /**
     * @param n 多少位
     *          n=12，如果不加1的话，12还会有4个位没有存储。因此我们就选择多一个子节的空间
     */
    public MyBitSet(int n) {
        this.elem = new byte[n / BIT + 1];
    }

    /**
     * 把对应 val 位 设置为 1即可
     * 需要修改 子节位 和 比特为
     *
     * @param val
     */
    public void set(int val) {
        if (val < 0) {
            throw new IndexOutOfBoundsException();
        }
        int arrIndex = val / BIT;
        int bitIndex = val % BIT;
        // 扩容
        if (arrIndex > elem.length - 1) {
            elem = Arrays.copyOf(elem, arrIndex + 1);
        }
        // 不可以用 ^异或 计算，否则会修改之前的值
        elem[arrIndex] |= (1 << bitIndex);
        ++usedSize;
    }

    /**
     * 判断对应位是否为 1 即可
     *
     * @param val
     * @return
     */
    public boolean get(int val) {
        if (val < 0) {
            throw new IndexOutOfBoundsException();
        }
        int arrIndex = val / BIT;
        int bitIndex = val % BIT;
        if ((elem[arrIndex] & (1 << bitIndex)) != 0) {
            return true;
        }
        return false;
    }

    /**
     * 取消某一数据的比特位
     * 这里需要左移之后按位取反在与运算即可
     *
     * @param val
     */
    public void reSet(int val) {
        if (val < 0) {
            throw new IndexOutOfBoundsException();
        }
        int arrIndex = val / BIT;
        int bitIndex = val % BIT;
        elem[arrIndex] &= (~(1 << bitIndex));
        --usedSize;
    }

    public int getUsedSize() {
        return usedSize;
    }

    // 用位图排序
    public void sort() {
        for (int i = 0; i < elem.length; i++) {
            for (int j = 0; j < BIT; j++) {
                if ((elem[i] & (1 << j)) != 0) {
                    System.out.print(i * BIT + j + " ");
                }
            }
        }
        System.out.println();
    }
}

测试

private static void MyBitSetTest() {
    BitSet bitSet = new BitSet(18);
    MyBitSet myBitSet = new MyBitSet(18);
    int[] arr = {1, 2, 3, 10, 4, 18, 13};
    for (int i : arr) {
        bitSet.set(i);
        myBitSet.set(i);
    }
    for (int i : arr) {
        System.out.printf("检查插入元素%d是否存在__>BitSet: %s  MyBitSet: %s\n", i, bitSet.get(i), myBitSet.get(i));
    }
    myBitSet.sort();
}

检查插入元素1是否存在__>BitSet: true  MyBitSet: false
检查插入元素2是否存在__>BitSet: true  MyBitSet: true
检查插入元素3是否存在__>BitSet: true  MyBitSet: false
检查插入元素10是否存在__>BitSet: true  MyBitSet: true
检查插入元素4是否存在__>BitSet: true  MyBitSet: true
检查插入元素18是否存在__>BitSet: true  MyBitSet: false
检查插入元素13是否存在__>BitSet: true  MyBitSet: false

位图的应用

  1. 快速查找某个数据是否在一个集合中

    位图标识为1就代表存在；为0就代表不存在。利用此思想，可以进行海量数据的处理。

    100亿个整数中找到出现1次的数据，出现2次的数据和出现2次以上的数据

    • 假设是用数组存储
      100 _ 00000000 ∗ 4 ÷ 102 4 3 = 37.252902984619141 G ≈ 37.3 G 100\_00000000 * 4 \div 1024^3 = 37.252902984619141G \approx 37.3G 100_00000000∗4÷10243=37.252902984619141G≈37.3G

      内存消耗很高

    • 哈希切割

      1. 将100亿个整数通过哈希函数切割为200个文件，每个文件存储5000w个整数，每个文件大约 162.3MB【 5000 _ 0000 ∗ 4 ÷ 1024 ÷ 1024 = 162.2196807861328 M B ≈ 162.3 M B 5000\_0000 * 4 \div 1024 \div 1024 = 162.2196807861328MB \approx162.3MB 5000_0000∗4÷1024÷1024=162.2196807861328MB≈162.3MB】
      2. 文件地址=hash(num)%200，一样的数字肯定放在同一个文件中
      3. HashMap遍历文件统计每个数字出现的次数

    • 使用2个位图

      ∵ 1 B y t e = 8 b i t ，字节数组中每个 b i t 位代表一个整数 \because 1Byte=8bit，字节数组中每个bit位代表一个整数 ∵1Byte=8bit，字节数组中每个bit位代表一个整数

      ∴ 1 B y t e 可以代表 8 个整数 \therefore 1Byte可以代表8个整数 ∴1Byte可以代表8个整数

      ∴ 100 _ 00000000 ÷ 8 ÷ 1024 ÷ 1024 ÷ 1024 = 1.1641532182693481 ≈ 1.2 G \therefore 100\_00000000 \div 8 \div 1024 \div 1024 \div 1024 = 1.1641532182693481 \approx1.2G ∴100_00000000÷8÷1024÷1024÷1024=1.1641532182693481≈1.2G

      高阶查找算法第一篇_第11张图片

      出现0次：00

      出现1次：01

      出现2次：10

      出现3次及以上：11

    • 使用1个位图

      高阶查找算法第一篇_第12张图片

  2. 排序+去重

    位图不能用来存储重复的数据，通过从右到左【低字节位到高字节位输出标识位为1的数据】就可以输出从升序的数据列

   public void sort() {
     for (int i = 0; i < elem.length; i++) {
       for (int j = 0; j < BIT; j++) {
         if ((elem[i] & (1 << j)) != 0) {
           System.out.print(i * BIT + j + " ");
         }
       }
     }
     System.out.println();
   }

elem[i] & (1 << j) 判断该比特位是否存在数据

数据值的计算方式：跨的字节数 * BIT + 位数

测试排序

myBitSet.sort();

0 2 4 6 10 12 20

  1. 有2个文件分别存储100亿个整数，如何快速找到他们的交集，并集和差集

    1. 交集

      • 哈希切割求交集

        • 将100亿个整数通过哈希函数切割为200个文件，每个文件存储5000w个整数，每个文件大约 162.3MB【 5000 _ 0000 ∗ 4 ÷ 102 4 2 = 190.73486328125 M B ≈ 190.8 M B 5000\_0000 * 4 \div 1024^2 = 190.73486328125MB \approx 190.8MB 5000_0000∗4÷10242=190.73486328125MB≈190.8MB】
        • 由于两个文件都是通过同一个哈希函数切割，所以对于相同文件地址进行 & 运算
        • 高阶查找算法第一篇_第13张图片

      • 1个位图

        • 把第一个集合的数据放在位图中
        • 然后遍历第二个集合，看位图中是否存在便利读取的数据
        • 如果有，就是交集

      • 2个位图

        • 分别把两个集合的数据存放在两个位图中
        • 位图对应的标识位进行 & 运算，如果结果为1，就是交集

    2. 并集

      • 2个位图
        • 分别把两个集合的数据存放在两个位图中
        • 位图对应的标识位进行 | 运算，如果结果为1，就是并集

    3. 差集

      • 2个位图
        • 分别把两个集合的数据存放在两个位图中
        • 位图对应的标识位进行 ^ 运算，如果结果为1，就是差集

  2. 位图应用变形：1个文件有100个int，如何找出出现次数不超过2次的整数

    1. 哈希切个文件
    2. 位图
      • 找两个位图中标识不为 11 的数据就是出现次数不超过2次的整数

  3. 操作系统中磁盘块的标记

位图的缺陷

位图就是为了解决数据存储量大占用内存的问题，但也有一定的局限性

  1. 存储的数据只能局限在整数，如果遇到字符串，小数就无能为力
  2. 存储在位图中的数据不能重复，这也就导致在排序的时候就不会出现重复的数据

为了解决位图的痛点，人们又设计出一种新的数据数据结构——布隆过滤器

布隆过滤器

通常我们会有许多判断元素是否存在某个集合中的业务场景。我们经常使用的方法就是将集合中的元素全部保存起来，然后通过比较确定。常用的数据结构有链表 O ( N ) O(N) O(N)，树 O ( log ⁡ N ) O(\log_N) O(logN​)，散列表来存储 O ( N ) O(N) O(N)。但是随着业务的增长，数据量也就开是线性增长，最终达到瓶颈。

散列表虽然是 O ( 1 ) O(1) O(1) ，但是由于负载因子的存在控制冲突概率，牺牲空间额外扩容的方式来解决哈希冲突，带来的数据效益是越来越小的，因此不推荐使用

loadFactory负载因子JDK8控制在0.75，因此也就会有25%的内存空间浪费

布隆过滤器数据结构

布隆过滤器本质上是由哈希函数+位图结合而成的。

高阶查找算法第一篇_第14张图片

分析

  1. 布隆过滤器初始化状态为0

  2. 当有k个元素加入集合的时候，会通过3个不同的hash函数分别映射到位图中，并置为1

  3. 下次我们查询某个变量在不在集合的时候，通过哈希函数映射的的下标是否为1即可判断

    • 如果其中有一个为0，那么一定不存在
    • 如果哈希函数映射的位图都是1，则可能存在

    上图中的b和c都映射到了 字节数组0下标的3下标位 ，此时都是1，那么就无法判断一定存在了，仅仅是可能存在

布隆过滤器的实现

package bloomFilter;

import java.util.BitSet;

class SimpleHash {
    // 当前容量
    public int cap;
    // 随机
    public int seed;

    public SimpleHash(int cap, int seed) {
        this.cap = cap;
        this.seed = seed;
    }

    // 根据 seed 不同，创建不同的 hash函数
    final int hash(String key) {
        int h;
        //(n - 1) & hash
        return (key == null) ? 0 : (seed * (cap - 1)) & ((h = key.hashCode()) ^ (h >>> 16));
    }
}

public class MyBloomFilter {
    public static final int DEFAULT_SIZE = 1 << 20;
    // 位图
    public BitSet bitSet;
    // 记录个数
    public int usedSize;
    // 随机种子
    public static final int[] seeds = {3, 5, 7, 11, 13, 27, 33};
    public SimpleHash[] simpleHashes;

    public MyBloomFilter() {
        bitSet = new BitSet(DEFAULT_SIZE);
        this.simpleHashes = new SimpleHash[seeds.length];
        for (int i = 0; i < seeds.length; i++) {
            simpleHashes[i] = new SimpleHash(DEFAULT_SIZE, seeds[i]);
        }
    }

    /**
     * 添加元素到布隆过滤器
     *
     * @param val
     */
    public void add(String val) {
        // 让 hash 函数处理当前数据
        int index = 0;
        for (SimpleHash s : simpleHashes) {
            index = s.hash(val);
            // 把它们都存储在位图当中即可
            ++usedSize;
            bitSet.set(index);
        }
    }

    /**
     * 是否包含 val，这里会存在一定的误判
     *
     * @param val
     * @return
     */
    public boolean contains(String val) {
        int index = 0;
        for (SimpleHash s : simpleHashes) {
            index = s.hash(val);
            if (!bitSet.get(index)) {
                return false;
            }
        }
        return true;
    }
}

测试

import bloomFilter.MyBloomFilter;

public class Test {

    private static void BloomFilterTest() {
        MyBloomFilter myBloomFilter = new MyBloomFilter();
        myBloomFilter.add("a");
        myBloomFilter.add("abc");
        myBloomFilter.add("abcd");

        System.out.println(myBloomFilter.contains("a"));
        System.out.println(myBloomFilter.contains("ac"));
    }

    public static void main(String[] args) {
        BloomFilterTest();
    }
}

true
false

布隆过滤器的应用

  1. 布隆过滤器在数据的插入和查询【时间和空间】上时间复杂度为 O ( 1 ) O(1) O(1) ，有着巨大的优势。哈希函数之间也没有关联关系

  2. 由于没有存储数据本身，也不能像位图那样推到书原始数据，所以对于保密的数据来说，是安全的

  3. 可以表示数据的全集，其它数据结构不能

  4. 防止数据库穿库： Google Bigtable，HBase 和 Cassandra 以及 Postgresql 使用BloomFilter来减少不存在的行或列的磁盘查找。避免代价高昂的磁盘查找会大大提高数据库查询操作的性能

  5. 业务场景中判断用户是否阅读过某视频或文章，比如抖音或头条，当然会导致一定的误判，但不会让用户看到重复的内容

  6. 缓存宕机、缓存击穿场景：一般判断用户是否在缓存中，如果在则直接返回缓存结果；不在就会去数据库查询。如果一波冷数据，就会造成大量缓存访问，缓存击穿引发雪崩效应。这个时候使用布隆过滤器当缓存的索引，如果在布隆过滤器中才会访问缓存，缓存中没有用户数据，再访问数据库；如果布隆过滤器没有，则直接返回，不需要访问缓存

    冷数据：一般用不到的数据，集中处理存放在专门负责存储的机器上

    热数据：高频，经常使用到的数据，布置在高性能机器上【可以放到 LRUCache 中，先埋一个坑】

  7. WEB拦截器：可以防止被同一个请求恶意多次攻击；也可以将用户第一次请求放入布隆过滤器中，下一次的先访问布隆过滤器在访决定是否访问缓存，请求提高缓存命中率

  8. 拦截垃圾邮件

有一个100G的log文件，log中存储着IP地址，如何找到出现次数最多的IP地址？

上回是100亿个整数的文件，可以用位图解决；那么这次100G的IP地址日志文件就需要使用布隆过滤器。

通常不考虑大小，最常用的 K-V结构 即可解决；其次是 TopK 的思路解决。但问题是 100G 文件，数据量很大很大，即使用 TopK 也无法解决内存问题。

  • 哈希切割文件：100G的文件切割为256MB，512MB。但是这样只能算出某个证文件中IP出现次数最多但并不代表整体文件中IP地址出现次数最多。

因此，我们不再按照文件来切割而是按照IP地址切割文件：将相同的IP地址切割到同一个文件中。然后 TopK使用大堆选择前三个最多出现次数的即可。

  • 哈希切割IP：
    • IP本身就是一个字符串，通过哈希转换为数字
    • 100G文件可以分为200个512MB的小文件【 100 G ÷ 1024 ÷ 512 = 200 100G \div 1024 \div 512 = 200 100G÷1024÷512=200】
    • 文件地址=hash(IP)%200，然后将从100G中读取的IP映射到对应的200份文件的地址中
    • 统计每个文件中IP出现的次数【可以是用HashMap统计，因为是512MB，所以可以直接读取到内存中】。每一个文件最多的IP统计出来之后，整体文件的IP出现次数就得知了。无论是 TopK形式的前K个，还是最大的。都能快速找到

有2个文件，分别有100亿个query，但只有1G内存，如何找到两个文件交集？分别给出精确算法和近似算法

这个query可能是SQL语句，也可能是HTTP请求，假设每个query是10字节。

100 _ 00000000 × 10 ÷ 102 4 3 = 93.132257461547852 G ≈ 93.2 G 100\_00000000 \times 10 \div 1024^3 = 93.132257461547852G \approx 93.2G 100_00000000×10÷10243=93.132257461547852G≈93.2G

  1. 精确算法

    • 哈希切割文件求交集，和位图的计算方式一样。这样是一种精确的算法【只不过这里需要按照query切割，我们可以通过哈希函数把query转为整数即可】
    • 高阶查找算法第一篇_第15张图片

  2. 近似算法

    • 布隆过滤器
      • 第1个文件中的query通过哈希函数映射到为途中
      • 遍历第2个文件，读取的每个query都去布隆过滤器中查找【会存在误判】
      • 因为误判，所以可能导致这个query没有，但是被判定为有

布隆过滤器的缺陷

  1. 误判率：随着插入元素越来越多，误判率也会越来越多。数据量太少，直接使用 HashMap 即可
  2. 只能增加元素不能删除元素：因为删除元素依据的是标识为1，如果多个元素共同映射到一个标识位，那么删除这个标识位就会导致误判率的增加
  3. 计数器溢出：通过计数器的方式来统计插入元素个数，多占用几倍的存储空间，并且也不一定100%正确

扩展部分

一致性哈希

普通哈希

在了解一致性哈希算法和应用之前我们先了解一下经典的分布式缓存的应用场景。

高阶查找算法第一篇_第16张图片

大量的用户请求的query或者url会被经过哈希之后落在对应的服务器上。经过同一个哈希函数，对同一个url的运算结果应该是相同的，由于服务器数量为3，因此对3求余的结果就在 [ 0 , 1 , 2 ] [0, 1, 2] [0,1,2] 区间内，如果计算结果为0，就使用0服务器；如果计算结果为1，就使用1服务器…当有300w个URL请求时，会通过这3个哈希函数将300w个请求均摊100w到每个服务器。

突然有一天，业务使用人数已经突破到了1亿访问量，每个服务器压力变为原来的了3.4倍，那么性能肯定会大打折扣的。如果突然增加了一个服务器，那么此时经过 hash(url)%4 的计算结果就落在了 [ 0 , 1 , 2 , 3 ] [0,1,2,3] [0,1,2,3] 上，那么对应原来的业务出理的服务器肯定会打乱，服务器的均摊功能也会丧失，更有可能导致缓存雪崩，因此得不偿失。

一致性哈希算法

什么是一致性哈希算法？之前的哈希算法是对服务器数量取模运算，但是一致性哈希使用 hashServer(Machine)%(2^32) 取模

  1. 一致性哈希是将整个哈希值顺时针布置在一个虚拟的圆环，称为哈希环

  2. 将服务器再哈希【可以用服务器的IP或者主机名作为关键子进行哈希】到哈希环上

  3. 然后再使用使用特定的哈希函数 hashQuery(URL) 计算出哈希值，并确定在环上的位置，然后顺时针找到的第一个服务器就是其定位到的服务器

    高阶查找算法第一篇_第17张图片

    一致性哈希优点

    假设 服务器2 出现了异常被移除之后，那么请求3就会顺时针找到遇到的第一个 服务器0 。而请求1，请求2依然交给 服务器1 处理；请求4交给 服务器0 处理，它们的请求处理服务器都没有改变；只有请求3 则转接给了 服务器0 处理。这就是一致性哈希的优点。

    高阶查找算法第一篇_第18张图片

    传统的哈希分布式对服务器数量取模，当某一个服务器出现异常宕机或者新增服务器之后，就会出现缓存雪崩从而有可能导致系统的奔溃。而一致性哈希每次对于服务器数量的增删都只需要重定向一小部分数据即可，只有小部分缓存失效，不至于将大部分的缓存压力集中在某一台服务器上并且具有良好的容错性和可维护性。

    哈希环的倾斜与虚拟节点

    一致性哈希算法在服务器数量很少的情况下，会导致服务器节点分布不均匀导致的数据倾斜，也就是被缓存的对象大部分集中在一台服务器上，从而出现数据分布不均匀，也就是哈希环的倾斜现象。

    高阶查找算法第一篇_第19张图片

    解决办法就是增加虚拟的服务器节点。hashServer(Matchine)%(2^32) 没计算一个物理地址就放置一个虚拟的地址称为 虚拟节点 。虚拟节点个数越多，数据/缓存/请求就会被分不的越均匀，哈希环倾斜的概率就越小。

    hashQuery(URL) 定位数据算法不变，但多了一步虚拟节点到物理节点的映射。

    具体做法：可以在 hashServer(Matchine)%(2^32) 后增加编号即可

    高阶查找算法第一篇_第20张图片

哈希与加密

哈希和加密都能把一段文本信息转化为特定的字符串，很多人分不清楚。更详细的说哈希是把文本转换为相等长度，不可逆的字符串【也称为消息摘要】；而加密则是把文本转换为具有不同长度，可逆的密文

  1. 转化后目标文本是否长度等长

    哈希：等长

    加密：不等长，随着加密文本的长度变化而变化

  2. 转话后目标文本是否可逆

    哈希：不可逆

    加密：可逆

试想：如果哈希可逆，那么它将是世上最强悍的压缩方式。无论多长的文本，都被转换为定长文本固定大小。

package bloomfilter;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MyEncrypt {
    private String method;
    private String password;
    private String salt;
    private int count;
    private int binary;

    public MyEncrypt(String method, String password, String salt, int count, int binary) {
        this.method = method;
        this.password = password;
        this.salt = salt;
        this.count = count;
        this.binary = binary;
    }

    public static String encypt(String algorithm, String password, String salt, int count, int radix) {
        MyEncrypt myEncypt = new MyEncrypt(algorithm, password, salt, count, radix);
        String ret = null;
        try {
            // 加秘算法 md5/sha1
            MessageDigest md = MessageDigest.getInstance(algorithm);
            // 加盐 salt
            md.update((password + salt).getBytes());
            // 已经加密一次，并转换为 radix 进制
            ret = new BigInteger(1, md.digest()).toString(radix);
            // 再加密 count-1 次
            for (int i = 0; i < count - 1; i++) {
                ret = new BigInteger(1, md.digest()).toString(radix);
            }
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
        return ret;
    }

    public static int hashCode(String content){
        return content.hashCode();
    }
}

测试

import bloomFilter.MyEncrypt;

import java.util.List;

public class Test {
	private static void MyEncryptTest() {
	    String algorithm = "MD5";
	    String password = "admin";
	    String salt = "1j2a3v4a";
	    System.out.println("原始密码: " + password);
	    List<StringBuilder> stringBuilderList = MyEncrypt.encrypt(algorithm, password, salt);
	    for (int i = 0; i < stringBuilderList.size(); i++) {
	        System.out.printf("第%d次MD5加密: %s\n", i, stringBuilderList.get(i));
	    }
	    int hashCode = MyEncrypt.hashCode(password);
	    System.out.println("哈希加密: " + hashCode);
	    MyEncrypt.HashAttackHelper(hashCode);
	}

    public static void main(String[] args) {
        MyEncryptTest();
    }
}

原始密码: admin
MD5加密: d41d8cd98f00b204e9800998ecf8427e
哈希加密: 92668751
穷举法模拟一次简单的哈希加密破解

这里学习了一下 MessageDigest 的用法，就换了另外一种方式来计算MD5和加盐的方式

package bloomFilter;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyEncrypt {
    public static List<StringBuilder> encrypt(String algorithm, String password, String salt) {
        List<StringBuilder> builderList = new ArrayList<>();
        StringBuilder stringBuilder = new StringBuilder();
        // 加秘算法 md5/sha1
        MessageDigest md = null;
        try {
            md = MessageDigest.getInstance(algorithm);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
        md.update(password.getBytes());
        System.out.printf("MD5未加盐: %s\n", new BigInteger(1, md.digest()).toString(16));// 一般为了方便都使用16进制
        // 加盐 salt
        int len = salt.length();
        for (int i = 0; i < len; ++i) {
            md.update((password + salt.charAt(i)).getBytes());
            byte[] bytes = md.digest();
            for (byte b : bytes) {
                stringBuilder.append(Integer.toHexString(255 & b));
            }
            builderList.add(stringBuilder);
            stringBuilder = new StringBuilder("");
        }
        return builderList;
    }

    public static int hashCode(String content) {
        return content.hashCode();
    }

    public static void HashAttackHelper(int hashCode) {
        List<String> dict = new ArrayList<>();
        // 添加可能性大的密码字典
        dict.add("12345678");
        dict.add("root");
        dict.add("admin");
        dict.add("@admin");
        dict.add("@admin123");
        ExecutorService pool = Executors.newCachedThreadPool();
        pool.submit(() -> {
            // 字典穷举失败
            for (String words : dict) {
                // 穷举的哈希值范围
                if (hashCode(words) == hashCode) {
                    System.out.println("穷举成功, 密码为: " + words);
                    break;
                }
            }
        });
        pool.shutdown();
    }
}

测试

import bloomFilter.MyEncrypt;

import java.util.List;

public class Test {

    private static void MyEncryptTest() {
        String algorithm = "MD5";
        String password = "admin";
        String salt = "1j2a3v4a";
        System.out.println("原始密码: " + password);
        List<StringBuilder> stringBuilderList = MyEncrypt.encrypt(algorithm, password, salt);
        for (int i = 0; i < stringBuilderList.size(); i++) {
            System.out.printf("第%d次MD5加密: %s\n", i, stringBuilderList.get(i));
        }
        int hashCode = MyEncrypt.hashCode(password);
        System.out.println("哈希加密: " + hashCode);
        MyEncrypt.HashAttackHelper(hashCode);
    }

    public static void main(String[] args) {
        MyEncryptTest();
    }
}

原始密码: admin
MD5未加盐: 21232f297a57a5a743894a0e4a801fc3
第0次MD5加密: e0cf25ad42683b3df678c61f42c6bda
第1次MD5加密: 5db450959bc7f779a3ffbb885bcf3ddb
第2次MD5加密: c84258e9c39059a89ab77d846ddab99
第3次MD5加密: 91183e1cb4e46961f86a2ef6287927ad
第4次MD5加密: 32cacb2f994f6b42183a130d9a3e8d6
第5次MD5加密: f98c28a9f4e4eb1af28b1f78412f32af
第6次MD5加密: fc1ebc848e31e0a68e868432225e3c82
第7次MD5加密: 91183e1cb4e46961f86a2ef6287927ad
哈希加密: 92668751
穷举成功, 密码为: admin

并查集

在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集 合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于哪个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(unionFindSet)

并查集数据结构

547. 省份数量，这个LeetCode利用到了并查集数据结构。

有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。

省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。

给你一个 n x n 的矩阵 isConnected ，其中 isConnected\[i][j]=1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。

返回矩阵中 省份 的数量。

输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]]
输出：2

高阶查找算法第一篇_第21张图片

分析

  1. [0,0]=1: 城市0和自己本身就是相连的，所以为1
  2. [0,1]=1: 城市0和城市1相连，所以为1
  3. [0,2]=0: 城市0和城市2不相连，所以为0

了解题目意思之后，最简单粗暴的方法就是暴力遍历，硬求出 i, j 不同时，数组中 1 的数量。我们可以是用并查集来解决此问题。我们先来学习如何构建并查集这样的数据结构

并查集实现

假设先构建 10 个具有亲戚关系的元素

高阶查找算法第一篇_第22张图片

这个时候对应城市的下标值【下标值直接替代父节点即可】再计算代表相连

高阶查找算法第一篇_第23张图片

假设我们要合并城市8和城市1

按照规定，那么 城市1 需要把 父节点 就是 城市8 的 父节点0【arr[1]=0】 ，城市0 需要把自己的下标更改为 7【arr[0]+=arr[1]】 才可以

高阶查找算法第一篇_第24张图片

package unionFindSet;

import java.util.Arrays;

public class UnionFindSet {
    public int[] elem;
    public int n;

    public UnionFindSet(int n) {
        this.elem = new int[n];
        Arrays.fill(elem, -1);
    }

    /**
     * 查找根节点【查找祖先亲戚】
     *
     * @param x
     */
    public int findRoot(int x) {
        if (x < 0) {
            throw new IndexOutOfBoundsException("数据不合法");
        }
        while (elem[x] >= 0) {
            x = elem[x];
        }
        return x;
    }

    /**
     * 合并两个节点【结交亲戚】
     * 本质是合并两个节点的根节点
     *
     * @param x1 合并节点
     * @param x2 被合并节点
     *           x2 被归入 x1 的节点
     */
    public void union(int x1, int x2) {
        int index1 = findRoot(x1);
        int index2 = findRoot(x2);
        if (index1 == index2) return;// 说明都是同一个根节点，则无法合并
        elem[index1] += elem[index2];
        elem[index2] = index1;
    }

    /**
     * 判断是不是同一个集合内【是否是亲戚】
     *
     * @param x1
     * @param x2
     * @return
     */
    public boolean isSameSet(int x1, int x2) {
        return findRoot(x1) == findRoot(x2);
    }

    /**
     * 求数组当中集合个数【有多少个亲戚】
     *
     * @return
     */
    public int getCount() {
        int count = 0;
        for (int i : elem) {
            if (i < 0) {
                ++count;
            }
        }
        return count;
    }


    public void printArr() {
        for (int i : elem) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

底层数组 -1 填充：任何一个元素在最开始没有合并之前，自己本身就是一个父节点

测试

import unionFindSet.UnionFindSet;

public class Test {
    public static void UnionFindSetTest() {
        int n = 10;
        UnionFindSet unionFindSet = new UnionFindSet(10);
        System.out.println("合并: 0和6");
        unionFindSet.union(0, 6);
        System.out.println("合并: 0和7");
        unionFindSet.union(0, 7);
        System.out.println("合并: 0和8");
        unionFindSet.union(0, 8);

        System.out.println("合并: 1和4");
        unionFindSet.union(1, 4);
        System.out.println("合并: 1和9");
        unionFindSet.union(1, 9);

        System.out.println("合并: 2和3");
        unionFindSet.union(2, 3);
        System.out.println("合并: 2和5");
        unionFindSet.union(2, 5);

        unionFindSet.printArr();

        System.out.println("合并: 8和1");
        unionFindSet.union(8, 1);
        unionFindSet.printArr();

        System.out.println(unionFindSet.isSameSet(6, 9));
        System.out.println(unionFindSet.isSameSet(8, 2));
    }

    public static void main(String[] args) {
//        AVLTreeTest();
//        RBTreeTest();
//        MyBitSetTest();
//        BloomFilterTest();
//        MyEncryptTest();
        UnionFindSetTest();
    }
}

合并: 0和6
合并: 0和7
合并: 0和8
合并: 1和4
合并: 1和9
合并: 2和3
合并: 2和5
-4 -3 -3 2 1 2 0 0 0 1 
合并: 8和1
-7 0 -3 2 1 2 0 0 0 1 
true
false

借助上述并查集的实现代码，有两个OJ题目可以顺手解决

//省份的数量: https://leetcode.cn/problems/number-of-provinces/submissions/
public int findCircleNum(int[][] isConnected) {
  int len = isConnected.length;
  UnionFindSet ufs=new UnionFindSet(len);
  for(int i=0; i<len; ++i){
    for(int j=0; j<len; ++j){
      if(isConnected[i][j] == 1){
        ufs.union(i, j);
      }
    }
  }
  return ufs.getCount();
}

//等式的可满足性: https://leetcode.cn/problems/satisfiability-of-equality-equations/submissions/
public boolean equationsPossible(String[] equations) {
  UnionFindSet ufs=new UnionFindSet(26);
  for(String str:equations){
    char[] ch=str.toCharArray();
    if(ch[1] == '='){
      ufs.union(ch[0]-'a', ch[3]-'a');
    }
  }
  for(String str:equations){
    char[] ch=str.toCharArray();
    if(ch[1] != '='){
      int index1 = ufs.findRoot(ch[0]-'a');
      int index2 = ufs.findRoot(ch[3]-'a');
      if(index1 == index2) return false;
    }
  }
  return true;
}

LRUCache

LRUCache数据结构

实现LRUCache数据结构的方式有很多，但为了是先 O ( 1 ) O(1) O(1) 复杂度内的 put, get 则需要使用 双向链表, 哈希表 是最经典高效的搭配。

双向链表的增删时间复杂度 O ( 1 ) O(1) O(1)

哈希表的查找时间复杂度 ( O ( 1 ) ) (O(1)) (O(1))

高阶查找算法第一篇_第25张图片

LRUCache实现

通过继承LinkedHashMap实现

package lruCache;

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache extends LinkedHashMap<String, Integer> {
    private int capacity;

    public LRUCache(int capacity) {
        // 默认为false: 基于插入顺序；true: 基于访问顺序
        super(capacity, 0.75F, true);
        this.capacity = capacity;
    }

    @Override
    public Integer get(Object key) {
        return super.get(key);
    }

    @Override
    public Integer put(String key, Integer value) {
        return super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
        return size() > capacity;
    }
}

手写双向链表借助HashMap实现

package lruCache;

import java.util.HashMap;

public class MyLRUCache<K, V> {
    static class DLinkedNode<K, V> {
        public K key;
        public V val;
        public DLinkedNode prev;
        public DLinkedNode next;

        public DLinkedNode() {
        }

        public DLinkedNode(K key, V val) {
            this.key = key;
            this.val = val;
        }

        @Override
        public String toString() {
            return "{ key=" + key + ", val=" + val + '}';
        }
    }

    // 双向链表头节点
    public DLinkedNode head;
    // 双向链表尾节点
    public DLinkedNode tail;

    // 存储数据
    public HashMap<K, DLinkedNode> cache;
    // 双向链表中有效数据个数
    public int usedSize;
    // 默认的容量
    public int capacity;

    public MyLRUCache(int capacity) {
        this.head = new DLinkedNode();
        this.tail = new DLinkedNode();
        this.capacity = capacity;
        this.cache = new HashMap<>();

        head.next = tail;
        tail.prev = head;
    }

    public V get(K key) {
        DLinkedNode<K, V> node = cache.get(key);
        if (node == null) {
            return null;
        }
        moveToTail(node);
        return node.val;
    }

    /**
     * 存储元素
     * 1.先查找是否存储过
     * 没存储:
     * map: 存储一份
     * 双向链表:
     * 没满: 该节点存储到链表尾巴
     * 满了: 删除头部节点，--usedSize
     * 存储过: 替换更新
     * 2.将改节点移动到末尾
     *
     * @param key
     * @param val
     */
    public void put(K key, V val) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            node = new DLinkedNode(key, val);
            cache.put(key, node);
            addTail(node);
            ++usedSize;
            if (usedSize > capacity) {
                DLinkedNode<K, V> del = removeHead();
                cache.remove(del.key);
                --usedSize;
            }
        } else {
            node.val = val;
        }
        moveToTail(node);
    }

    /**
     * 移动当前节点到尾巴节点
     *
     * @param node
     */
    private void moveToTail(DLinkedNode node) {
        removeNode(node);
        addTail(node);
    }

    private void removeNode(DLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    /**
     * 添加节点到尾巴
     *
     * @param node
     */
    private void addTail(DLinkedNode node) {
        tail.prev.next = node;
        node.prev = tail.prev;
        node.next = tail;
        tail.prev = node;
    }

    /**
     * 清除缓存中的头部节点
     */
    private DLinkedNode<K, V> removeHead() {
        DLinkedNode<K, V> del = head.next;
        head.next = del.next;
        del.next.prev = head;
        return del;
    }

    public void printNodes(String str) {
        System.out.print(str);
        DLinkedNode cur = head.next;
        while (cur != null && cur != tail) {
            System.out.print(cur + " ");
            cur = cur.next;
        }
        System.out.println();
    }
}

测试

import lruCache.LRUCache;
import lruCache.MyLRUCache;

import java.util.LinkedHashMap;

public class Test {
    private static void LRUCacheTest() {
        // false: 基于插入顺序；true: 基于访问顺序
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>(3, 0.75F, true);
        linkedHashMap.put("Java", 1);
        linkedHashMap.put("C++", 2);
        linkedHashMap.put("Python", 3);
        linkedHashMap.put("PHP", 4);
        System.out.println(linkedHashMap);
        linkedHashMap.get("Java");
        linkedHashMap.get("C++");
        linkedHashMap.put("MySQL", 5);
        linkedHashMap.put("Java", 6);
        System.out.println(linkedHashMap);

        LRUCache lruCache = new LRUCache(3);
        lruCache.put("Java", 1);
        lruCache.put("C++", 2);
        lruCache.put("Python", 3);
        lruCache.put("PHP", 4);
        System.out.println(lruCache);
        lruCache.get("Java");
        lruCache.get("C++");
        System.out.println(lruCache);
        lruCache.put("MySQL", 5);
        System.out.println(lruCache);

        MyLRUCache myLRUCache = new MyLRUCache(2);
        myLRUCache.put(1, 1);
        myLRUCache.printNodes("put(1): ");
        myLRUCache.put(2, 2);
        myLRUCache.printNodes("put(2): ");
        myLRUCache.get(1);
        myLRUCache.printNodes("get(1): ");
        myLRUCache.put(3, 3);
        myLRUCache.printNodes("put(3): ");
        myLRUCache.get(2);
        myLRUCache.printNodes("get(2): ");
        myLRUCache.put(4, 4);
        myLRUCache.printNodes("put(4): ");
        myLRUCache.get(1);
        myLRUCache.printNodes("get(1): ");
        myLRUCache.get(3);
        myLRUCache.printNodes("get(3): ");
        myLRUCache.get(4);
        myLRUCache.printNodes("get(4): ");
    }

    public static void main(String[] args) {
        LRUCacheTest();
    }
}

{Java=1, C++=2, Python=3, PHP=4}
{Python=3, PHP=4, C++=2, MySQL=5, Java=6}
{C++=2, Python=3, PHP=4}
{Python=3, PHP=4, C++=2}
{PHP=4, C++=2, MySQL=5}
put(1): { key=1, val=1} 
put(2): { key=1, val=1} { key=2, val=2} 
get(1): { key=2, val=2} { key=1, val=1} 
put(3): { key=1, val=1} { key=3, val=3} 
get(2): { key=1, val=1} { key=3, val=3} 
put(4): { key=3, val=3} { key=4, val=4} 
get(1): { key=3, val=3} { key=4, val=4} 
get(3): { key=4, val=4} { key=3, val=3} 
get(4): { key=3, val=3} { key=4, val=4}

146. LRU 缓存

通过继承的方式实现LRU缓存

import java.util.LinkedHashMap;
import java.util.HashMap;

class LRUCache extends LinkedHashMap<Integer, Integer>{
    public int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }
    
    public Integer get(int key) {
        return super.getOrDefault(key, -1);
    }
    
    public void put(int key, int value) {
        super.put(key, value);
    }

    @Override
    public boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest){
        return size() > capacity;
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

手动实现的LRUCache

class LRUCache {
        static class DLinkedNode {
        public Integer key;
        public Integer val;
        public DLinkedNode prev;
        public DLinkedNode next;

        public DLinkedNode() {
        }

        public DLinkedNode(Integer key, Integer val) {
            this.key = key;
            this.val = val;
        }

        @Override
        public String toString() {
            return "{ key=" + key + ", val=" + val + '}';
        }
    }

    // 双向链表头节点
    public DLinkedNode head;
    // 双向链表尾节点
    public DLinkedNode tail;

    // 存储数据
    public HashMap<Integer, DLinkedNode> cache;
    // 双向链表中有效数据个数
    public int usedSize;
    // 默认的容量
    public int capacity;

    public LRUCache(int capacity) {
        this.head = new DLinkedNode();
        this.tail = new DLinkedNode();
        this.capacity = capacity;
        this.cache = new HashMap<>();

        head.next = tail;
        tail.prev = head;
    }

    public Integer get(Integer key) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            return -1;
        }
        moveToTail(node);
        return node.val;
    }

    /**
     * 存储元素
     * 1.先查找是否存储过
     * 没存储:
     * map: 存储一份
     * 双向链表:
     * 没满: 该节点存储到链表尾巴
     * 满了: 删除头部节点，--usedSize
     * 存储过: 替换更新
     * 2.将改节点移动到末尾
     *
     * @param key
     * @param val
     */
    public void put(Integer key, Integer val) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            node = new DLinkedNode(key, val);
            cache.put(key, node);
            addTail(node);
            ++usedSize;
            if (usedSize > capacity) {
                DLinkedNode del = removeHead();
                cache.remove(del.key);
            }
        } else {
            node.val = val;
        }
        moveToTail(node);
    }

    /**
     * 移动当前节点到尾巴节点
     *
     * @param node
     */
    private void moveToTail(DLinkedNode node) {
        removeNode(node);
        addTail(node);
    }

    private void removeNode(DLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    /**
     * 添加节点到尾巴
     *
     * @param node
     */
    private void addTail(DLinkedNode node) {
        tail.prev.next = node;
        node.prev = tail.prev;
        node.next = tail;
        tail.prev = node;
    }

    /**
     * 清除缓存中的头部节点
     */
    private DLinkedNode removeHead() {
        DLinkedNode del = head.next;
        head.next = del.next;
        del.next.prev = head;
        return del;
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

初阶查找算法总结

本篇博客围绕着“搜索”的主题来讲。
首先我们要弄清楚查找表，记录，关键字，主关键字，静态查找表，动态查找表等这些概念。

顺序表查找

尽管方法很土(简单)，但它却是后面很多查找的基础，注意设置“哨兵”的技巧，可以使得本已经很难提升的简单算法里还是提高了性能

有序表查找

折半查找性能上比原来的顺序表查找有了质的飞跃，由O(N)到O(logN)。之后两种优秀的有序查找：插值查找和斐波那契数列查找，三者各有优缺点。

线性索引查找

稠密索引，分块索引和倒排索引。索引技术被广泛用于文件检索，数据库和搜索引等技术领域。是进一步学习这些技术的基础。

二叉排序树

动态查找最重要的数据结构，兼顾查找性能的基础上让插入和删除也变得效率高。不过为了达到最好的性能，最好构平衡的二叉树才最佳。因此这一块需要我们认真学习关于平衡二叉树(AVL树)，了解AVL树是如何处理平衡性的问题

B树

B树这种数据结构是针对内存与外存之间的存取而专门设计的。由于内外存的查找性能更多取决于读取的次数，因此在设计中要考虑B树的平衡和层次。先通过最最简单的B树(2-3 树)来理解如何构建、插入、删除元素的操作，再通过2-3-4树的深化，最终来理解B树的原理。之后，我们还介绍了B+树的设计思想。

散列表

散列表是一种非常高效的查找数据结构，在原理上也与前面的查找不尽相同，它回避了关键字之间反复比较的烦琐，而是直接一步到位查找结果。当然，这也就带来了记录之间没有任何关联的弊端。应该说，散列表对于那种查找性能要求高，记录之间关系无要求的数据有非常好的适用性。在学习中要注意的是散列函数的选择和处理冲突的方法。

位图

存储固定的整数类型数据，遇到小数，字符串就无法存储。再处理海量数据的时候具有很高的存储效率和查询效率

布隆过滤器

修补位图的不足，应用范围更加广泛和多样化

并查集

主要用来判断是否两者具有一定的关联关系【图数据结构中需要用到次数据结构判断是否有环】

LRUCache

最后最近访问的数据，经常把用到的数据放在前边。

你可能感兴趣的:(数据结构与算法,算法,java,数据结构)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
    ?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • 推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 多线程编程之join()方法 周凡杨 javaJOIN多线程编程线程
    现实生活中，有些工作是需要团队中成员依次完成的，这就涉及到了一个顺序问题。现在有T1、T2、T3三个工人，如何保证T2在T1执行完后执行，T3在T2执行完后执行？问题分析：首先问题中有三个实体，T1、T2、T3， 因为是多线程编程，所以都要设计成线程类。关键是怎么保证线程能依次执行完呢？   Java实现过程如下： public class T1 implements Runnabl
  • java中switch的使用 bingyingao javaenumbreakcontinue
    java中的switch仅支持case条件仅支持int、enum两种类型。 用enum的时候，不能直接写下列形式。 switch (timeType) { case ProdtransTimeTypeEnum.DAILY: break; default: br
  • hive having count 不能去重 daizj hive去重having count计数
    hive在使用having count()是，不支持去重计数   hive (default)> select imei from t_test_phonenum where ds=20150701 group by imei having count(distinct phone_num)>1 limit 10;  FAILED: SemanticExcep
  • WebSphere对JSP的缓存 周凡杨 WAS JSP 缓存
          对于线网上的工程，更新JSP到WebSphere后，有时会出现修改的jsp没有起作用，特别是改变了某jsp的样式后，在页面中没看到效果，这主要就是由于websphere中缓存的缘故，这就要清除WebSphere中jsp缓存。要清除WebSphere中JSP的缓存，就要找到WAS安装后的根目录。        现服务
  • 设计模式总结 朱辉辉33 java设计模式
    1.工厂模式   1.1 工厂方法模式 (由一个工厂类管理构造方法)      1.1.1普通工厂模式(一个工厂类中只有一个方法)      1.1.2多工厂模式(一个工厂类中有多个方法)      1.1.3静态工厂模式(将工厂类中的方法变成静态方法) &n
  • 实例：供应商管理报表需求调研报告 老A不折腾 finereport报表系统报表软件信息化选型
    引言 随着企业集团的生产规模扩张，为支撑全球供应链管理，对于供应商的管理和采购过程的监控已经不局限于简单的交付以及价格的管理，目前采购及供应商管理各个环节的操作分别在不同的系统下进行，而各个数据源都独立存在，无法提供统一的数据支持；因此，为了实现对于数据分析以提供采购决策，建立报表体系成为必须。 业务目标 1、通过报表为采购决策提供数据分析与支撑 2、对供应商进行综合评估以及管理，合理管理和
  • mysql 林鹤霄
    转载源：http://blog.sina.com.cn/s/blog_4f925fc30100rx5l.html mysql -uroot -p ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)   [root@centos var]# service mysql
  • Linux下多线程堆栈查看工具(pstree、ps、pstack) aigo linux
    原文：http://blog.csdn.net/yfkiss/article/details/6729364   1. pstree pstree以树结构显示进程$ pstree -p work | grep adsshd(22669)---bash(22670)---ad_preprocess(4551)-+-{ad_preprocess}(4552)  &n
  • html input与textarea 值改变事件 alxw4616 JavaScript
    // 文本输入框(input) 文本域(textarea)值改变事件 // onpropertychange(IE) oninput(w3c) $('input,textarea').on('propertychange input', function(event) {      console.log($(this).val()) });  
  • String类的基本用法 百合不是茶 String
      字符串的用法;     // 根据字节数组创建字符串 byte[] by = { 'a', 'b', 'c', 'd' }; String newByteString = new String(by);         1,length()  获取字符串的长度     &nbs
  • JDK1.5 Semaphore实例 bijian1013 javathreadjava多线程Semaphore
    Semaphore类        一个计数信号量。从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。 S
  • 使用GZip来压缩传输量 bijian1013 javaGZip
            启动GZip压缩要用到一个开源的Filter：PJL Compressing Filter。这个Filter自1.5.0开始该工程开始构建于JDK5.0，因此在JDK1.4环境下只能使用1.4.6。         PJL Compressi
  • 【Java范型三】Java范型详解之范型类型通配符 bit1129 java
        定义如下一个简单的范型类，   package com.tom.lang.generics; public class Generics<T> { private T value; public Generics(T value) { this.value = value; } }
  • 【Hadoop十二】HDFS常用命令 bit1129 hadoop
    1. 修改日志文件查看器   hdfs oev -i edits_0000000000000000081-0000000000000000089 -o edits.xml cat edits.xml   修改日志文件转储为xml格式的edits.xml文件，其中每条RECORD就是一个操作事务日志   2. fsimage查看HDFS中的块信息等 &nb
  • 怎样区别nginx中rewrite时break和last ronin47
    在使用nginx配置rewrite中经常会遇到有的地方用last并不能工作，换成break就可以，其中的原理是对于根目录的理解有所区别，按我的测试结果大致是这样的。 location /    {         proxy_pass http://test; 
  • java-21.中兴面试题 输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 , 使其和等于 m bylijinnan java
    import java.util.ArrayList; import java.util.List; import java.util.Stack; public class CombinationToSum { /* 第21 题 2010 年中兴面试题 编程求解： 输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 , 使其和等
  • eclipse svn 帐号密码修改问题 开窍的石头 eclipseSVNsvn帐号密码修改
    问题描述：      Eclipse的SVN插件Subclipse做得很好，在svn操作方面提供了很强大丰富的功能。但到目前为止，该插件对svn用户的概念极为淡薄，不但不能方便地切换用户，而且一旦用户的帐号、密码保存之后，就无法再变更了。 解决思路：      删除subclipse记录的帐号、密码信息，重新输入
  • [电子商务]传统商务活动与互联网的结合 comsci 电子商务
          某一个传统名牌产品，过去销售的地点就在某些特定的地区和阶层，现在进入互联网之后，用户的数量群突然扩大了无数倍，但是，这种产品潜在的劣势也被放大了无数倍，这种销售利润与经营风险同步放大的效应，在最近几年将会频繁出现。。。。        如何避免销售量和利润率增加的
  • java 解析 properties-使用 Properties-可以指定配置文件路径 cuityang javaproperties
    #mq xdr.mq.url=tcp://192.168.100.15:61618; import java.io.IOException; import java.util.Properties; public class Test { String conf = "log4j.properties"; private static final
  • Java核心问题集锦 darrenzhu java基础核心难点
    注意，这里的参考文章基本来自Effective Java和jdk源码 1)ConcurrentModificationException 当你用for each遍历一个list时，如果你在循环主体代码中修改list中的元素，将会得到这个Exception，解决的办法是： 1)用listIterator, 它支持在遍历的过程中修改元素， 2)不用listIterator, new一个
  • 1分钟学会Markdown语法 dcj3sjt126com markdown
    markdown 简明语法 基本符号 *,-,+ 3个符号效果都一样，这3个符号被称为 Markdown符号 空白行表示另起一个段落 `是表示inline代码，tab是用来标记 代码段，分别对应html的code，pre标签 换行 单一段落( <p>) 用一个空白行 连续两个空格 会变成一个 <br> 连续3个符号，然后是空行
  • Gson使用二（GsonBuilder） eksliang jsongsonGsonBuilder
    转载请出自出处：http://eksliang.iteye.com/blog/2175473 一.概述     GsonBuilder用来定制java跟json之间的转换格式   二.基本使用 实体测试类： 温馨提示：默认情况下@Expose注解是不起作用的,除非你用GsonBuilder创建Gson的时候调用了GsonBuilder.excludeField
  • 报ClassNotFoundException: Didn't find class "...Activity" on path: DexPathList gundumw100 android
    有一个工程，本来运行是正常的，我想把它移植到另一台PC上，结果报： java.lang.RuntimeException: Unable to instantiate activity ComponentInfo{com.mobovip.bgr/com.mobovip.bgr.MainActivity}: java.lang.ClassNotFoundException: Didn't f
  • JavaWeb之JSP指令 ihuning javaweb
      要点   JSP指令简介  page指令  include指令    JSP指令简介    JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。 JSP指令的基本语法格式： <%@ 指令 属性名="
  • mac上编译FFmpeg跑ios 啸笑天 ffmpeg
    1、下载文件：https://github.com/libav/gas-preprocessor， 复制gas-preprocessor.pl到/usr/local/bin/下， 修改文件权限：chmod 777 /usr/local/bin/gas-preprocessor.pl 2、安装yasm-1.2.0 curl http://www.tortall.net/projects/yasm
  • sql mysql oracle中字符串连接 macroli oraclesqlmysqlSQL Server
    有的时候，我们有需要将由不同栏位获得的资料串连在一起。每一种资料库都有提供方法来达到这个目的： MySQL: CONCAT() Oracle: CONCAT(), || SQL Server: + CONCAT() 的语法如下： Mysql 中 CONCAT(字串1, 字串2, 字串3, ...): 将字串1、字串2、字串3，等字串连在一起。 请注意，Oracle的CON
  • Git fatal: unab SSL certificate problem: unable to get local issuer ce rtificate qiaolevip 学习永无止境每天进步一点点git纵观千象
    // 报错如下： $ git pull origin master fatal: unable to access 'https://git.xxx.com/': SSL certificate problem: unable to get local issuer ce rtificate   // 原因： 由于git最新版默认使用ssl安全验证，但是我们是使用的git未设
  • windows命令行设置wifi surfingll windowswifi笔记本wifi
    还没有讨厌无线wifi的无尽广告么，还在耐心等待它慢慢启动么 教你命令行设置 笔记本电脑wifi： 1、开启wifi命令 netsh wlan set hostednetwork mode=allow ssid=surf8 key=bb123456 netsh wlan start hostednetwork pause 其中pause是等待输入，可以去掉 2、
  • Linux（Ubuntu）下安装sysv-rc-conf wmlJava linuxubuntusysv-rc-conf
    安装：sudo apt-get install sysv-rc-conf 使用：sudo sysv-rc-conf 操作界面十分简洁，你可以用鼠标点击，也可以用键盘方向键定位，用空格键选择，用Ctrl+N翻下一页，用Ctrl+P翻上一页，用Q退出。     背景知识 sysv-rc-conf是一个强大的服务管理程序，群众的意见是sysv-rc-conf比chkconf
  • svn切换环境，重发布应用多了javaee标签前缀 zengshaotao javaee
    更换了开发环境，从杭州，改变到了上海。svn的地址肯定要切换的，切换之前需要将原svn自带的.svn文件信息删除，可手动删除，也可通过废弃原来的svn位置提示删除.svn时删除。   然后就是按照最新的svn地址和规范建立相关的目录信息，再将原来的纯代码信息上传到新的环境。然后再重新检出，这样每次修改后就可以看到哪些文件被修改过，这对于增量发布的规范特别有用。   检出
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他