为什么二进制搜索数组比二进制搜索树快一点？

Question

我使用这两个函数来从大量数据中搜索查询。 起初它们的速度大致相同，但是当大小变得很大时，二进制搜索数组会稍快一些。 那是因为缓存效果吗？ 数组具有顺序。 树有吗？

int binary_array_search(int array[], int length, int query){
//the array has been sorted

  int left=0, right=length-1;
  int mid;
  while(left <= right){
    mid = (left+right)/2;
    if(query == array[mid]){
      return 1;
    }
    else if(query < array[mid]){
      right = mid-1;
    }
    else{
      left = mid+1;
    }
  }
  return 0;
}

// Search a binary search tree
int binary_tree_search(bst_t *tree, int ignore, int query){
  node_t *node = tree->root;
  while(node != NULL){
    int data = node->data;
    if(query < data){
      node = node->left;
    }
    else if(query > data){
      node =node->right;
    }
    else{
      return 1;
    }
  }
  return 0;
}

结果如下：

LENGTH   SEARCHES    binary search  array    binary search tree

 1024       10240        7.336000e-03            8.230000e-03
 2048       20480        1.478000e-02           1.727900e-02
 4096       40960        3.001100e-02           3.596800e-02
 8192       81920        6.132700e-02          7.663800e-02
 16384       163840      1.251240e-01          1.637960e-01

Answer 1

数组可能并且应该更快的原因有很多：

树中的节点是更大然后数组中的项，由于至少3次left和right指针。

例如，在32位系统上，您将拥有12个字节而不是4个字节。机会是将这12个字节填充或对齐为16个字节。 在64位系统上，我们得到8和24至32字节。

这意味着，使用阵列时，可以在L1缓存中加载3至4倍的项目。

树中的节点是在堆上分配的，它们可能在内存中的任何位置，具体取决于分配的顺序（同样，堆可能会碎片化）-创建这些节点（使用new或alloc ）也将花费更多时间与可能的一次阵列分配相比-但这可能不是此处速度测试的一部分。

要访问数组中的单个值，只需执行一次读取，对于树，我们需要两个： left指针或right指针以及该值。

当达到较低的搜索级别时，要比较的项目将在数组中（可能已经在L1高速缓存中）靠在一起，而它们可能会散布在树的内存中。

由于引用的局部性，大多数时间数组将更快。

Answer 2

那是因为缓存效果吗？

当然，这是主要原因。 在现代CPU上，缓存透明地用于读取/写入内存中的数据。

缓存比主内存（DRAM）快得多。 为了给您一个视角，访问1级缓存中的数据大约需要4个CPU周期，而访问同一CPU上的DRAM大约需要200个CPU周期，即快50倍。

高速缓存在称为高速缓存行的小块上运行，通常长64个字节。

更多信息： https : //en.wikipedia.org/wiki/CPU_cache

数组具有顺序。 树有吗？

数组是单个数据块。 数组的每个元素都与其相邻元素相邻，即：

+-------------------------------+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+-------------------------------+
  block of 32 bytes (8 times 4)

每个数组访问都获取一个缓存行，即64个字节或16个int值。 因此，对于数组而言，下一次访问将在同一高速缓存行内的可能性很高（尤其是在二进制搜索的末尾），因此不需要进行内存访问。

另一方面，树节点被一个一个地分配：

                      +------------------------------------------------+
+------------------+  | +------------------+    +------------------+   |
| 0 | left | right | -+ | 2 | left | right | <- | 1 | left | right | <-+
+------------------+    +------------------+    +------------------+
 block 0 of 24 bytes     block 2 of 24 bytes     block 1 of 24 bytes

我们可以看到，仅存储3个值，就比在上面的数组中存储8个值要多2倍的内存。 因此，树结构更稀疏，并且每64个字节的缓存行统计上的数据更少。

同样，每个内存分配都会返回内存中的一个块，该块可能与先前分配的树节点不相邻。

另外，分配器将每个内存块至少对齐8个字节（在64位CPU上），因此在那里浪费了一些字节。 更何况，我们需要将这些存储left和right指针中的每个节点...

因此，即使在排序的最后阶段，每个树访问都将需要获取高速缓存行，即比数组访问慢。

那么为什么在测试中阵列快一点呢？ 这是由于二进制搜索。 在排序的开始，我们非常随机地访问数据，并且每次访问都与先前的访问相距很远。 因此，数组结构可以在排序的最后将其增强。

只是为了好玩，尝试比较数组中的线性搜索（即基本搜索循环）与树中的二进制搜索。 我敢打赌，您会对结果感到惊讶;）