[关闭]
@guoxs 2016-05-15T06:16:26.000000Z 字数 13745 阅读 3242

查找算法总结

数据结构与算法


顺序表查找

查找表按照操作方式来分有两大种:静态查找表动态查找表

静态查找表(Static Search Table):只作查找操作的查找表。
它的主要操作有:(1)查询某个“特定的”数据元素是否在查找表中。(2)检索某个“特定的”数据元素和各种属性。
动态查找表(Dynamic Search Table):在查找过程中同时插入查找表中不存在的数据元素,或者从查找表中删除已经存在的某个数据元素。
动态查找表的操作有:(1)查找时插入数据元素。(2)查找时删除数据元素。

有序表查找

  1. /* 顺序查找,a为数组,n为要查找的数组长度,key为要查找的关键字 */
  2. int Sequential_Search(int *a, int n, int key)
  3. {
  4. int i;
  5. for (i = 1; i <= n; i++)
  6. {
  7. if (a[i] == key)
  8. return i;
  9. }
  10. return 0;
  11. }

该算法每次都要判断i是否越界,可设置哨兵

  1. /* 有哨兵顺序查找 */
  2. int Sequential_Search2(int *a, int n, int key)
  3. {
  4. int i;
  5. /* 设置a[0]为关键字值,我们称之为“哨兵” */
  6. a[0] = key;
  7. /* 循环从数组尾部开始 */
  8. i = n;
  9. while (a[i] != key)
  10. {
  11. i--;
  12. }
  13. /* 返回0则说明查找失败 */
  14. return i;
  15. }

时间复杂度 O(n)

二分查找

前提是有序数组

  1. int Binary_Search(int *a, int n, int key)
  2. {
  3. int low, high, mid;
  4. /* 定义最低下标为记录首位 */
  5. low = 1;
  6. /* 定义最高下标为记录末位 */
  7. high = n;
  8. while (low <= high)
  9. {
  10. /* 折半 */
  11. mid = (low + high) / 2;
  12. /* 若查找值比中值小 */
  13. if (key < a[mid])
  14. /* 最高下标调整到中位下标小一位 */
  15. high = mid - 1;
  16. /* 若查找值比中值大 */
  17. else if (key > a[mid])
  18. /* 最低下标调整到中位下标大一位 */
  19. low = mid + 1;
  20. else
  21. /* 若相等则说明mid即为查找到的位置 */
  22. return mid;
  23. }
  24. return 0;
  25. }

时间复杂度 O(logn)

插值查找

二分查找的推广,有时候不一定折半最优。


也就是mid等于最低下标low加上最高下标high与low的差的一半。1/2可以进行改进,改进为下面的计算方案:

相应代码需要改写为

  1. mid=low+ (high-low)*(key-a[low])/(a[high]-a[low]); /* 插值 */

时间复杂度也是O(logn),但对于表长较大,而关键字分布又比较均匀的查找表来说,插值查找算法的平均性能比折半查找要好得多。反之,数组中如果分布类似{0,1,2,2000,2001,......,999998,999999}这种极端不均匀的数据,用插值查找未必是很合适的选择。

斐波那契查找

利用黄金分割原理进行查找:
斐波那契数列 F={0,1,1,2,3,5,8,13,21,34...}

  1. /* 斐波那契查找 */
  2. int Fibonacci_Search(int *a, int n, int key)
  3. {
  4. int low, high, mid, i, k;
  5. /*定义最低下标为记录首位 */
  6. low = 1;
  7. /*定义最高下标为记录末位 */
  8. high = n;
  9. k = 0;
  10. /* 计算n位于斐波那契数列的位置 */
  11. while (n > F[k] - 1)
  12. k++;
  13. /* 将不满的数值补全 */
  14. for (i = n; i < F[k] - 1; i++)
  15. a[i] = a[n];
  16. while (low <= high)
  17. {
  18. /* 计算当前分隔的下标 */
  19. mid = low + F[k - 1] - 1;
  20. /* 若查找记录小于当前分隔记录 */
  21. if (key < a[mid])
  22. {
  23. /* 最高下标调整到分隔下标mid-1处 */
  24. high = mid - 1;
  25. /* 斐波那契数列下标减一位 */
  26. k = k - 1;
  27. }
  28. /* 若查找记录大于当前分隔记录 */
  29. else if (key > a[mid])
  30. {
  31. /* 最低下标调整到分隔下标mid+1处 */
  32. low = mid + 1;
  33. /* 斐波那契数列下标减两位 */
  34. k = k - 2;
  35. }
  36. else
  37. {
  38. if (mid <= n)
  39. /* 若相等则说明mid即为查找到的位置 */
  40. return mid;
  41. else
  42. /* 若mid>n说明是补全数值,返回n */
  43. return n;
  44. }
  45. }
  46. return 0;
  47. }

斐波那契查找算法的核心在于:
1)当key=a[mid]时,查找就成功;
2)当key<a[mid]时,新范围是第low个到第mid-1个,此时范围个数为F[k-1]-1个;
3)当key>a[mid]时,新范围是第m+1个到第high个,此时范围个数为F[k-2]-1个。

斐波那契查找算法

就是说,如果要查找的记录在右侧,则左侧的数据都不用再判断了,不断反复进行下去,对处于当中的大部分数据,其工作效率要高一些。所以尽管斐波那契查找的时间复杂也为O(logn),但就平均性能来说,斐波那契查找要优于折半查找。可惜如果是最坏情况,比如这里key=1,那么始终都处于左侧长半区在查找,则查找效率要低于折半查找。

折半查找是进行加法与除法运算(mid=(low+high)/2),插值查找进行复杂的四则运算(mid=low+(high-low)*(key-a[low])/(a[high]-a[low])),而斐波那契查找只是最简单加减法运算(mid=low+F[k-1]-1),在海量数据的查找过程中,这种细微的差别可能会影响最终的查找效率。

线性索引查找

数据结构的最终目的是提高数据的处理速度,索引是为了加快查找速度而设计的一种数据结构。索引就是把一个关键字与它对应的记录相关联的过程,一个索引由若干个索引项构成,每个索引项至少应包含关键字和其对应的记录在存储器中的位置等信息。索引技术是组织大型数据库以及磁盘文件的一种重要技术。

索引按照结构可以分为线性索引树形索引多级索引。所谓线性索引就是将索引项集合组织为线性结构,也称为索引表。

稠密索引

稠密索引是指在线性索引中,将数据集中的每个记录对应一个索引项。,索引项一定是按照关键码有序的排列。索引项有序也就意味着,要查找关键字时,可以用到折半、插值、斐波那契等有序查找算法,大大提高了效率。

倒排索引

倒排索引源于实际应用中需要根据属性(或字段、次关键码)的值来查找记录。这种索引表中的每一项都包括一个属性值和具有该属性值的各记录的地址。由于不是由记录来确定属性值,而是由属性值来确定记录的位置,因而称为倒排索引。

倒排索引的优点显然就是查找记录非常快,基本等于生成索引表后,查找时都不用去读取记录,就可以得到结果。但它的缺点是这个记录号不定长,维护比较困难,插入和删除操作都需要作相应的处理。

分块索引

稠密索引因为索引项与数据集的记录个数相同,所以空间代价很大。为了减少索引项的个数,可以对数据集进行分块,使其分块有序,然后再对每一块建立一个索引项,从而减少索引项的个数。

分块有序,是把数据集的记录分成了若干块,并且这些块需要满足两个条件:

如图所示,分块索引的索引项结构分三个数据项:

分块索引

分块索引表中查找,需要分两步进行:
- 1.在分块索引表中查找要查关键字所在的块。由于分块索引表是块间有序的,因此很容易利用折半、插值等算法得到结果。
- 2.根据块首指针找到相应的块,并在块中顺序查找关键码。因为块中可以是无序的,因此只能顺序查找。

分块索引的平均查找长度
设n个记录的数据集被平均分成m块,每个块中有t条记录,显然n=m×t,或者说m=n/t。再假设Lb为查找索引表的平均查找长度,因最好与最差的等概率原则,所以Lb的平均长度为(m+1)/2。Lw为块中查找记录的平均查找长度,同理可知它的平均查找长度为(t+1)/2。

这样分块索引查找的平均查找长度为:


平均长度不仅仅取决于数据集的总记录数n,还和每一个块的记录个数t相关。最佳的情况就是分的块数m与块中的记录数t相同,此时意味着n=m×t=t2,即ASLw=1/2·(n/t+t)+1=t+1=sqrt(n)+1。

分块索引在兼顾了对细分块不需要有序的情况下,大大增加了整体查找的速度,所以普遍被用于数据库表查找等技术的应用当中。

二叉排序树

二叉排序树(Binary Sort Tree),又称为二叉查找树。它或者是一棵空树,或者是具有下列性质的二叉树。

构造一棵二叉排序树的目的,并不是为了排序,而是为了提高查找和插入删除关键字的速度。在一个有序数据集上的查找,速度总是要快于无序的数据集的,而二叉排序树这种非线性的结构,也有利于插入和删除的实现。

二叉树结构:

  1. /* 二叉树的二叉链表结点结构定义 */
  2. /* 结点结构 */
  3. typedef struct BiTNode
  4. {
  5. /* 结点数据 */
  6. int data;
  7. /* 左右孩子指针 */
  8. struct BiTNode *lchild, *rchild;
  9. } BiTNode, *BiTree;

二叉树查找实现:

  1. /* 递归查找二叉排序树T中是否存在key, 指针f指向T的双亲,其初始调用值为NULL */
  2. /* 若查找成功,则指针p指向该数据元素结点,并返回TRUE */
  3. /* 否则指针p指向查找路径上访问的最后一个结点并返回FALSE */
  4. Status SearchBST(BiTree T, int key, BiTree f, BiTree *p)
  5. {
  6. /* 查找不成功 */
  7. if (!T)
  8. {
  9. *p = f;
  10. return FALSE;
  11. }
  12. /* 查找成功 */
  13. else if (key == T->data)
  14. {
  15. *p = T;
  16. return TRUE;
  17. }
  18. else if (key < T->data)
  19. /* 在左子树继续查找 */
  20. return SearchBST(T->lchild, key, T, p);
  21. else
  22. /* 在右子树继续查找 */
  23. return SearchBST(T->rchild, key, T, p);
  24. }

二叉排序树插入操作

  1. /* 当二叉排序树T中不存在关键字等于key的数据元素时,插入key并返回TRUE,否则返回FALSE */
  2. Status InsertBST(BiTree *T, int key)
  3. {
  4. BiTree p, s;
  5. /* 查找不成功 */
  6. if (!SearchBST(*T, key, NULL, &p))
  7. {
  8. s = (BiTree)malloc(sizeof(BiTNode));
  9. s->data = key;
  10. s->lchild = s->rchild = NULL;
  11. if (!p)
  12. /* 插入s为新的根结点 */
  13. *T = s;
  14. else if (key < p->data)
  15. /* 插入s为左孩子 */
  16. p->lchild = s;
  17. else
  18. /* 插入s为右孩子 */
  19. p->rchild = s;
  20. return TRUE;
  21. }
  22. else
  23. /* 树中已有关键字相同的结点,不再插入 */
  24. return FALSE;
  25. }
  26. int main()
  27. {
  28. int i;
  29. int a[10] = { 62, 88, 58, 47, 35, 73, 51, 99, 37, 93 };
  30. BiTree T = NULL;
  31. for (i = 0; i < 10; i++)
  32. {
  33. InsertBST(&T, a[i]);
  34. }
  35. return 0;
  36. }

二叉排序树删除操作
找到需要删除的结点p的直接前驱(或直接后继)s,用s来替换结点p,然后再删除此结点s

  1. * 若二叉排序树T中存在关键字等于key的数据元素时,则删除该数据元素结点,并返回TRUE;否则返回FALSE */
  2. Status DeleteBST(BiTree *T, int key)
  3. {
  4. /* 不存在关键字等于key的数据元素 */
  5. if (!*T)
  6. return FALSE;
  7. else
  8. {
  9. /* 找到关键字等于key的数据元素 */
  10. if (key == (*T)->data)
  11. return Delete(T);
  12. else if (key < (*T)->data)
  13. return DeleteBST(&(*T)->lchild, key);
  14. else
  15. return DeleteBST(&(*T)->rchild, key);
  16. }
  17. }
  18. /* 从二叉排序树中删除结点p,并重接它的左或右子树。 */
  19. Status Delete(BiTree *p)
  20. {
  21. BiTree q, s;
  22. /* 右子树空则只需重接它的左子树 */
  23. if ((*p)->rchild == NULL)
  24. {
  25. q = *p;
  26. *p = (*p)->lchild;
  27. free(q);
  28. }
  29. /* 只需重接它的右子树 */
  30. else if ((*p)->lchild == NULL)
  31. {
  32. q = *p;
  33. *p = (*p)->rchild;
  34. free(q);
  35. }
  36. /* 左右子树均不空 */
  37. else
  38. {
  39. q = *p; s = (*p)->lchild;
  40. /* 转左,然后向右到尽头(找待删结点的前驱) */
  41. while (s->rchild)
  42. {
  43. q = s; s = s->rchild;
  44. }
  45. /* s指向被删结点的直接前驱 */
  46. (*p)->data = s->data;
  47. if (q != *p)
  48. /* 重接q的右子树 */
  49. q->rchild = s->lchild;
  50. else
  51. /* 重接q的左子树 */
  52. q->lchild = s->lchild;
  53. free(s);
  54. }
  55. return TRUE;
  56. }

平衡二叉树

平衡二叉树(Self-Balancing Binary SearchTree或Height-Balanced Binary Search Tree),是一种二叉排序树,其中每一个节点的左子树和右子树的高度差至多等于1。
平衡因子BF(Balance Factor): 二叉树上结点的左子树深度减去右子树深度的值,平衡二叉树上所有结点的平衡因子只可能是-1、0和1。
最小不平衡子树: 距离插入结点最近的,且平衡因子的绝对值大于1的结点为根的子树

原理

平衡二叉树构建的基本思想就是在构建二叉排序树的过程中,每当插入一个结点时,先检查是否因插入而破坏了树的平衡性,若是,则找出最小不平衡子树。在保持二叉排序树特性的前提下,调整最小不平衡子树中各结点之间的链接关系,进行相应的旋转,使之成为新的平衡子树。

因为BF值为正,因此我们将整个树进行右旋(顺时针旋转),此时结点2成了根结点,3成了2的右孩子,这样三个结点的BF值均为0,非常的平衡
然后我们再增加结点4,平衡因子没有超出限定范围(-1,0,1),如图3。增加结点5时,结点3的BF值为-2,说明要旋转了。由于BF是负值,所以我们对这棵最小平衡子树进行左旋(逆时针旋转)
平衡二叉树构建
平衡二叉树构建
增加结点9,此时结点7的BF变成了-2,理论上我们只需要旋转最小不平衡子树7、9、10即可,但是如果左旋转后,结点9就成了10的右孩子,这是不符合二叉排序树的特性的,此时不能简单的左旋,如图11所示。
平衡二叉树构建
仔细观察图11,发现根本原因在于结点7的BF是-2,而结点10的BF是1,也就是说,它们俩一正一负,符号并不统一,而前面的几次旋转,无论左还是右旋,最小不平衡子树的根结点与它的子结点符号都是相同的。故应先把符号转到统一。
平衡二叉树构建

算法

二叉排序树的结点结构

  1. * 二叉树的二叉链表结点结构定义结点结构 */
  2. typedef struct BiTNode
  3. {
  4. /* 结点数据 */
  5. int data;
  6. /* 结点的平衡因子 */
  7. int bf;
  8. /* 左右孩子指针 */
  9. struct BiTNode *lchild, *rchild;
  10. } BiTNode, *BiTree;

右旋操作

  1. /* 对以p为根的二叉排序树作右旋处理,
  2. 处理之后p指向新的树根结点,即旋转处理之前的左子树的根结点 */
  3. void R_Rotate(BiTree *P)
  4. {
  5. BiTree L;
  6. /* L指向P的左子树根结点 */
  7. L = (*P)->lchild;
  8. /* L的右子树挂接为P的左子树 */
  9. (*P)->lchild = L->rchild;
  10. L->rchild = (*P);
  11. /* P指向新的根结点 */
  12. *P = L;
  13. }

此函数代码的意思是说,当传入一个二叉排序树P,将它的左孩子结点定义为L,将L的右子树变成P的左子树,再将P改成L的右子树,最后将L替换P成为根结点。这样就完成了一次右旋操作,如图8-7-9所示。图中三角形代表子树,N代表新增结点。
右旋操作

左旋操作

  1. /* 对以P为根的二叉排序树作左旋处理,处理之后P指向新的树根结点
  2. 即旋转处理之前的右子树的根结点0 */
  3. void L_Rotate(BiTree *P)
  4. {
  5. BiTree R;
  6. /* R指向P的右子树根结点 */
  7. R = (*P)->rchild;
  8. /* R的左子树挂接为P的右子树 */
  9. (*P)->rchild = R->lchild;
  10. R->lchild = (*P);
  11. /* P指向新的根结点 */
  12. *P = R;
  13. }

左平衡旋转处理的函数代码

  1. #define LH +1 /* 左高 */
  2. #define EH 0 /* 等高 */
  3. #define RH -1 /* 右高 */
  4. /* 对以指针T所指结点为根的二叉树作左平衡旋转
  5. 处理 */
  6. /* 本算法结束时,指针T指向新的根结点 */
  7. void LeftBalance(BiTree *T)
  8. {
  9. BiTree L,Lr;
  10. /* L指向T的左子树根结点 */
  11. L = (*T)->lchild;
  12. switch (L->bf)
  13. {
  14. /* 检查T的左子树的平衡度,并作相应平衡处理 */
  15. /* 新结点插入在T的左孩子的左子树上,要作单右旋处理 */
  16. case LH:
  17. (*T)->bf = L->bf = EH;
  18. R_Rotate(T);
  19. break;
  20. /* 新结点插入在T的左孩子的右子树上,要作双旋处理 */
  21. case RH:
  22. /* Lr指向T的左孩子的右子树根 */
  23. Lr = L->rchild;
  24. /* 修改T及其左孩子的平衡因子 */
  25. switch (Lr->bf)
  26. {
  27. case LH: (*T)->bf = RH;
  28. L->bf = EH;
  29. break;
  30. case EH: (*T)->bf = L->bf = EH;
  31. break;
  32. case RH: (*T)->bf = EH;
  33. L->bf = LH;
  34. break;
  35. }
  36. Lr->bf = EH;
  37. /* 对T的左子树作左旋平衡处理 */
  38. L_Rotate(&(*T)->lchild);
  39. /* 对T作右旋平衡处理 */
  40. R_Rotate(T);
  41. }
  42. }

右平衡旋转处理的函数代码非常类似。

主函数

  1. /* 若在平衡的二叉排序树T中不存在和e有相同关键
  2. 字的结点,则插入一个 */
  3. /* 数据元素为e的新结点并返回1,否则返回0。若
  4. 因插入而使二叉排序树 */
  5. /* 失去平衡,则作平衡旋转处理,布尔变量taller
  6. 反映T长高与否。 */
  7. Status InsertAVL(BiTree *T, int e, Status *taller)
  8. {
  9. if (!*T)
  10. {
  11. /* 插入新结点,树“长高”,置taller为TRUE */
  12. *T = (BiTree)malloc(sizeof(BiTNode));
  13. (*T)->data = e;
  14. (*T)->lchild = (*T)->rchild = NULL;
  15. (*T)->bf = EH;
  16. *taller = TRUE;
  17. }
  18. else
  19. {
  20. if (e == (*T)->data)
  21. {
  22. /* 树中已存在和e有相同关键字的结点则不再插入 */
  23. *taller = FALSE;
  24. return FALSE;
  25. }
  26. if (e < (*T)->data)
  27. {
  28. /* 应继续在T的左子树中进行搜索 */
  29. /* 未插入 */
  30. if (!InsertAVL(&(*T)->lchild, e, taller))
  31. return FALSE;
  32. /* 已插入到T的左子树中且左子树“长高” */
  33. if (*taller)
  34. {
  35. /* 检查T的平衡度 */
  36. switch ((*T)->bf)
  37. {
  38. /* 原本左子树比右子树高,需要作左平衡处理 */
  39. case LH:
  40. LeftBalance(T);
  41. *taller = FALSE;
  42. break;
  43. /* 原本左右子树等高,现因左子树增高而树增高 */
  44. case EH:
  45. (*T)->bf = LH;
  46. *taller = TRUE;
  47. break;
  48. /* 原本右子树比左子树高,现左右子树等高 */
  49. case RH:
  50. (*T)->bf = EH;
  51. *taller = FALSE;
  52. break;
  53. }
  54. }
  55. }
  56. else
  57. {
  58. /* 应继续在T的右子树中进行搜索 */
  59. /* 未插入 */
  60. if (!InsertAVL(&(*T)->rchild, e, taller))
  61. return FALSE;
  62. /* 已插入到T的右子树且右子树“长高” */
  63. if (*taller)
  64. {
  65. /* 检查T的平衡度 */
  66. switch ((*T)->bf)
  67. {
  68. /* 原本左子树比右子树高,现左、右子树等高 */
  69. case LH:
  70. (*T)->bf = EH;
  71. *taller = FALSE;
  72. break;
  73. /* 原本左右子树等高,现因右子树增高而树增高 */
  74. case EH:
  75. (*T)->bf = RH;
  76. *taller = TRUE;
  77. break;
  78. /* 原本右子树比左子树高,需要作右平衡处理 */
  79. case RH:
  80. RightBalance(T);
  81. *taller = FALSE;
  82. break;
  83. }
  84. }
  85. }
  86. }
  87. return TRUE;
  88. }

查找时间复杂度就为O(logn),而插入和删除也为O(logn)。这显然是比较理想的一种动态查找表算法。

多路查找树

多路查找树(muitl-way search tree),其每一个结点的孩子数可以多于两个,且每一个结点处可以存储多个元素。由于它是查找树,所有元素之间存在某种特定的排序关系。

2-3树

2-3树:其中的每一个结点都具有两个孩子(我们称它为2结点)或三个孩子(我们称它为3结点)。
2-3树
2-3树的插入实现
对于2-3树的插入来说,与二叉排序树相同,插入操作一定是发生在叶子结点上。可与二叉排序树不同的是,2-3树插入一个元素的过程有可能会对该树的其余结构产生连锁反应。

2-3树的插入
2-3树的插入
2-3树的插入
2-3树的插入

2-3树的删除实现
2-3树的删除也分为三种情况。与插入相反

2-3树的删除
2-3树的删除
2-3树的删除
2-3树的删除
2-3树的删除
2-3树的删除
2-3树的删除
2-3树的删除

2-3-4树

2-3-4树: 它其实就是2-3树的概念扩展,包括了4结点的使用。一个4结点包含小中大三个元素和四个孩子(或没有孩子),一个4结点要么没有孩子,要么具有4个孩子。如果某个4结点有孩子的话,左子树包含小于最小元素的元素;第二子树包含大于最小元素,小于第二元素的元素;第三子树包含大于第二元素,小于最大元素的元素;右子树包含大于最大元素的元素。

插入过程:

插入过程

删除过程:

删除过程

B树

B树(B-tree)是一种平衡的多路查找树,2-3树和2-3-4树都是B树的特例。结点最大的孩子数目称为B树的(order),因此,2-3树是3阶B树,2-3-4树是4阶B树。

一个m阶的B树具有如下属性:


B树

一个典型的B树应用中,要处理的硬盘数据量很大,因此无法一次全部装入内存。因此我们会对B树进行调整,使得B树的阶数(或结点的元素)与硬盘存储的页面大小相匹配。比如说一棵B树的阶为1001(即1个结点包含1000个关键字),高度为2,它可以储存超过10亿个关键字,我们只要让根结点持久地保留在内存中,那么在这棵树上,寻找某一个关键字至多需要两次硬盘的读取即可。
通过这种方式,在有限内存的情况下,每一次磁盘的访问我们都可以获得最大数量的数据。由于B树每结点可以具有比二叉树多得多的元素,所以与二叉树的操作不同,它们减少了必须访问结点和数据块的数量,从而提高了性能。可以说,B树的数据结构就是为内外存的数据交互准备的。

B+树

这样的数据结构最大的好处就在于,如果是要随机查找,就从根结点出发,与B树的查找方式相同,只不过即使在分支结点找到了待查找的关键字,它也只是用来索引的,不能提供实际记录的访问,还是需要到达包含此关键字的终端结点。

哈希表查找

散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使得每个关键字key对应一个存储位置f(key)。查找时,根据这个确定的对应关系找到给定值key的映射f(key),若查找集合中存在这个记录,则必定在f(key)的位置上。
这种对应关系f称为散列函数,又称为哈希(Hash)函数。按这个思想,采用散列技术将记录存储在一块连续的存储空间中,这块连续存储空间称为散列表或哈希表(Hash table)。关键字对应的记录存储位置称为散列地址。

散列技术既是一种存储方法,也是一种查找方法。然而它与线性表、树、图等结构不同的是,前面几种结构,数据元素之间都存在某种逻辑关系,可以用连线图示表示出来,而散列技术的记录之间不存在什么逻辑关系,它只与关键字有关联。因此,散列主要是面向查找的存储结构。

散列函数的构造方法

原则:
计算简单
散列地址分布均匀

直接定址法

取关键字的某个线性函数值为散列地址:

f(key)=a×key+b(a、b为常数)

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

折叠法

折叠法是将关键字从左到右分割成位数相等的几部分(注意最后一部分位数不够时可以短些),然后将这几部分叠加求和,并按散列表表长,取后几位作为散列地址。
比如关键字9876543210,散列表表长为三位,将它分为四组,987|654|321|0,然后将它们叠加求和987+654+321+0=1962,再求后3位得到散列地址为962。
有时可能这还不能够保证分布均匀,可以从一端向另一端来回折叠后对齐相加。比如我们将987和321反转,再与654和0相加,变成789+654+123+0=1566,此时散列地址为566。
折叠法事先不需要知道关键字的分布,适合关键字位数较多的情况。

数字分析法

比如要存储某家公司员工登记表,如果用手机号作为关键字,那么极有可能前7位都是相同的。而选择后面的四位成为散列地址就是不错的选择。如果这样的抽取工作还是容易出现冲突问题,还可以对抽取出来的数字再进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环位移、甚至前两数与后两数叠加(如1234改成12+34=46)等方法。总的目的就是为了提供一个散列函数,能够合理地将关键字分配到散列表的各位置。
这里提到了一个关键词——抽取。抽取方法是使用关键字的一部分来计算散列存储位置的方法,这在散列函数中是常常用到的手段。
数字分析法通常适合处理关键字位数比较大的情况,如果事先知道关键字的分布且关键字的若干位分布较均匀,就可以考虑用这个方法。

除留余数法

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

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

mod是取模。事实上,这方法不仅可以对关键字直接取模,也可在折叠、平方取中后再取模。

本方法的关键就在于选择合适的p,p如果选得不好,就可能会容易产生同义词。
根据经验,若散列表表长为m,通常p为小于或等于表长(最好接近m)的最小质数或不包含小于20质因子的合数。

平方取中法

这个方法计算很简单,假设关键字是1234,那么它的平方就是1522756,再抽取中间的3位就是227,用做散列地址。再比如关键字是4321,那么它的平方就是18671041,抽取中间的3位就可以是671,也可以是710,用做散列地址。平方取中法比较适合于不知道关键字的分布,而位数又不是很大的情况。

随机数法

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

处理散列冲突的方法

在使用散列函数后发现两个关键字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的位置
开放定址法

这种解决冲突的开放定址法称为线性探测法
类似的,还有其他方法:
二次探测法

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

随机探测法

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

这里的随机其实是伪随机数。伪随机数是说,如果设置随机种子相同,则不断调用随机函数可以生成不会重复的数列,在查找时,用同样的随机种子,它每次得到的数列是相同的,相同的di当然可以得到相同的散列地址。

链地址法

将所有关键字为同义词的记录存储在一个单链表中,称这种表为同义词子表,在散列表中只存储所有同义词子表的头指针
。对于关键字集合{12,67,56,16,25,37,22,29,15,47,48,34},用前面同样的12为除数,进行除留余数法,可得到如图结构,此时,已经不存在什么冲突换址的问题,无论有多少个冲突,都只是在当前位置给单链表增加结点的问题。
链地址法

链地址法对于可能会造成很多冲突的散列函数来说,提供了绝不会出现找不到地址的保障。当然,这也就带来了查找时需要遍历单链表的性能损耗。

再散列函数法

事先准备多个散列函数:

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

公共溢出法

为所有冲突的关键字建立了一个公共的溢出区来存放
公共溢出法

在查找时,对给定值通过散列函数计算出散列地址后,先与基本表的相应位置进行比对,如果相等,则查找成功;如果不相等,则到溢出表去进行顺序查找。如果相对于基本表而言,有冲突的数据很少的情况下,公共溢出区的结构对查找性能来说还是非常高的。

散列表查找实现

定义散列表的结构:

  1. #define SUCCESS 1
  2. #define UNSUCCESS 0
  3. /* 定义散列表长为数组的长度 */
  4. #define HASHSIZE 12
  5. #define NULLKEY -32768
  6. typedef struct
  7. {
  8. /* 数据元素存储基址,动态分配数组 */
  9. int *elem;
  10. /* 当前数据元素个数 */
  11. int count;
  12. } HashTable;
  13. /* 散列表表长,全局变量 */
  14. int m = 0;
  1. /* 初始化散列表 */
  2. Status InitHashTable(HashTable *H)
  3. {
  4. int i;
  5. m = HASHSIZE;
  6. H->count = m;
  7. H->elem = (int *)malloc(m * sizeof(int));
  8. for (i = 0; i < m; i++)
  9. H->elem[i] = NULLKEY;
  10. return OK;
  11. }

定义散列函数

  1. /* 散列函数 */
  2. int Hash(int key)
  3. {
  4. /* 除留余数法 */
  5. return key % m;
  6. }
  1. /* 插入关键字进散列表 */
  2. void InsertHash(HashTable *H, int key)
  3. {
  4. /* 求散列地址 */
  5. int addr = Hash(key);
  6. /* 如果不为空,则冲突 */
  7. while (H->elem[addr] != NULLKEY)
  8. /* 开放定址法的线性探测 */
  9. addr = (addr + 1) % m;
  10. /* 直到有空位后插入关键字 */
  11. H->elem[addr] = key;
  12. }
  1. /* 散列表查找关键字 */
  2. Status SearchHash(HashTable H, int key, int *addr)
  3. {
  4. /* 求散列地址 */
  5. *addr = Hash(key);
  6. /* 如果不为空,则冲突 */
  7. while (H.elem[*addr] != key)
  8. {
  9. /* 开放定址法的线性探测 */
  10. *addr = (*addr + 1) % m;
  11. if (H.elem[*addr] == NULLKEY || *addr == Hash(key))
  12. {
  13. /* 如果循环回到原点 */
  14. /* 则说明关键字不存在 */
  15. return UNSUCCESS;
  16. }
  17. }
  18. return SUCCESS;
  19. }

散列表查找性能分析

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注