后台研发常见问题（数据结构与算法）

最新推荐文章于 2024-04-17 14:20:53 发布

Unique-You

最新推荐文章于 2024-04-17 14:20:53 发布

阅读量2.7k

点赞数 2

分类专栏：数据结构文章标签：数据结构与算法后台面试常见问题

本文链接：https://blog.csdn.net/qq_22238021/article/details/79798444

版权

数据结构专栏收录该内容

31 篇文章 15 订阅

订阅专栏

一、Hash表

Hash表实现（拉链和分散地址）点击打开链接

Hash策略常见的有哪些？

STL中hash_map扩容发生什么？

(1) 创建一个新桶，该桶是原来桶两倍大最接近的质数(判断n是不是质数的方法：用n除2到$sqrt(n)$范围内的数) ；
(2) 将原来桶里的数通过指针的转换，插入到新桶中(注意STL这里做的很精细，没有直接将数据从旧桶遍历拷贝数据插入到新桶，而是通过指针转换)

(3) 通过swap函数将新桶和旧桶交换，销毁新桶。

hash_map基于hash table（哈希表）。哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存。然而在当前可利用内存越来越多的情况下，用空间换时间的做法是值得的。另外，编码比较容易也是它的特点之一。

其基本原理是：使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素“分类”，然后将这个元素存储在相应“类”所对应的地方，称为桶。

但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了“冲突”，换句话说，就是把不同的元素分在了相同的“类”之中。总的来说，“直接定址”与“解决冲突”是哈希表的两大特点。

1 与map定义对比

相同点：二者都是STL中的关联容器，且都具有以下两个性质：

a.键值形式，即元素类型都是键值形式：pair<const Key, Data>；

b.键唯一性，即没有两个元素有相同的键：key。

不同点：

hash_map是一种将对象的值data和键key关联起来的哈希关联容器（Hashed Associative Container），而map是一种将对象的值data和键key关联起来的排序关联容器（Sorted Associative Container）。所谓哈希关联容器是使用hash table实现的关联容器，它不同于一般的排序关联容器：哈希关联容器的元素没有特定的顺序，大部分操作的最差时间复杂度为O(n)，平均时间复杂度为常数，所以在不要求排序而只要求存取的应用中，哈希关联容器的效率要远远高于排序关联容器。

2 与map实现对比

map的底层是用红黑树实现的，操作的时间复杂度是O(log(n))级别；hash_map的底层是用hash table实现的，操作的时间复杂度是常数级别。

3 与map应用对比

在元素数量达到一定数量级时如果要求效率优先，则采用hash_map。但是注意：虽然hash_map 操作速度比map的速度快，但是hash函数以及解决冲突都需要额外的执行时间，且hash_map构造速度慢于map。其次，hash_map由于基于hash table，显然是空间换时间，因此hash_map对内存的消耗高于map。所以选择时需要权衡三个因素：速度，数据量，内存。

（1）hash_map原理

hash_map使用hash table来实现，首先分配内存，形成许多bucket用来存放元素，然后利用hash函数，对元素的key进行映射，存放到对应的bucket内。这其中hash函数用于定址，额外的比较函数用于解决冲突。该过程可以描述为：

a.计算元素的key

b.通过hash函数对key进行映射（常见的为取模），得到hash值，即为对应的bucket索引

c.存放元素的key和data在bucket内。

对应的查询过程是：

a.计算元素的key

b.通过hash函数对key进行映射（常见的为取模），得到hash值，即为对应的bucket索引

c.比较bucket内元素的key’与该key相等，若不相等则没有找到。

d.若相等则取出该元素的data。

所以实现hash_map最重要的两个东西就是hash函数和比较函数。以下以SGI的hash_map为例子进行说明。

hash_map中直接地址用hash函数生成，解决冲突，用比较函数解决。这里可以看出，如果每个桶内部只有一个元素，那么查找的时候只有一次比较。当许多桶内没有值时，许多查询就会更快了(指查不到的时候).

由此可见，要实现哈希表, 和用户相关的是：hash函数和比较函数。这两个参数刚好是我们在使用hash_map时需要指定的参数。

hash_map函数：

hash_map的函数和map的函数差不多。具体函数的参数和解释，请参看SGI的hash_map介绍，这里主要介绍几个常用函数：

hash_map(size_type n)：如果讲究效率，这个参数是必须要设置的。n 主要用来设置hash_map 容器中hash桶的个数。桶个数越多，hash函数发生冲突的概率就越小，重新申请内存的概率就越小。n越大，效率越高，但是内存消耗也越大。

const_iterator find(const key_type& k)const：用查找，输入为键值，返回为迭代器。

data_type& operator[](constkey_type& k) ：像数组一样随机访问元素。注意：当使用[key]操作符时，如果容器中没有key元素，这就相当于自动增加了一个key元素（等同于插入操作）。所以如果只是想知道容器中是否有key元素时，可以使用find函数。

insert函数：在容器中不包含key值时，insert函数和[]操作符的功能差不多。但是当容器中元素越来越多，每个桶中的元素会增加，为了保证效率， hash_map会自动申请更大的内存，以生成更多的桶。因此在insert以后，以前的iterator有可能是不可用的。

erase 函数：在insert的过程中，当每个桶的元素太多时，hash_map可能会自动扩充容器的内存，但在SGI的STL中erase并不自动回收内存。因此你调用erase后，其他元素的iterator还是可用的。

HashMap的整体结构如下

　　简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度依然为O(1)，因为最新的Entry会插入链表头部，仅需简单改变引用链即可，而对于查找操作来讲，此时就需要遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

二、树

二叉树结构，二叉查找树实现；
二叉树的六种遍历；
二叉树的按层遍历；
递归是解决二叉树相关问题的神级方法；
树的各种常见算法题点击打开链接

三、红黑树

节点为红色或者黑色；
根节点为黑色；
从根节点到每个叶子节点经过的黑色节点个数的和相同；
如果父节点为红色，那么其子节点就不能为红色。

四、红黑树与AVL树区别

红黑树与AVL树都是平衡树，但是AVL是完全平衡的(平衡就是值树中任意节点的左子树和右子树高度差不超过1)；红黑树效率更高，因为AVL为了保证其完全平衡，插入和删除的时候在最坏的情况下要旋转logN次，而红黑树插入和删除的旋转次数要比AVL少。

五、Trie树（字典树）点击打开链接

每个节点保存一个字符
根节点不保存字符
每个节点最多有n个子节点(n是所有可能出现字符的个数)
查询的复杂父为O(k)，k为查询字符串长度

六、链表

链表的插入和删除，单向和双向链表都要会
链表的问题考虑多个指针和递归
(1) 反向打印链表(递归)
(2) 打印倒数第K个节点(前后指针)
(3) 链表是否有环(快慢指针)等等

七、栈和队列

队列和栈的区别？(从实现，应用，自身特点多个方面来阐述，不要只说一个先入先出，先入后出，这个你会别人也会，要展现出你比别人掌握的更深)
典型的应用场景

1、队列先进先出，栈先进后出

2、对插入和删除操作的"限定"。栈是限定只能在表的一端进行插入和删除操作的线性表。队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。

删除数据元素的位置不同，栈的删除操作在表尾进行，队列的删除操作在表头进行。

3、遍历数据速度不同：队列：基于地址指针进行遍历，而且可以从头部或者尾部进行遍历，但不能同时遍历，无需开辟空间，因为在遍历的过程中不影响数据结构，所以遍历速度要快；栈：只能从顶部取数据，也就是说最先进入栈底的，需要遍历整个栈才能取出来，而且在遍历数据的同时需要为数据开辟临时空间，保持数据在遍历前的一致性。

4、应用场景不同；常见栈的应用场景包括括号问题的求解，表达式的转换和求值，函数调用和递归实现，深度优先搜索遍历等；常见的队列的应用场景包括计算机系统中各种资源的管理，消息缓冲器的管理和广度优先搜索遍历等。

5、顺序栈能够实现多栈空间共享，而顺序队列不能。

八、海量数据问题
十亿整数（随机生成，可重复）中前K最大的数
类似问题的解决方法思路：首先哈希将数据分成N个文件，然后对每个文件建立K个元素最小/大堆（根据要求来选择）。最后将文件中剩余的数插入堆中，并维持K个元素的堆。最后将N个堆中的元素合起来分析。可以采用归并的方式来合并。在归并的时候为了提高效率还需要建一个N个元素构成的最大堆，先用N个堆中的最大值填充这个堆，然后就是弹出最大值，指针后移的操作了。当然这种问题在现在的互联网技术中，一般就用map-reduce框架来做了。
大数据排序相同的思路：先哈希（哈希是好处是分布均匀，相同的数在同一个文件中），然后小文件装入内存快排，排序结果输出到文件。最后建堆归并。 十亿整数（随机生成，可重复）中出现频率最高的一千个

九、排序算法点击打开链接

排序算法当然是基础内容了，必须至少能快速写出，快排，建堆，和归并
每种算法的时间空间复杂度，最好最差平均情况

十、位运算

bitmap算法：

一、bitmap算法思想
32位机器上，一个整形，比如int a; 在内存中占32bit位，可以用对应的32bit位对应十进制的0-31个数，bitmap算法利用这种思想处理大量数据的排序与查询.
优点：1.运算效率高，不许进行比较和移位；2.占用内存少，比如N=10000000；只需占用内存为N/8=1250000Byte=1.25M。
缺点：所有的数据不能重复。即不能对重复的数据进行排序和查找。

示例：

申请一个int型的内存空间，则有4Byte，32bit。输入 4， 2, 1, 3时：

输入4：

输入2：

输入1：

输入3：

思想比较简单，关键是十进制和二进制bit位需要一个map图，把十进制的数映射到bit位。下面详细说明这个map映射表。
二、map映射表
假设需要排序或者查找的总数N=10000000，那么我们需要申请内存空间的大小为int a[1 + N/32]，其中：a[0]在内存中占32为可以对应十进制数0-31，依次类推：
bitmap表为：
a[0]--------->0-31
a[1]--------->32-63
a[2]--------->64-95
a[3]--------->96-127
..........
那么十进制数如何转换为对应的bit位，下面介绍用位移将十进制数转换为对应的bit位。
三、位移转换
浅析上面的对应表：
1.求十进制0-N对应在数组a中的下标：
十进制0-31，对应在a[0]中，先由十进制数n转换为与32的余可转化为对应在数组a中的下标。比如n=24,那么 n/32=0，则24对应在数组a中的下标为0。又比如n=60,那么n/32=1，则60对应在数组a中的下标为1，同理可以计算0-N在数组a中的下标。
2.求0-N对应0-31中的数：
十进制0-31就对应0-31，而32-63则对应也是0-31，即给定一个数n可以通过模32求得对应0-31中的数。

3.利用移位0-31使得对应32bit位为1.

（我觉得N应该是所有数中最大的数）

#include <stdio.h>  
  
#define BITSPERWORD 32  
#define SHIFT 5  
#define MASK 0x1F  
#define N 10000000  
  
int a[1 + N/BITSPERWORD];//申请内存的大小  
  
//set 设置所在的bit位为1  
//clr 初始化所有的bit位为0  
//test 测试所在的bit为是否为1  
  
void set(int i) {        a[i>>SHIFT] |=  (1<<(i & MASK)); }  
void clr(int i) {        a[i>>SHIFT] &= ~(1<<(i & MASK)); }  
int  test(int i){ return a[i>>SHIFT] &   (1<<(i & MASK)); }  
  
int main()  
{   int i;  
    for (i = 0; i < N; i++)  
        clr(i);    
    while (scanf("%d", &i) != EOF)  
        set(i);  //对输入的每一个数设置相应的位为1
    for (i = 0; i < N; i++)  
        if (test(i))  
            printf("%d\n", i);  
  
    return 0;  
}

解析本例中的void set(int i) {        a[i>>SHIFT] |= (1<<(i & MASK)); }
1.i>>SHIFT：
其中SHIFT=5，即i右移5为，2^5=32,相当于i/32，即求出十进制i对应在数组a中的下标。比如i=20，通过i>>SHIFT=20>>5=0 可求得i=20的下标为0；
2.i & MASK：
其中MASK=0X1F,十六进制转化为十进制为31，二进制为0001 1111，i&（0001 1111）相当于保留i的后5位。
比如i=23，二进制为：0001 0111，那么
                         0001 0111
                   &    0001 1111 = 0001 0111 十进制为：23
比如i=83，二进制为：0000 0000 0101 0011，那么
                          0000 0000 0101 0011
                     &   0000 0000 0001 0000 = 0000 0000 0001 0011 十进制为：19
i & MASK相当于i%32。
3.1<<(i & MASK)
相当于把1左移 (i & MASK)位。
比如(i & MASK)=20，那么i<<20就相当于：
         0000 0000 0000 0000 0000 0000 0000 0001 >>20
      =0000 0000 0000 1000 0000 0000 0000 0000
4.void set(int i) {        a[i>>SHIFT] |= (1<<(i & MASK)); }等价于：
void set(int i)
{
   a[i/32] |= (1<<(i%32));
}

布隆过滤器：

几十亿个数经常要查找某一个数在不在里面，使用布隆过滤器，布隆过滤器的原理。布隆过滤器可能出现误判，怎么保证无误差？

然而Bitmap不是万能的，如果数据量大到一定程度，如开头写的64bit类型的数据，还能不能用Bitmap？我们来算一算：

264 b i t = 261 B y t e = 2048 P B = 2 E B

EB（Exabyte，艾字节）这个计算机科学中统计数据量的单位有多大，有兴趣的小伙伴可以查阅下资料。这个量级的Bitmap，已经不是人类硬件所能承担的了。我相信谁也不会想用集群去计算这么一个问题吧？所以Bitmap的好处在于空间复杂度不随原始集合内元素的个数增加而增加，而它的坏处也源于这一点——空间复杂度随集合内最大元素增大而线性增大。

所以接下来，我们要引入另一个著名的工业实现—— 布隆过滤器（Bloom Filter）。如果说Bitmap对于每一个可能的整型值，通过直接寻址的方式进行映射，相当于使用了一个哈希函数，那布隆过滤器就是引入了k（k>1）个 相互独立 的哈希函数，保证在给定的空间、误判率下，完成元素判重的过程。下图中是k=3

k=3 时的布隆过滤器。
图1 布隆过滤器（来源：wiki）

x,y,z经由哈希函数映射将各自在Bitmap中的3个位置置为1，当w出现时，仅当3个标志位都为1时，才表示w在集合中。图中所示的情况，布隆过滤器将判定w不在集合中。

直观的说，bloom算法类似一个hash set，用来判断某个元素（key）是否在某个集合中。

和一般的hash set不同的是，这个算法无需存储key的值，对于每个key，只需要k个比特位，每个存储一个标志，用来判断key是否在集合中。

布隆过滤器的原理：底层使用的是位图.当一个元素被加入集合时,通过 K 个 Hash 函数将这个元素映射成一个位阵列（Bit array）中的 K 个点,把它们置为 1。检索时，我们只要看看这些点是不是都是 1 就（大约）知道集合中有没有它了：
1、如果这些点有任何一个 0，则被检索元素一定不在；

2、如果都是 1，则被检索元素很可能在。

算法：
1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数
2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为0
3. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为1
4. 判断某个key是否在集合时，用k个hash函数计算出k个散列值，并查询数组中对应的比特位，如果所有的比特位都是1，认为在集合中。

优点：不需要存储key，节省空间。空间效率和查询时间都远远超过一般的算法，布隆过滤器存储空间和插入 / 查询时间都是常数O(k)。另外, 散列函数相互之间没有关系，方便由硬件并行实现。布隆过滤器不需要存储元素本身，在某些对保密要求非常严格的场合有优势

缺点：
1. 误算率是其中之一。随着存入的元素数量增加，误算率随之增加。但是如果元素数量太少，则使用散列表足矣。算法判断key在集合中时，有一定的概率key其实不在集合中。

2. 无法删除。我们很容易想到把位数组变成整数数组，每插入一个元素相应的计数器加 1, 这样删除元素时将计数器减掉就可以了。然而要保证安全地删除元素并非如此简单。首先我们必须保证删除的元素在布隆过滤器里面. 这一点单凭这个过滤器是无法保证的。另外计数器回绕也会造成问题。

基本概念

如果想判断一个元素是不是在一个集合里，一般想到的是将所有元素保存起来，然后通过比较确定。链表，树等等数据结构都是这种思路. 但是随着集合中元素的增加，我们需要的存储空间越来越大，检索速度也越来越慢。不过世界上还有一种叫作散列表（又叫哈希表，Hash table）的数据结构。它可以通过一个Hash函数将一个元素映射成一个位阵列（Bit Array）中的一个点。这样一来，我们只要看看这个点是不是 1 就知道可以集合中有没有它了。这就是布隆过滤器的基本思想。

Hash面临的问题就是冲突。假设 Hash 函数是良好的，如果我们的位阵列长度为 m 个点，那么如果我们想将冲突率降低到例如 1%, 这个散列表就只能容纳 m/100 个元素。显然这就不叫空间有效了（Space-efficient）。解决方法也简单，就是使用多个 Hash，如果它们有一个说元素不在集合中，那肯定就不在。如果它们都说在，虽然也有一定可能性它们在说谎，不过直觉上判断这种事情的概率是比较低的。

False positives 概率推导

假设 Hash 函数以等概率条件选择并设置 Bit Array 中的某一位，m 是该位数组的大小，k 是 Hash 函数的个数，

那么位数组中某一特定的位在进行元素插入时的 Hash 操作中没有被置位的概率是：

那么在所有 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，假正例概率最大为：

Unique-You

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
后台研发常见问题（数据结构与算法）

一、Hash表Hash表实现（拉链和分散地址）点击打开链接 Hash策略常见的有哪些？ STL中hash_map扩容发生什么？(1) 创建一个新桶，该桶是原来桶两倍大最接近的质数(判断n是不是质数的方法：用n除2到$sqrt(n)$范围内的数) ；(2) 将原来桶里的数通过指针的转换，插入到新桶中(注意STL这里做的很精细，没有直接将数据从旧桶遍历拷贝数据插入到新桶，而是通过指针转换)(3) 通过...
复制链接

扫一扫