C语言静态查找表：顺序查找、二分查找、分块查找

最新推荐文章于 2024-07-06 13:12:18 发布
最新推荐文章于 2024-07-06 13:12:18 发布
阅读量7.9k 收藏 119
点赞数 17
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42250302/article/details/89739921
版权

目录

1 静态查找表

2 静态查找的三种方法

2.1 顺序查找

2.1.1 概念

2.1.2 分类

2.1.3 源代码示例

2.1.4 性能分析

2.2 二分查找

2.2.1 实现算法前提

2.2.2 实现思路（以升序为例）

2.2.3 源代码示例

2.2.4 性能分析

2.3 分块查找

2.3.1 概念

2.3.2 实现思路

2.3.3 特点

2.3.4 源代码示例

2.3.5 性能分析

3 三种算法性能比较

 

1 静态查找表

概念：静态查找表是数据元素的线性表，可以是基于数组的顺序存储或以线性链表存储。

2 静态查找的三种方法

2.1 顺序查找

2.1.1 概念

顺序查找又称静态查找，是最基本的查找方法之一。

2.1.2 分类

1.无监视哨：从表中一端开始，向另一端逐个将其关键码与待查找元素比较。若相等，则查找成功，返回给定值在表中存储位置；否则查找失败。

2.有监视哨：表中 0 位置存储待查找元素。从表尾向表头查找，若搜索到 0 位置，说明查找失败；否则查找成功。优点：查找过程中省略了每次查找的检测过程，直接返回元素下标，当 L.length >= 1000 时，与方法（1）相比进行一次查找所需平均时间几乎减少一半。

ps：监视哨也可设置在高下标处

2.1.3 源代码示例

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 100   // 表中最大元素个数
typedef int ElemType; // 设置表中元素类型为整型
typedef struct {
    ElemType data[MAXSIZE + 1]; // 下标0处存放监视哨，数组元素存储1~n单元
    int length;
} SqList;

void CreateSqList(SqList *L);         // 创建表
int SeqSearch1(SqList L, ElemType x); // 无监视哨查找算法
int SeqSearch2(SqList L, ElemType x); // 有监视哨查找算法

int main(void)
{
    SqList L;
    int index;

    CreateSqList(&L);

    printf("元素总数为：%d\n", L.length);

    index = SeqSearch1(L, 3);
    if (index == 0)
        printf("查找失败！\n");
    else
        printf("查找成功，下标为：%d\n", index);

    index = SeqSearch2(L, 11);
    if (index == 0)
        printf("查找失败！\n");
    else
        printf("查找成功，下标为：%d\n", index);

    return 0;
}

void CreateSqList(SqList *L) // 创建表
{
    int i, n;

    printf("请输入元素个数：");
    scanf("%d", &n);
    while (n > MAXSIZE || n < 1) {
        printf("个数超出范围，重新输入：");
        scanf("%d", &n);
    }
    L->length = n;

    printf("请依次输入元素值：\n");
    for (i = 1; i <= L->length; i++)
        scanf("%d", &(L->data[i]));
}
int SeqSearch1(SqList L, ElemType x) // 无监视哨查找算法
{
    int i = 1;

    /*
     * for (i = 1; i <= L.length; i++)
     *     if (L.data[i] == x)
     *         return i;
     */

    while (i <= L.length && L.data[i] != x)
        i++;
    if (i <= L.length)
        return i;
    return 0;
}
int SeqSearch2(SqList L, ElemType x) // 有监视哨查找算法
{
    int i;
    L.data[0] = x;
    for (i = L.length; L.data[i] != x; i--)
        ;
    return i;
}

2.1.4 性能分析

设表中有 n 个元素，给定值 x 与表中第 i 个元素相等，则定位元素 x 时，共查找 n - i + 1 次，即 Ci = n - i + 1。因此查找成功时，平均查找长度（Average search length）为：

ASL=\sum^n_{i=1}p_i(n-i+1)

 

设每个元素的查找概率相等，即 p_i=\frac{1}{n}

 

将 \large p_{i} 代入可得：ASL=\frac{n+1}{2}

 

2.2 二分查找

2.2.1 实现算法前提

要实现表的二分查找，必须使表有序（升序 / 降序）

2.2.2 实现思路（以升序为例）

取有序表中间元素为比较对象：

（1）若待查找元素 = 中间元素，则返回中间元素下标；

（2）若待查找元素 < 中间元素，则在表左半部分查找；

（3）若待查找元素 > 中间元素，则在表右半部分查找

2.2.3 源代码示例

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 100   // 表中最大元素个数
typedef int ElemType; // 设置表中元素类型为整型
typedef struct {
    ElemType data[MAXSIZE + 1]; // 下标0处存放监视哨，数组元素存储1~n单元
    int length;
} SqList;

void CreateSqList(SqList *L);           // 创建表
void ASCSort(SqList *L);                // 对表进行升序排序
int BinarySearch(SqList L, ElemType x); // 二分查找非递归算法
int BinarySearch_Recursive(SqList L, int low, int high, ElemType x);
// 二分查找递归算法

int main(void)
{
    SqList L;
    int index;

    CreateSqList(&L);
    printf("元素总数为：%d\n", L.length);
    ASCSort(&L);

    index = BinarySearch(L, 3);
    if (index == 0)
        printf("查找失败！\n");
    else
        printf("查找成功，下标为：%d\n", index);

    index = BinarySearch_Recursive(L, 1, L.length, 8);
    if (index == 0)
        printf("查找失败！\n");
    else
        printf("查找成功，下标为：%d\n", index);

    return 0;
}

void CreateSqList(SqList *L) // 创建表
{
    int i, n;

    printf("请输入元素个数：");
    scanf("%d", &n);
    while (n > MAXSIZE || n < 1) {
        printf("个数超出范围，重新输入：");
        scanf("%d", &n);
    }
    L->length = n;

    printf("请依次输入元素值：\n");
    for (i = 1; i <= L->length; i++)
        scanf("%d", &(L->data[i]));
}
void ASCSort(SqList *L) // 对表进行升序排序
{
    int i, j, temp;

    for (i = 1; i <= L->length - 1; i++)
        for (j = i; j <= L->length; j++)
            if (L->data[i] > L->data[j]) {
                temp = L->data[i];
                L->data[i] = L->data[j];
                L->data[j] = temp;
            }

    printf("升序排序后：");
    for (i = 1; i <= L->length; i++)
        printf("%d, ", L->data[i]);
    printf("\n");
}
int BinarySearch(SqList L, ElemType x) // 二分查找非递归算法
{
    int low, mid, high;

    low = 1;
    high = L.length;
    while (low <= high) {
        mid = (high + low) / 2;

        if (x == L.data[mid])
            return mid;
        else if (x < L.data[mid])
            high = mid - 1;
        else // (x > L.data[mid])
            low = mid + 1;
    }

    return 0;
}
int BinarySearch_Recursive(SqList L, int low, int high, ElemType x)
{
    int mid;

    if (low > high)
        return 0;
    else {
        mid = (high + low) / 2;

        if (x == L.data[mid])
            return mid;
        else if (x < L.data[mid])
            return BinarySearch_Recursive(L, low, mid - 1, x);
        else // (x > L.data[mid])
            return BinarySearch_Recursive(L, mid + 1, high, x);
    }
}

2.2.4性能分析

 

 

 

查找图中任一元素的过程，即是从根节点到该元素的路径，比较次数 k 为该元素节点在树中的层次数。所以：K=\lfloor log_2n+1 \rfloor

设每个元素的查找概率相等，即 

p_i=\frac{1}{n}，

ASL=\sum^n_{i=1}p_iC_i=p_ik \approx log_2(n+1)-1

 

2.3分块查找

2.3.1概念

分块查找又称索引顺序查找，是对顺序查找的一种改进。

2.3.2实现思路

将数据表分成若干块，然后为每块建立一个索引，将所有块组织起来建立一个索引表

（1）数据表：存储所有数据元素

（2）索引表(index_table)：表中每个索引有两个部分，关键码字段、指针字段

关键码字段：存储对应块中的最大元素

指针字段：存储对应块中起始元素位置

2.3.3特点

表中数据是分块有序的。即索引表中数据是有序的，数据表中数据不要求有序。

查找元素时，先根据索引表确定元素所在块数，然后再从数据表对应块中查找该元素。

2.3.4源代码示例

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE  100  // 表中最大元素个数
#define BLOCKNUM 5    // 索引表中最大块数
typedef int KeyType;  // 设置索引表元素类型为整型
typedef int DataType; // 设置记录的其他项为整型
typedef struct        // 数据表结构体
{
    KeyType key;       // 节点元素
    DataType data;     // 节点的其他项
} SqList[MAXSIZE + 1]; // 数据表0位置存储数据表的长度

typedef struct // 索引表结构体
{
    KeyType key;            // 块的最大关键字
    int addr;               // 块的起始地址
} IndexTable[BLOCKNUM + 1]; // 索引表0位置存储数据表的长度

void CreateSqList(SqList L, IndexTable id);   // 创建表
void TraverseSqList(SqList L, IndexTable id); // 遍历表
int BlockSearch(SqList L, IndexTable id, KeyType x); // 查找块中元素值为x的元素

int main(void)
{
    SqList L;
    IndexTable id;
    int index;

    CreateSqList(L, id);
    TraverseSqList(L, id);

    index = BlockSearch(L, id, -7);
    if (index == 0)
        printf("表中无此元素！\n");
    else
        printf("查找成功，元素下标为：%d\n", index);

    index = BlockSearch(L, id, 17);
    if (index == 0)
        printf("表中无此元素！\n");
    else
        printf("查找成功，元素下标为：%d\n", index);

    index = BlockSearch(L, id, 100);
    if (index == 0)
        printf("表中无此元素！\n");
    else
        printf("查找成功，元素下标为：%d\n", index);

    return 0;
}

void CreateSqList(SqList L, IndexTable id) // 创建表
{
    int i, j, k, m, n;
    int elemnum, bnum; // 总元素个数；总块数
    int max = INT_MIN; // 块中最大元素

    printf("请输入元素个数( < 100)、块数( < 5 )：");
    scanf("%d%d", &elemnum, &bnum);
    while (elemnum < 1 || elemnum > MAXSIZE || bnum < 1 || bnum > BLOCKNUM ||
           bnum > elemnum) {
        printf("输入有误，重新输入：");
        scanf("%d%d", &elemnum, &bnum);
    }

    L[0].key = elemnum; // 数据表0位置存储数据表的长度
    id[0].key = bnum;   // 索引表0位置存储索引表的长度

    n = elemnum / bnum;             // 平均每块元素个数
    for (i = 1; i <= bnum - 1; i++) // 构造前 bnum - 1 块中的元素
    {
        printf("请输入块 %d 的 %d 个元素（最小元素不能小于 %d ）：", i, n, max);

        k = (i - 1) * n; // 第 i 块元素起始下标
        for (j = 1; j <= n; j++) {
            scanf("%d", &(L[k + j].key));
            if (max < L[k + j].key) // 获取第 i 块中最大元素
                max = L[k + j].key;
        }
        id[i].key = max;
        id[i].addr = k + 1;
    }

    k = (bnum - 1) * n;
    m = elemnum - k; // 最后一块元素个数
    printf("请输入块 %d 的 %d 个元素（最小元素不能小于 %d ）：", bnum, m, max);
    for (j = 1; j <= m; j++) // 构造最后一块中的元素
    {
        scanf("%d", &(L[k + j].key));
        if (max < L[k + j].key) // 获取最后一块中最大元素
            max = L[k + j].key;
    }
    id[i].key = max;
    id[i].addr = k + 1;
}
void TraverseSqList(SqList L, IndexTable id) // 遍历表
{
    int i;

    printf("---------数据表信息---------\n");
    for (i = 1; i <= L[0].key; i++) // 遍历并输出表中元素
        printf("%d, ", L[i].key);
    printf("\n---------索引表信息---------");
    for (i = 1; i <= id[0].key; i++) // 遍历并输出索引表信息
        printf("\n%d, %d", id[i].key, id[i].addr);
    printf("\n----------------------------\n");
}
int BlockSearch(SqList L, IndexTable id, KeyType x) // 查找块中元素值为x的元素
{
    int low1, high1, low2, high2, mid, i;

    low1 = 1;
    high1 = id[0].key;    // 设置索引表二分查找上下区间
    while (low1 <= high1) // 查找元素所在块数
    {
        mid = (low1 + high1) / 2;
        if (x <= id[mid].key)
            high1 = mid - 1;
        else
            low1 = mid + 1;
    }

    if (low1 <= id[0].key) // 若low1 > id[0].key，则关键子大于数据表中所有元素
    {
        low2 = id[low1].addr; // 元素所在块的最小下标
        if (low1 == id[0].key)
            high2 = L[0].key; // 元素所在块的最大下标
        else
            high2 = id[low1 + 1].addr - 1;

        for (i = low2; i <= high2; i++) // 在指定块中查找元素并返回下标
            if (L[i].key == x)
                return i;
    }

    return 0; // 查找失败返回0
}

2.3.5性能分析

设 n 个数据元素的表分为 m 个子表，则子表(sub_table)元素个数为 t = n / m ；

则

ASL=ASL_{(index\_table)}+ASL_{(sub\_table)}=\frac{1}{2} \times (m+1) +\frac{1}{2} \times (\frac{n}{m}+1)=\frac{1}{2} \times (m+\frac{n}{m})+1

当 m= \sqrt{n} 时，  ASL=\sqrt{n}+1 达到最小值。

3.三种算法性能比较

顺序查找时间复杂度：T(n)=O(n)

二分查找时间复杂度：T(n)=O(log_2n)

分块查找时间复杂度：T(n)=O(\sqrt{n})\\

O(n) > O(\sqrt{n})>O(log_2n)

 

 

其铄
关注
专栏目录
分块查找算法（C语言实现）
数据结构和算法教程（C语言版）
01-03 1208
分块查找又称索引顺序查找，是一种在顺序查找算法基础上改进得到的算法。在索引顺序结构表示的静态查找表中，可以借助分块查找算法在表中查找特定的元素。索引顺序结构是一种顺序表和索引表的组合存储结构，例如：图 1 索引顺序结构数据全部存储在顺序表中，存储时遵循“分块有序”的规则。图 1 中的整个顺序表被分成了 3 块（用不同的颜色区分），第二块的所有元素都比第一块的大，同样第三块的所有元素都比第二块的大。根据各个块内的元素最大值，所有块有序存放在顺序表中，这样的存储方式就称为分块有序。
（C语言实现）静态查找表之顺序表的查找
yuxi___的博客
08-01 1526
实现思路： 从表中的最后一个记录开始，逐个进行纪律的关键字和给定值的比较，若某个记录的关键字和给定值比较相等，则查找成功；反之，则查找失败。为了提高查找效率，我们可以设置一个监视哨。 监视哨：所谓的监视哨就是将表中的第一个元素赋值为给定值（也可以将它设在高下标处），它的目的免去查找过程中每一步都要检测整个表是否检测完毕。 但是只在ST.length>=1000时，进行一个查找所需的平均时间几乎减少一半。 代码 int Search_Seq(SSTable ST,int key) {//key为所要查找
静态表的顺序查找（BUCT-JK1602-LLP）
sunshine_rebrith的博客
10-24 3144
Problem A: 算法9-1：静态表的顺序查找 Time Limit: 1 Sec Memory Limit: 128 MB Submit: 388 Solved: 102 [Submit][Status][Web Board] Description用顺序表或者线性链表表示静态查找表时，搜索函数可以采用顺序查找来实现。 通常顺序查找的查找过程是从表中的自后一个记录开始，逐个将记
顺序查找算法（Sequential Search）
最新发布
weixin_64534587的博客
07-06 964
顺序查找算法（Sequential Search），也称为，是最基本的查找技术之一。其工作原理是从数据结构（如数组）的一端开始，检查每个元素，直到找到所需的特定元素或搜索到数据结构的另一端为止。简单来说，顺序查找是一种简单直观的查找方法，它通过从数据集合的比较目标值与每个元素的值，直到找到目标值或者遍历完所有元素为止。
C语言数据结构——静态查找顺序查找
weixin_45084986的博客
06-28 304
顺序查找 基本思想： 从顺序表的一端开始，用给定数据元素的关键字逐个和顺序表中各数据元素的关键字比较，若在顺序表中查找到要查找的数据元素，则查找成功，函数返回该数据元素在顺序表中的位置；否则查找失败，函数返回-1。 #include "SeqList.h" int SeqSearch(DataType a[], int n, KeyType key) //在a[0]--a[n-1]中顺序查找关键码为key的数据元素 //查找成功时返回该元素的下标序号；失败时返回-1 { int i = 0; wh
静态查找（c语言）表
wxlwxllxw的博客
03-27 498
一、 查找概念 假设有两组数据: int array1[]={6,4,5,3,8,7,1,2,0,9}; int array2[]={0,1,2,3,4,5,6,7,8,9}; 一个有序数组,一个无序数组, 在他们之间查找某一个值的方法有什么区别呢, 对于两组数据我们都可以用最直接的方法，逐个比较直到遇到合适的值。 思路是怎么样的呢:从表中最后一个记录开始，逐个进行记录的关键字和给定值的比较，若某...
静态查找
happylife1527的专栏
08-31 461
#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间
【数据结构】查找：基本概念及静态查找表（顺序查找、二分查找、索引查找）
自律带来自由
08-20 4457
#笔记整理 查找 查找的基本概念 静态查找表——基于线性表的查找法 动态查找表——基于树表的查找法 哈希表——计算式查找法 基本概念 查找表 由同一类型的数据元素（记录）构成的集合。 查找的定义 给定一个值 key，在含有 n 个记录的表中找出关键字等于 key 的记录。若找到，则查找成功，返回该记录的信息或该记录在表中的位置；否则查找失败，返回相关的指示信息。 静态查找表(Static S...
三大基础查找（顺序、二分、分块）
ZER00000001的博客
07-04 1851
查找和排序是数据结构与算法中不可或缺的一环，是前辈们在算法道路上留下的重要且方便的一些技巧，学习这些经典的查找和排序也能让我们更好和更快的解决问题。在这个专栏中我们会学习六大查找和十大排序，而本篇将详细讲解其中的三大基础查找——顺序查找、折半（二分）查找、分块（索引）查找这些概念非常的简单，我们只需要快速的过一遍即可；顺序查找那是非常的简单，就是用 for循环遍历数据去判断就行了； 虽然顺序查找简单，但它是唯一 一 个可以针对于无序的数据进行查找；即使是顺序查找也是有优化的方法的，这里还可以提一句，我们针对
7.1 顺序查找、折半查找、分块查找
qq_42077929的博客
11-15 1434
顺序查找、折半查找基础概念顺序查找一般线性表的顺序查找平均查找次数优缺点：有序表的顺序查找思路失败结点平均查找长度折半查找平均查找长度时间复杂度分块查找（索引顺序查找）思路步骤平均查找长度 基础概念 在学习查找之前我们需要了解一些基础概念： 查找：在数据结构中寻找满足某种条件的数据元素的过程叫做查找 查找表：用于查找的数据集合，由同一类型的数据元素组成，可以是链表、数组等 静态查找表：只支持查找，不支持改动的查找表；对应的有动态查找表 关键字：数据元素中唯一标识该元素的某个数据项的值。如学号至于学生 平均
C语言——查找（折半、分块、二叉排序、哈希法）
qq_51308373的博客
06-20 4446
前言 本篇主要介绍查找概念及各类查找方法。 看完本篇，你将了解到： 1.查找问题概述（查找表可进行的操作、时间开销、一些计算方法） 2.顺序表的查找（存储方式、算法时间性能） 3.折半查找（可递归可迭代） 4.分块查找 5.二叉排序树（查找、插入、创建、删除） 6.平衡二叉排序树（平衡化方法：四种类型） 7.哈希查找（哈希表、哈希函数、解决冲突的方法） 一、查找问题概述 1.查找问题 （1）定义： ①“查找”是基于数据逻辑结构(D,R)定义的一种十分常见的运算。 ②D：数据元素的一个集合 R：数据元素关系的
数据结构顺序表查找（C语言版）
10-10
折半查找算法 顺序表 数据结构顺序表查找（C语言版）
数据结构之静态查找表——顺序查找、折半查找与分块查找
人生处处是围城，一切都是最好的安排！
11-26 4274
前言 在非数值运算问题中，数据存储量一般很大，为了能在大量信息中找到某些值，就需要用到查找技术。而为了提高查找效率，就需要对一些数据进行排序。查找和排序是两大重要技术，其数据处理量几乎占到数据总处理量的80%以上，所以查找与排序的有效性直接就影响到基本算法的有效性。本篇文章主要来讨论查找技术中的静态查找，主要包括顺序查找法、折半查找法以及分块查找法。 关于查找 查找表：是由同一类型的数据元素(或记录)构成的集合。由于“集合”中的数据元素之间存在着松散的关系，没有严格的前驱和后继的关系，因此...
静态顺序表查找
qq_43776742的博客
03-30 415
静态顺序表查找 #include<stdio.h> #include<stdlib.h> #define EQ(a,b) ((a)==(b)) #define LT(a,b) ((a)<(b)) #define LQ(a,b) ((a)<=(b)) #define N 5 /* 数据元素个数 */ typedef int Status; typedef ...
数据结构之静态查找表的查找方法
qq_33501207的博客
01-31 2533
查找是一种常用的基本运算。查找表是指由同一类型的数据元素(或记录)构成的集合。由于“集合”中的数据元素之间存在着完全松散的关系，因此，查找表是一种非常灵活的数据结构。
静态查找--顺序表
weixin_42917994的博客
05-23 395
查找： 静态查找：只查找某个特定的元素是否在表中，或查找它的属性。（就是通常所说的查找） 动态查找：在查找表中国插入，删除一个元素，对表进行操作。 顺序表的查找 一般的查找：从头到尾的遍历查找 int Find(Sqlist L,int key){//平均查找长度为(n+1)/2 int i; L.date[0]=key;//设置监视哨 for(i=L.length;...
静态表查找--顺序表的查找（无序）
滴水藏海
12-09 1721
静态查找表在查找的过程中不改变表的状态---不插入也不删除，适合不变动或者不经常变动的查找，顺序表可以使有序的也可以是无序的，如果是有序的可以使用折半查找，每查找一次，就把范围缩小一半。如果是无序的就只能从表的一端开始逐一查找了。 本文先构建一个无序的顺序表，然后从表的一端进行查找指定的元素。 #include #include #include #define ERROR 0 #define
数据结构之分块查找
AAS48的博客
10-29 1744
字典就是一种分块查找，也可以叫索引 试想： 给你一本没有索引的字典，里面全部乱序，那么我们不得不用最低级的顺序查找法查找单词，即一页一页地翻，一个一个地对比，费时费力，给你一天时间可能都找不到某一个词… 而有了分块这种操作，将首字母相同的单词放在一个集体里，查找起来可以帮助我们快速定位，效率大大提高，这就是分块查找。 例子： 如果我们按照这个样子建立起索引表，那么查找过程就非常轻松了。注意：索引查找要求块间有序，即第二块里面的所有元素都比第一块里面大，第三块里面的所有元素都比前两块大。 比如上图查找4
【数据结构】静态表查找之顺序查找、二分查找、分块查找
四季轮换叶，一路招摇胜
10-11 4361
​通过一定的方法找出与给定关键字相同的数据元素的过程叫做查找。也就是根据给定的某个值，在查找表中确定一个关键字等于给定值的记录或数据元素。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值