【数据结构7-1-查找-线性-二分法-二叉树-哈希表】

目录

  • 1 查找基本概念
  • 2 线性表的查找
    • 2.1 顺序查找
    • 2.2 二分法查找
    • 2.3 分块查找
  • 3 树表的查询
    • 3.1 二叉排序树
      • 3.1.1 定义
      • 3.1.2 二叉树的建立、遍历、查找、增加、删除:
      • 3.1.3 代码实现:
    • 3.2 平衡二叉树
      • 3.2.1 平横因子
      • 3.2.2 不平横树的调整-左旋
      • 3.2.3 不平横树的调整-右旋
      • 3.2.4 当插入节点出现失衡因子如何旋转
      • 3.2.4 某位UP主的详细视频讲解
    • 3.3 B-树
      • 3.3.1 B-树的定义
      • 3.3.2 题目练习
      • 3.3.3 B-树的查找、插入、删除
    • 3.4 B+树
  • 4 散列表查找(哈希表查找)
    • 4.1 基本术语和概念
    • 4.2 散列函数的构造
    • 4.3 哈希表的创建,插入,查找
      • 4.3.1 程序实现
      • 4.3.2 程序结果:

常用的查找及代码程序

1 查找基本概念

  查找是在数据集合中寻找特定元素或满足特定条件的元素的过程。它是一种常见的数据操作。

2 线性表的查找

2.1 顺序查找

  顺序查找(Sequential Search)的查找过程为:从表的一端开始,依次将记录的关键字和给定值进行比较,若某个记录的关键字和给定值相等,则查找成功;反之,若扫描整个表后,仍未找到关键字和给定值相等的记录,则查找失败。
  顺序查找方法既适用于线性表的顺序存储结构,又适用千线性表的链式存储结构。下面只介绍以顺序表作为存储结构时实现的顺序查找算法。顺序查找比较简单,但是费时;效率低;
  简单看一下下面两个算法的区别:arr【0】不用于存储数据;

// 顺序查找函数
int search(int arr[], int size, int key) {// 从数组的最后一个元素开始查找for (int i = size - 1; i >= 1; --i) {if (arr[i] == key) {return i;}}// 未找到元素return 0;
}

改进后:不用每次都进行循环是否结束的查找,也就是i>=1?

// 顺序查找函数
int search(int arr[], int size, int key) {// 设置监视哨arr[0] = key;// 从数组的最后一个元素开始查找for (int i = size; arr[i]!=key; --i);// 未找到元素return i;
}

2.2 二分法查找

  它是一种效率较高的查找方法。但是,折半查找要求线性表必须采用顺序存储结构, 而且表中元素按关键字有序排列;
  例如查找30的数据:( 5, 16, 20, 27, 3 0, 36, 44, 55, 60, 67, 71)
  思考如果low=mid而不是low=mid+1后结果是什么?
  需要注意的是,循环执行的条件是low< =high,而不是low<high,因为low=high时,查找区间还有最后一个结点, 还要进一步比较 。

// 二分法查找函数
int main()
{int high, mid, low, t;int str[] = {5, 16, 20, 27, 30, 36, 44, 55, 60, 67, 71};high = 10;low = 0;mid = (high + low) / 2;t = 71;while (low <= high){mid = (high + low) / 2;if (str[mid] >= t){if (str[mid] == t){printf("YES\n");return 0;}else{high = mid;}}else{low = mid + 1; // 思考如果low=mid后结果是什么?如果// t=71,会在后面陷入死循环:high=10,low=9,mid=9;一直循环}}return 0;
}

  折半查找的优点是:比较次数少,查找效率高。其缺点是:对表结构要求高,只能用于顺序存储的有序表。查找前需要排序,而排序本身是一种费时的运算。同时为了保持顺序表的有序性,对有序表进行插入和删除时,平均比较和移动表中一半元素,这也是一种费时的运算。因此,折半查找不适用于数据元素经常变动的线性表。

2.3 分块查找

  分块查找的优点是:在表中插入和删除数据元素时,只要找到该元素对应的块,就可以在该块内进行插入和删除运算。 由于块内是无序的,故插入和删除比较容易,无需进行大量移动。 如果线性表既要快速查找又经常动态变化,则可采用分块查找。
  其缺点是:要增加一个索引表的存
储空间并对初始索引表进行排序运算。
  其基本的思想和这里面差不多;如下图:

3 树表的查询

  前面介绍的3 种查找方法都是用线性表作为查找表的组织形式,其中折半查找效率较高。但由千折半查找要求表中记录按关键字有序排列,且不能用链表做存储结构,因此,当表的插入或删除操作频繁时,为维护表的有序性,需要移动表中很多记录。这种由移动记录引起的额外时间开销,就会抵消折半查找的优点。 所以,线性表的查找更适用千静态查找表,若要对动态查找表进行高效率的查找,可采用几种特殊的二叉树作为查找表的组织形式,在此将它们统称为树表。 本节将介绍在这些树表上进行查找和修改操作的方法

3.1 二叉排序树

3.1.1 定义

  二叉排序树或者是一棵空树,或者是具有下列性质的二叉树:二叉排序树,又称二叉查找树,它或者是一棵空树,或者是具有以下性质的二叉树:

  1. 若左子树不空,则左子树上所有节点的值均小于它的根节点的值;
  2. 若右子树不空,则右子树上所有节点的值均大于它的根节点的值;
  3. 左、右子树也分别为二叉排序树。
    如下图所示:

    若中序遍历图7.5(a), 则可得到一个按数值 大小排序的递增序列:
                  3, 12, 24, 37, 45, 53, 61, 78, 90, 100

3.1.2 二叉树的建立、遍历、查找、增加、删除:

  若中序遍历图7.5(a), 则可得到一个按数值 大小排序的递增序列:具体详情可以参考我下面的这篇内容:主要是包括二叉排序树(建立、遍历、查找、增加、删除)并给出了详细的C运行代码;链接:

3.1.3 代码实现:

  二叉排序树(建立、遍历、查找、增加、删除)并给出了详细的C运行代码;链接

3.2 平衡二叉树

  二叉排序树查找算法的性能取决于二叉树的结构,而 二叉排序树的形状则取决于其数据集。如果数据呈有序排列,则二叉排序树是线性的,查找的时间复杂度为O(n); 反之,如果二叉排序树的结构合理,则查找速度较快,查找的时间复杂度为 O(lo2n)。事实上,树的高度越小,查找 g速度越快。因此,希望二叉树的高度尽可能小。本节将讨论一种特殊类型的二叉排序树,称为平衡二叉树 (Balance d Binary Tree或Height-Balanced·Tree), 因由前苏联数学家Adelson-Velskii和Land i s提出,所以又称AVL树。

平衡二叉树或者是空树,或者是具有如下特征的二叉排序树:

  1. (1 )左子树和右子树的深度之差绝对值不超过1;
  2. (2)左子树和右子树也是平衡二叉树

3.2.1 平横因子

  平衡因子=左子树高度-右子树高度:如下图所示:

3.2.2 不平横树的调整-左旋

  在旋转过程中,冲突的是9的左孩6,这里记一句话左旋--冲突左孩变右孩;如下图左旋过程

而且旋转过后,中序遍历的话,两者是等价的,但是树的高度却变低了;如下图:

3.2.3 不平横树的调整-右旋

  在旋转过程中,冲突的是14的左孩9,这里记一句话右旋--冲突右孩变左孩;如下图左旋过程

而且旋转过后,中序遍历的话,两者是等价的,但是树的高度却变低了;如下图:

3.2.4 当插入节点出现失衡因子如何旋转

  调整方法是:找到离插入结点最近且平衡因子绝对值超过1的祖先结点, 以该结点为根的子树称为最小不平衡子树, 可将重新平衡的范围局限于这棵子树,如下图所示,一共四种情况:
  巧记一下:LL是右旋,RR是左旋,也就是纯的则相反旋转:L(left),R(right)
  巧记一下:LR是右旋,先左后右,RL,先右后左,也就是混的按照字母:L(left),R(right)
在这里插入图片描述

3.2.4 某位UP主的详细视频讲解

关于平衡二叉树的详细信息,这个视频讲的异常清晰:链接

3.3 B-树

  前面介绍的查找方法均适用千存储在计算机内存中较小的文件,统称为内查找法。若文件很大且存放于外存进行查找时,这些查找方法就不适用了。内查找法都以结点为单位进行查找,这样需要反复地进行内、外存的交换,是很费时的。1970年,R.Bayer和£.Mccreight提出了一种适用于外查找的平衡多叉树-B-树,磁盘管理系统中的目录管理,以及数据库系统中的索引组织多数都采用B-树这种数据结构。
  B树就是一个有序的多路查询树

3.3.1 B-树的定义

  • 对于m叉树,每个节点最多有m个孩子,其中最多有m-1个关键字;(人5个手指最多4条缝)
  • 每个节点的内容如下:例如对于四叉树,3个关键字,即其存储结构:
n:多少关键字P0指针k1关键字P1指针k2关键字P2指针k3关键字P3指针
  • 每个节点的内容如下:例如对于四叉树,3个关键字,即其存储结构:
  • 谨记m阶子树,最多有m-1个关键字,而对于每个节点最少要有[m/2]-1个关键字,其中[m/2]是向上取整;
  • 关键字就是把内容进行了分块,如同索引,例如:2--- 5,两个关键字就分量三个区域,0-2,2-5,5--三个范围,也就是对于四叉树,最多是3个关键字;

3.3.2 题目练习

  真题练习:

3.3.3 B-树的查找、插入、删除

  代码实现——C:链接

/** @Author: Xyh4ng* @Date: 2023-01-02 20:24:30* @LastEditors: Xyh4ng* @LastEditTime: 2023-01-05 20:17:06* @Description:* Copyright (c) 2023 by Xyh4ng 503177404@qq.com, All Rights Reserved.*/
#include <stdio.h>
#include <stdlib.h>#define M 3 // B树的阶
#define MIN_KEYNUM (M + 1) / 2 - 1typedef struct BTreeNode
{int keyNum;               // 结点中关键字的数量struct BTreeNode *parent; // 指向双亲结点struct Node               // 存放关键字以及其孩子节点指针,正常结点最多存放m个孩子,但在插入判断时会多存放一个{int key;struct BTreeNode *ptr;} node[M + 1]; // key的0号单元未使用
} BTreeNode, *BTree;typedef struct Result
{int tag;       // 查找成功的标志BTreeNode *pt; // 指向查找到的结点int i;         // 结点在关键字中的序号
} Result;int Search(BTree T, int K)
{int i = 0;for (int j = 1; j <= T->keyNum; j++){if (T->node[j].key <= K){i = j;}}return i;
}/* 在m阶B树T上查找关键字K,返回结果(pt,i,tag)。若查找成功,则特征值tag=1,指针pt所指结点中第i个关键字等于K;否则特征值tag=0,等于K的关键字应插入在指针Pt所指结点中第i和第i+1个关键字之间。 */
Result SearchBTree(BTree T, int K)
{BTree p = T, q = NULL; /*  初始化,p指向待查结点,q指向p的双亲  */int found = 0;int index = 0;Result r;while (p && !found){index = Search(p, K); // p->node[index].key ≤ K < p->node[index+1].keyif (index > 0 && p->node[index].key == K)found = 1;else{q = p;p = p->node[index].ptr;}}r.i = index;if (found) // 查找成功{r.tag = 1;r.pt = p;}else{r.tag = 0;r.pt = q;}return r;
}void Insert(BTree *q, int key, BTree ap, int i)
{for (int j = (*q)->keyNum; j > i; j--) // 空出(*q)->node[i+1]{(*q)->node[j + 1] = (*q)->node[j];}(*q)->node[i + 1].key = key;(*q)->node[i + 1].ptr = ap;(*q)->keyNum++;
}// 将结点q分裂成两个结点,mid之前的结点保留,mid之后结点移入新生结点ap
void Split(BTree *q, BTree *ap)
{int mid = (M + 1) / 2;*ap = (BTree)malloc(sizeof(BTreeNode));(*ap)->node[0].ptr = (*q)->node[mid].ptr;if ((*ap)->node[0].ptr){(*ap)->node[0].ptr->parent = *ap;}for (int i = mid + 1; i <= M; i++){(*ap)->node[i - mid] = (*q)->node[i];if ((*ap)->node[i - mid].ptr){(*ap)->node[i - mid].ptr->parent = *ap;}}(*ap)->keyNum = M - mid;(*ap)->parent = (*q)->parent;(*q)->keyNum = mid - 1;
}// 生成含信息(T,r,ap)的新的根结点&T,原T和ap为子树指针
void NewRoot(BTree *T, int key, BTree ap)
{BTree p;p = (BTree)malloc(sizeof(BTreeNode));p->node[0].ptr = *T; // 根结点孩子数最小为2,则将T作为左孩子,ap作为右孩子*T = p;if ((*T)->node[0].ptr){(*T)->node[0].ptr->parent = *T;}(*T)->parent = NULL;(*T)->keyNum = 1;(*T)->node[1].key = key;(*T)->node[1].ptr = ap;if ((*T)->node[1].ptr){(*T)->node[1].ptr->parent = *T;}
}/*  在m阶B树T上结点*q的key[i]与key[i+1]之间插入关键字K的指针r。若引起结点过大,则沿双亲链进行必要的结点分裂调整,使T仍是m阶B树。 */
void InseartBTree(BTree *T, int key, BTree q, int i)
{BTree ap = NULL;int finished = 0;int rx = key; // 需要插入的关键字的值int mid;while (q && !finished){Insert(&q, rx, ap, i);if (q->keyNum < M)finished = 1;else // 结点关键字数超出规定{int mid = (M + 1) / 2; // 结点的中间关键字序号rx = q->node[mid].key;Split(&q, &ap); // 将q->key[mid+1..M],q->ptr[mid..M]移入新结点*apq = q->parent;if (q)i = Search(q, rx);}}if (!finished){NewRoot(T, rx, ap);}
}void Delete(BTree *q, int index)
{for (int i = index; i <= (*q)->keyNum; i++){(*q)->node[index] = (*q)->node[index + 1];}(*q)->keyNum--;
}void LeftRotation(BTree *q, BTree *p, int i)
{// 将父亲结点转移至q结点的末尾(*q)->keyNum++;(*q)->node[(*q)->keyNum].key = (*p)->node[i + 1].key;// 将q结点的右兄弟的第一个关键字转移至父亲结点的分隔符位置BTree rightBroPtr = (*p)->node[i + 1].ptr;(*p)->node[i + 1].key = rightBroPtr->node[1].key;// 将右结点的关键字前移for (int j = 1; j < rightBroPtr->keyNum; j++){rightBroPtr->node[j] = rightBroPtr->node[j + 1];}rightBroPtr->keyNum--;
}void RightRotation(BTree *q, BTree *p, int i)
{// 将q结点向后移动空出第一个关键字的位置for (int j = (*q)->keyNum; j >= 1; j--){(*q)->node[j + 1] = (*q)->node[j];}// 将父亲结点移动至q结点的第一个关键字的位置(*q)->node[1].key = (*p)->node[i].key;(*q)->node[1].ptr = NULL;(*q)->keyNum++;// 将左兄弟结点的最后一个关键字移动至父亲结点的分隔符位置BTree leftBroPtr = (*p)->node[i - 1].ptr;(*p)->node[i].key = leftBroPtr->node[leftBroPtr->keyNum].key;leftBroPtr->keyNum--;
}void BalanceCheck(BTree *q, int key);void MergeNode(BTree *q, BTree *p, int i)
{BTree rightBroPtr = NULL, leftBroPtr = NULL;if (i + 1 <= (*p)->keyNum){rightBroPtr = (*p)->node[i + 1].ptr;}if (i - 1 >= 0){leftBroPtr = (*p)->node[i - 1].ptr;}if (rightBroPtr){// 将父亲结点的分隔符移动至q结点的最后(*q)->keyNum++;(*q)->node[(*q)->keyNum].key = (*p)->node[i + 1].key;// 将右兄弟结点都移动到q结点上(*q)->node[(*q)->keyNum].ptr = rightBroPtr->node[0].ptr;for (int j = 1; j <= rightBroPtr->keyNum; j++){(*q)->keyNum++;(*q)->node[(*q)->keyNum] = rightBroPtr->node[j];}// 将父亲结点的分隔符删除int key = (*p)->node[i + 1].key;for (int j = i + 1; j < (*p)->keyNum; j++){(*p)->node[j] = (*p)->node[j + 1];}(*p)->keyNum--;if (!(*p)->parent && !(*p)->keyNum){// 判断父亲结点是否为根结点,且关键字为空// 让q结点作为根结点(*q)->parent = NULL;(*p) = (*q);}BalanceCheck(p, key);}else if (leftBroPtr){// 将父亲结点的分隔符移动至左兄弟结点的最后leftBroPtr->keyNum++;leftBroPtr->node[leftBroPtr->keyNum].key = (*p)->node[i].key;// 将q结点都移动到左兄弟结点上leftBroPtr->node[leftBroPtr->keyNum].ptr = (*q)->node[0].ptr;for (int j = 1; j <= (*q)->keyNum; j++){leftBroPtr->keyNum++;leftBroPtr->node[leftBroPtr->keyNum] = (*q)->node[j];}// 将父亲结点的分隔符删除int key = (*p)->node[i].key;for (int j = i; j < (*p)->keyNum; j++){(*p)->node[j] = (*p)->node[j + 1];}(*p)->keyNum--;if (!(*p)->parent && !(*p)->keyNum){// 判断父亲结点是否为根结点,且关键字为空// 让q结点作为根结点(*q)->parent = NULL;(*p) = (*q);}BalanceCheck(p, key);}
}void BalanceCheck(BTree *q, int key)
{if ((*q)->keyNum < MIN_KEYNUM) // 该结点不满足最小关键字数目要求{BTree p = (*q)->parent;int i = Search(p, key);                                            // 找到q结点在父亲结点中的索引if (i + 1 <= p->keyNum && p->node[i + 1].ptr->keyNum > MIN_KEYNUM) // 看q结点的右兄弟是否存在多余结点{LeftRotation(q, &p, i);}else if (i - 1 >= 0 && p->node[i - 1].ptr->keyNum > MIN_KEYNUM) // 看q结点的左兄弟是否存在多余结点{RightRotation(q, &p, i);}else // q结点的左右兄弟都不存在多余结点{// 将q结点和其左右兄弟的其中一个以及父亲结点中的分隔符合并MergeNode(q, &p, i);}}
}void MergeBro(BTree *left, BTree *right)
{if (!(*left)->node[((*left)->keyNum)].ptr){// 如果左子树为叶子结点(*left)->node[(*left)->keyNum].ptr = (*right)->node[0].ptr;for (int j = 1; j <= (*right)->keyNum; j++){(*left)->keyNum++;(*left)->node[(*left)->keyNum] = (*right)->node[j];}}else{// 左子树不是叶子结点,则先将左子树最后一个子结点和右子树第一个子结点合并MergeBro(&(*left)->node[(*left)->keyNum].ptr, &(*right)->node[0].ptr);for (int j = 1; j <= (*right)->keyNum; j++){(*left)->keyNum++;(*left)->node[(*left)->keyNum] = (*right)->node[j];}}// 合并完对左子树关键字数目进行判断if ((*left)->keyNum >= M){int mid = (M + 1) / 2; // 结点的中间关键字序号int rx = (*left)->node[mid].key;BTree ap = NULL;Split(&(*left), &ap); // 将q->key[mid+1..M],q->ptr[mid..M]移入新结点*apBTree p = (*left)->parent;int i = Search(p, rx);Insert(&p, rx, ap, i);}
}void DeleteBTreeNode(BTree *T, int key)
{Result res = SearchBTree(*T, key);if (res.tag) // 查找成功{// 判断该结点是否是叶子结点if (!res.pt->node[res.i].ptr){// 若是叶子结点,则直接删除,然后对该结点进行平衡判断Delete(&res.pt, res.i);BalanceCheck(&res.pt, key);}else{// 若不是叶子节点BTree leftChildPtr = res.pt->node[res.i - 1].ptr;BTree rightChildPtr = res.pt->node[res.i].ptr;if (leftChildPtr->keyNum > MIN_KEYNUM) // 左子树富有,则将左子树中提取最大值放到该结点中替换要删除的关键字{res.pt->node[res.i].key = leftChildPtr->node[leftChildPtr->keyNum].key;leftChildPtr->keyNum--;}else if (rightChildPtr->keyNum > MIN_KEYNUM) // 右子树富有,则将右子树中提取最小值放到该结点中替换要删除的关键字{res.pt->node[res.i].key = rightChildPtr->node[1].key;for (int j = 1; j < rightChildPtr->keyNum; j++){rightChildPtr->node[j] = rightChildPtr->node[j + 1];}rightChildPtr->keyNum--;}else // 左右子树都不富有,则合并左右子树{MergeBro(&leftChildPtr, &rightChildPtr);// 删除结点的关键字res.i = Search(res.pt, key); // 合并结点可能会改变结点中关键字的次序,重新查序for (int j = res.i; j < res.pt->keyNum; j++){res.pt->node[j] = res.pt->node[j + 1];}res.pt->keyNum--;// 对结点进行平衡判断BalanceCheck(&res.pt, key);}}}else // 查找失败{printf("您删除的元素不存在");}
}int main()
{int r[16] = {22, 16, 41, 58, 8, 11, 12, 16, 17, 9, 23, 13, 52, 58, 59, 61};BTree T = NULL;Result s;int i;for (int i = 0; i < 16; i++){s = SearchBTree(T, r[i]);if (!s.tag)InseartBTree(&T, r[i], s.pt, s.i);}while (1){printf("\n请输入要删除的关键字: ");scanf("%d", &i);DeleteBTreeNode(&T, i);}
}

3.4 B+树

  B+ 树是一种 B-树的变形树,更适合用于文件索引系统。严格来讲,它已不符合第 5 章中定
义的树了。这里仅进行概念的了解,详细信息可后序用到在进行熟悉。

4 散列表查找(哈希表查找)

  前面讨论了基于线性表、树表结构的查找方法,这类查找方法都是以关键字的比较为基础的。散
列查找法(哈希查找) 的思想,它通过对元素的关键字值进行某种运算,直接求出元素的地址, 即使用关键字到地址的直接转换方法,而不需要反复比较。因此,散列查找法又叫杂凑法或散列法。

4.1 基本术语和概念

  1. 散列函数和地址:用于计算数据元素的哈希值。在记录的存储位置p和其关键字key 之间建立一个确定的对应关系H, 使 p=H( key ), 称这个对应关系H为散列函数,p为散列地址
  2. 散列表:存储数据元素的结构。一个有限连续的地址空间,用以存储按散列函数计算得到相应散列地址的数据记录。通常散列表的存储空间是一个一维数组,散列地址是数组的下标。
  3. 冲突和同义词:不同数据元素计算出的哈希值相同的情况。,那么这相同的哈希值就是同义词;
  4. 解决冲突的方法:如开放定址法、链地址法等。

4.2 散列函数的构造

  常用的方法分类:

  1. 数字分析法
  2. 平方取中法
  3. 折叠法
  4. 除留余数法,如下图:

4.3 哈希表的创建,插入,查找

4.3.1 程序实现

  这里哈希函数采用除留余数法,解决冲突的方法采用开放定址线性探测法.
  这里如果中文输出乱码可以参考下列文章. 链接:

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>#define HASIZE 17
// 哈希表进行初始化时要保证其初始值不为要查询的值,
// 下面的值就是进行初始化的表值,一般不会重复
#define NULLKEY -32768typedef struct hashtable
{int *key;int count; // 当前元素的个数
} HashTable;// 哈希表的初始化
int InitHashtable(HashTable *H)
{H->count = HASIZE;H->key = (int *)malloc(sizeof(int) * HASIZE);if (!H->key){return -1; // 空间分配失败}// 初始化for (int i = 0; i < HASIZE; i++){(H->key)[i] = NULLKEY;}return 0; // 返回0代表初始化成功
}
// 使用除余留数法
int Hash(int key)
{return key % HASIZE;
}// 插入函数
void HashInsert(HashTable *H, int key)
{// 先定义一个地址int addr;addr = Hash(key);// 第一种情况就是一次插入就完成,也就是o(1)// 第二种情况就是有了冲突,也就是第一次取的// 模不为初始值,这时候就要进行,开放地址线性探测法// 这两种相同点就是最后都要把key值插入表中,因此可以稍微合并一下,对下面的代码进行改进// if ((H->key)[addr] == NULLKEY)// {//     (H->key)[addr] = key;// }// else// {//     while ((H->key)[addr] != NULLKEY)//     {//         // addr = Hash(addr+1);//或者//         addr = (addr + 1) % HASIZE;//     }//     // 循环结束的条件是找到了空位,进行插入//     (H->key)[addr] = key;// }// 改进代码情况while ((H->key)[addr] != NULLKEY){// addr = Hash(addr+1);//或者addr = (addr + 1) % HASIZE;}// 循环结束的条件是找到了空位,进行插入(H->key)[addr] = key;
}// 搜索函数,传入一个地址,如果找到的话就让这个地址指向数据
int HashSerach(HashTable H, int key, int *addr)
{*addr = Hash(key);while (H.key[*addr] != key){// 有两种情况是没有找到// 第一就是遇到了NULLKEY,第二种就是循环到了自己本身*addr = (*addr + 1) % HASIZE;if (H.key[*addr] == NULLKEY || H.key[*addr] == key){// 返回-1代表查询失败return -1;}}// 返回0代表查询成功,并且addr指针指向目标数据return 0;
}int main()
{int arr[15] = {4, 6, 76, 89, 3, 43, 45, 657, 87, 879, 65, 342, 42, 34, 242};HashTable H;int *adrr = NULL;int j;int i;adrr = &j;InitHashtable(&H);printf("打印原数组:\n");for (int i = 0; i < 15; i++){printf("%d,", arr[i]);HashInsert(&H, arr[i]);} // 插入完毕// 打印出来:printf("\n打印插入的哈希表\n");for (int i = 0; i < 15; i++){printf("%d,", H.key[i]);} // 插入完毕// 哈希搜索,查找0是否在哈希表中,否的话返回-1printf("\n哈希搜索,查找0是否在哈希表中,否的话返回-1");i = HashSerach(H, 0, adrr);printf("\n%d", i);printf("\n哈希搜索,查找43是否在哈希表中,是的话返回0");i = HashSerach(H, 43, adrr);printf("\n%d", i);return 0;
}

4.3.2 程序结果:

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/4905.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

[系统安全] 六十.威胁狩猎 (1)APT攻击检测及防御与常见APT组织的攻击案例分析

您可能之前看到过我写的类似文章,为什么还要重复撰写呢?只是想更好地帮助初学者了解病毒逆向分析和系统安全,更加成体系且不破坏之前的系列。因此,我重新开设了这个专栏,准备系统整理和深入学习系统安全、逆向分析和恶意代码检测,“系统安全”系列文章会更加聚焦,更加系…

[极客大挑战 2019]Upload、[ACTF2020 新生赛]Upload、[MRCTF2020]你传你呢

[极客大挑战 2019]Upload 打开环境&#xff0c;是上传一句话木马的题 先上传1.php试试&#xff0c;发现不可以 试试改后缀为phtml&#xff0c;提示语句中不能包含<?&#xff0c;只能改木马&#xff1a; <script language"php">eval($_POST[line]);</sc…

机器学习-11-卷积神经网络-基于paddle实现神经网络

文章目录 总结参考本门课程的目标机器学习定义第一步&#xff1a;数据准备第二步&#xff1a;定义网络第三步&#xff1a;训练网络第四步&#xff1a;测试训练好的网络 总结 本系列是机器学习课程的系列课程&#xff0c;主要介绍基于paddle实现神经网络。 参考 MNIST 训练_副…

编译Qt6.5.3LTS版本(Mac/Windows)的mysql驱动(附带编译后的全部文件)

文章目录 0 背景1 编译过程2 福利参考 0 背景 因为项目要用到对MYSQL数据库操作&#xff0c;所以需要连接到MYSQL数据库。但是连接需要MYSQL驱动&#xff0c;但是Qt本身不自带MYSQL驱动&#xff0c;需要自行编译。网上有很多qt之前版本的mysql驱动&#xff0c;但是没有找到qt6…

使用Ollama和OpenWebUI在CPU上玩转Meta Llama3-8B

2024年4月18日&#xff0c;meta开源了Llama 3大模型[1]&#xff0c;虽然只有8B[2]和70B[3]两个版本&#xff0c;但Llama 3表现出来的强大能力还是让AI大模型界为之震撼了一番&#xff0c;本人亲测Llama3-70B版本的推理能力十分接近于OpenAI的GPT-4[4]&#xff0c;何况还有一个4…

降薪、调岗、裁员,库迪咖啡没有“钱景”

文 | 螳螂观察 作者 | 青玥 2024年&#xff0c;连锁咖啡行业依然激战正酣。 卷价格、卷联名、卷代言人&#xff0c;部分咖啡小店已经在这样内卷的氛围中&#xff0c;率先被淘汰&#xff0c;咖门的统计数据显示&#xff0c;2023年前九个月&#xff0c;注销的咖啡企业有9825家…

Unity 数字字符串逗号千分位

使用InputField时处理输入的数字型字符串千分位自动添加逗号&#xff0c;且自动保留两位有效数字 输入&#xff1a;123 输出&#xff1a;123.00 输入&#xff1a;12345 输出&#xff1a;12,345.00 代码非常简单 using UnityEngine; using TMPro;public class …

前端高并发的出现场景及解决方法——技能提升——p-limit的使用

最近在写后台管理系统的时候&#xff0c;遇到一个场景&#xff0c;就是打印的页面需要根据传入的多个id&#xff0c;分别去请求详情接口。 比如id有10个&#xff0c;则需要调用10次详情接口获取到数据&#xff0c;最后对所有的数据进行整合后页面渲染。 相信大家或多或少都遇到…

ASP.NET实验室预约系统的设计

摘 要 实验室预约系统的设计主要是基于B/S模型&#xff0c;在Windows系统下&#xff0c;运用ASP.NET平台和SQLServer2000数据库实现实验室预约功能。该设计主要实现了实验室的预约和管理功能。预约功能包括老师对实验室信息、实验项目和实验预约情况的查询以及对实验室的预约…

Linux--05---相对路径与绝对路径、终端的认识

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 1. 相对路径与绝对路径切换到用户家目录&#xff1a;cd ~当前目录&#xff1a;./ 2. 对终端的认识3. 文件的类型颜色表示的文件类型&#xff1a;文件类型和权限的表…

基于深度学习的实时人脸检测与情绪分类

情绪分类 实时人脸检测与情绪分类 Kaggle Competion 数据集 fer2013 中的测试准确率为 66%CK数据集的检验准确率为99.87%情绪分类器模型预测从网络摄像头捕获的实时视频中的平均成本时间为 4~ 10ms 关键技术要点&#xff1a; 实时人脸检测&#xff1a;系统采用了前沿的人脸检…

明日周刊-第8期

现在露营的人越来越多了&#xff0c;都是带着帐篷或者遮阳篷聚在一起喝喝茶聊聊天&#xff0c;这是一种很好的放松方式。最近我养了一只金毛&#xff0c;目前两个月大&#xff0c;非常可爱。 文章目录 一周热点资源分享言论歌曲推荐 一周热点 一、人工智能领域 本周&#xff…

迈威通信首秀成都工博会,迸发品牌强势能

4月26日&#xff0c;在繁花似锦的成都&#xff0c;一场工业界的盛会刚刚落下帷幕。而在这场盛会的璀璨星辰中&#xff0c;迈威通信以其首秀之姿&#xff0c;迸发出耀眼的光芒&#xff0c;强势展现了品牌的实力与魅力。 此次展会&#xff0c;迈威通信以“工业互联赋能新数字化智…

C语言求 MD5 值

MD5值常被用于验证数据的完整性&#xff0c;嵌入式开发时经常用到。md5sum命令可以求MD5码&#xff0c;下面介绍如何用C语言实现MD5功能。 一、求字符串MD5值 1、md5sum命令 $ echo -n "12345678" | md5sum //获取"12345678"字符串的md5值 结果&…

react 学习笔记二:ref、状态、继承

基础知识 1、ref 创建变量时&#xff0c;需要运用到username React.createRef()&#xff0c;并将其绑定到对应的节点。在使用时需要获取当前的节点&#xff1b; 注意&#xff1a;vue直接使用里面的值&#xff0c;不需要再用this。 2、状态 组件描述某种显示情况的数据&#…

VCSA6.7重置root密码

VCSA6.7重置root密码 1、登录VCSA所运行的ESXI主机 2、打开VCSA虚拟机Web控制台&#xff0c;先拍摄一个快照&#xff0c;然后重启虚拟机&#xff0c;在如下界面按"e" 3、找到linux开头的段落&#xff0c;在末尾追加rw init/bin/bash; 4、输入完成后&#xff0c;按&…

LPDDR5和LPDDR5X区别

发布时间 LPDDR5和LPDDR5X的发布时间如下&#xff1a; LPDDR5的具体发布时间没有直接提及&#xff0c;但它在市场上的应用早于LPDDR5X。LPDDR5作为LPDDR4(X)的继任者&#xff0c;其规范发布和商用化大致发生在2019年至2020年间&#xff0c;具体技术细节和产品商用则依据各制造…

【ruoyi-vue】关于密码重置

文章目录 前言解决问题 前言 在qq群里经常看到问ruoyi的账号密码是多少&#xff1f;有源代码忘记了登录密码怎么办&#xff1f; 解决问题 在 ruoyi-admin 模块内 SysUserController找到新增用户或修改用户密码的相关接口在里面就可以找相关创建密码的方法ruoyi里的创建密码的…

MySQL从入门到高级 --- 3.DML基本操作

文章目录 第三章&#xff1a;3.基本操作 - DML3.1 数据插入3.2 数据修改3.3 数据删除3.4 练习 第三章&#xff1a; 3.基本操作 - DML DML&#xff1a;数据操作语言&#xff0c;用来对数据中表的数据记录进行更新 关键字&#xff1a; insert 插入 delete 删除 update 更新 …

OceanBase V4.3 发布—— 迈向实时分析 AP 的重要里程

OceanBase在2023年初&#xff0c;发布了4.x架构的第一个重要版本&#xff0c;V4.1。该版本采用了单机分布式一体化架构&#xff0c;并在该架构的基础上&#xff0c;将代表数据库可靠性的RTO降低至 8 秒以内&#xff0c;从而确保在意外故障发生后&#xff0c;系统能够在极短时间…