【查找算法概念】与【线性表的相关查找算法】

已于 2024-10-08 08:56:01 修改
阅读量1.1k 收藏 26
点赞数 35
分类专栏： 数据结构---C语言 文章标签： 数据结构 查找算法
于 2024-10-07 17:46:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82676816/article/details/142491459
版权

1.知识回顾

在这里插入图片描述

2.查找算法相关问题汇总

2.1在哪里查找

查找表

在这里插入图片描述

2.2通过什么进行查找

关键字的对应
在这里插入图片描述
主关键字：比如我们可以通过一个学号来唯一确定一名学生
这里的学号就是一种主关键字。

次关键字：而通过一个名字李华，我们可能会确定不止一名学生
这里的名字李华就是一种次关键字。

实际上我们只需要明白
主关键字唯一确定一个元素
次关键字可能确定多个元素
即可

2.3查找是否成功

在这里插入图片描述

2.4查找的目的

在这里插入图片描述

2.5查表找的分类

在这里插入图片描述

2.6评价查找算法–平均查找长度

在这里插入图片描述

2.7查找过程中的研究目标

在这里插入图片描述

3.线性表的查找

3.1分类：

顺序查找（线性查找），折半查找（二分或对分查找），分块查找

3.2线性表的顺序查找

实际上就是暴力遍历，从表头遍历到表尾，直至查找到对应元素
当然我们也可以从表尾遍历到表头直至查找到对应元素

3.2.1顺序查找的应用范围：

  • 顺序表或线性链表表示的静态查找表
  • 表内元素之间可以无序

3.2.2顺序表的表示

//定义动态顺序表初始默认最大容量
#define InitSize 12

typedef int KeyType ;
//KeyType:是顺序表中每个关键字的类型



//1.顺序表的表示：

//1.1数据元素类型定义
typedef struct
{
	KeyType key;//关键字域

	//除了关键字域以外，还可以定义其他域
}ElemType;

//ElemType:是顺序表中的数据类型

//1.2顺序表的结构类型定义

typedef struct 
{
	ElemType * elem;//顺序表的基地址（动态数组存储）
	int length;//表长
    int maxsize;//顺序表的最大容量
}SSTable;

//SSTable:用来定义一个顺序表

3.2.3 顺序表的顺序查找算法：

  • 1.一般的顺序查找算法：
    在这里插入图片描述
三种基本形式的代码
//在顺序表L中,查找值为key的数据元素，若成功返回其位置信息，否则返回0；
//注意这里的位置信息就是顺序表数组下标：从1开始（因为我们是从下标1开始存储第一个有效数据的）

//1.不带监视哨的顺序查找法
//思路：从后往前比较，直到找到key或比较到最后一个元素
//时间复杂度：O(n)
//空间复杂度：O(1)

//方式1：
int Search1(SSTable L, KeyType key)
{
    for (int i = L.length; i >= 1; i--)
    {
        if (L.elem[i].key == key)
        {
            return i;
        }
    }
    return 0;
}

//其他方式：（主要包含了边界条件的判断）
//方式2：
int Search2(SSTable L, KeyType key)
{
    int i;
    for (i = L.length; L.elem[i].key!=key; i--)
    {
        if (i <= 0)
        {
            break;
        }
    }

    if (i > 0)
    {
        return i;
    }
    else
    {
        return 0;
    }
    
}


//方式3：
int Search3(SSTable L, KeyType key)
{
    int i;
    for (i = L.length; L.elem[i].key != key && i > 0; i--);
    //这里实际上就是将两个判断条件合并了 一定要注意这里的for循环没有循环体，需要加引号。
  
    if (i > 0)
    {
        return i;
    }
    else
    {
        return 0;
    }

}
  • 改进过后的顺序查找（添加了监视哨）：
    在这里插入图片描述
    如下图：
    在这里插入图片描述
    代码如下：
//2.改进后带监视哨的顺序查找法
//思路：把待查关键字key存入表头（哨兵，监视哨）从后往前比较，直到找到key或比较到最后一个元素，直接返回i的值
//可以减少查找过程中每一步都要检测是否查找完毕，加快了查找速度


int Search4(SSTable L, KeyType key)
{
    //[1]初始化监视哨
    L.elem[0].key = key;

    //[2]顺序查找操作：
    int i;
    for ( i = L.length; L.elem[i].key != key; i--);

    //[3]返回最后的i值：
    //如果能找到key，那么i就是key的位置，否则i就是0（即监视哨位置的下标）
    return i;
}

3.2.4顺序查找法操作一览：

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

//定义动态顺序表初始默认最大容量
#define InitSize 12

typedef int KeyType ;//KeyType:是顺序表中每个关键字的类型



//1.顺序表的表示：

//1.1数据元素类型定义
typedef struct
{
	KeyType key;//关键字域

	//除了关键字域以外，还可以定义其他域
}ElemType;

//ElemType:是顺序表中的数据类型

//1.2顺序表的结构类型定义

typedef struct 
{
	ElemType * elem;//顺序表的基地址（动态数组存储）
	int length;//表长
    int maxsize;//顺序表的最大容量
}SSTable;

//SSTable:用来定义一个顺序表



//2.顺序表的一些基本操作：（与之前所学完全一致）
//这里仅涉及初始化，与输出（重点是查找算法）

//2.1顺序表的初始化（动态顺序表）
bool InitSeqList(SSTable* L)
{
    //[0]防止程序潜在异常
    if (L == NULL)
    {
        return false;
    }

    //[1]初始化动态数组的内存空间
    //注意：因为动态顺序表定义时只定义了一个指针，没有给指针分配空间，这是一个极其危险的野指针
    //所以我们需要为它分配一片空间，而且这片空间的大小应该由初始化时定义的InitSize来决定
    L->elem = (ElemType*)malloc(sizeof(ElemType) * InitSize);
    //sizeof(ElemType)*InitSize):本程序中的ElemType是结构体类型（包含了int 类型的 关键字域），所以这里分配了InitSize个结构体类型的空间

    //[2]检查内存分配是否成功
    if (L->elem == NULL)
    {
        printf("顺序表内存分配失败！");
        return false;
    }

    //[3]初始化表长
    L->length = 0;


    //[4]初始化动态顺序表的最大容量
    //注意这里的最大容量是初始值（即前面定义过的InitSize），后续有需求的时候可以进行扩容
    L->maxsize = InitSize;

    return true;
}


//6.动态顺序表的元素插入
//可以类比静态顺序表的插入操作
bool SeqListInsert(SSTable* L, int i, KeyType e)//在顺序表的第i个【元素位序】位置插入一个新元素e
{
    //[1]确保顺序表指针和数据指针不为空
    if (L == NULL || L->elem == NULL)
    {
        printf("顺序表指针为空或数据指针为空！\n");
        return false;
    }


    //[2]判断插入操作是否合法
    //<1>插入位置不合法
    // （比如一个顺序表长度为8，而插入位置是【元素位序】第0位【即数组下标】[-1]，插入位置是【元素位序】第10位【即数组下标】[9]等）
    //注意：数组末的下一个元素的位置是可以插入的（即在顺序表的末尾添加一个元素）此时【元素位序】第Length+1位
    //但是数组末的下下个元素及以后位置不能插入
    if (i<1 || i>L->length + 1)
    {
        printf("插入位置不合法！\n");
        // return false;
    }

    //<2>顺序表已经存满了，不能再插入
    if (L->length >= L->maxsize)//最大容量为可变值maxsize
    {
        printf("顺序表已满！\n");
        return false;
    }

    //[3]将新元素插入到正确的位置------区分数组下标[i-1]和元素位序[i]的排列（元素位序比数组下标大1）
    //<1>将【元素位序】第i位以及第i位之后的所有元素后移一位
    for (int j = L->length; j >= i; j--)
    {
        L->elem[j] = L->elem[j - 1];
    }//现在的j就是数组下标

    //<2>在【元素位序】第i位【即数组下标】第i-1位插入新元素e
    L->elem[i-1].key = e;

    //[4]顺序表长度+1
    L->length++;

    //[5]返回true,插入成功
    return true;

}



//2.2动态顺序表的输出
bool SeqListPrint(SSTable L)
{
    //[1]判断是否为空表
    if (L.length == 0)
    {
        printf("该顺序表是空表!\n");
        return false;
    }


    //[2]输出顺序表的元素
    printf("SeqList:\n");
    for (int i = 0; i < L.length; i++)
    {
        printf("%d-->", L.elem[i].key);
    }
    printf("end\n");
    return true;
}






//顺序表的查找算法：(从最后一个元素开始比较)
//在顺序表L中,查找值为key的数据元素，若成功返回其位置信息，否则返回0；
//注意这里的位置信息就是顺序表数组下标：从1开始（因为我们是从下标1开始存储第一个有效数据的）

//1.不带监视哨的顺序查找法
//思路：从后往前比较，直到找到key或比较到最后一个元素
//时间复杂度：O(n)
//空间复杂度：O(1)

//方式1：
int Search1(SSTable L, KeyType key)
{
    for (int i = L.length; i >= 1; i--)
    {
        if (L.elem[i].key == key)
        {
            return i;
        }
    }
    return 0;
}

//其他方式：（主要包含了边界条件的判断）
//方式2：
int Search2(SSTable L, KeyType key)
{
    int i;
    for (i = L.length; L.elem[i].key!=key; i--)
    {
        if (i <= 0)
        {
            break;
        }
    }

    if (i > 0)
    {
        return i;
    }
    else
    {
        return 0;
    }
    
}


//方式3：
int Search3(SSTable L, KeyType key)
{
    int i;
    for (i = L.length; L.elem[i].key != key && i > 0; i--);
    //这里实际上就是将两个判断条件合并了 一定要注意这里的for循环没有循环体，需要加引号。
  
    if (i > 0)
    {
        return i;
    }
    else
    {
        return 0;
    }

}



//2.改进后带监视哨的顺序查找法
//思路：把待查关键字key存入表头（哨兵，监视哨）从后往前比较，直到找到key或比较到最后一个元素，直接返回i的值
//可以减少查找过程中每一步都要检测是否查找完毕，加快了查找速度


int Search4(SSTable L, KeyType key)
{
    //[1]初始化监视哨
    L.elem[0].key = key;

    //[2]顺序查找操作：
    int i;
    for ( i = L.length; L.elem[i].key != key; i--);

    //[3]返回最后的i值：
    //如果能找到key，那么i就是key的位置，否则i就是0（即监视哨位置的下标）
    return i;
}


//注意：我们将有效数据从数组中下标为1的位置开始存储，即元素位序为2的位置开始存储
int main()
{
    SSTable L;
    InitSeqList(&L);


    //这里直接初始化11个数据，不考虑动态扩容
    SeqListInsert(&L, 1, -99);
    //第一个数据，即插入到数组下标为0的位置，是垃圾值-99

    SeqListInsert(&L, 2, 5);
    SeqListInsert(&L, 3, 7);
    SeqListInsert(&L, 4, 19);
    SeqListInsert(&L, 5, 21);
    SeqListInsert(&L, 6, 13);
    SeqListInsert(&L, 7, 56);
    SeqListInsert(&L, 8, 64);
    SeqListInsert(&L, 9, 92);
    SeqListInsert(&L, 10, 88);
    SeqListInsert(&L, 11, 80);
    SeqListInsert(&L, 12, 75);

    SeqListPrint(L);


    printf("13查找结果：%d\n", Search4(L, 13));
    printf("60查找结果：%d\n", Search4(L, 60));
	return 0;
}

在这里插入图片描述

3.2.5顺序查找算法的分析：

  • 效率分析：

如下图，共11个元素，查找失败，比较12次
在这里插入图片描述
则有结论：比较次数与key位置有关

查找第i个元素，需要比较n-i+1次
查找失败，需比较n+1次
在这里插入图片描述
在这里插入图片描述

  • 效率优化方法：
    在这里插入图片描述

3.3线性表的二分查找

本篇前提：

  • 每个元素按非递减有序排列
  • 有效数据从下标为1开始存储

3.3.3二分查找的非递归算法

在这里插入图片描述

算法核心思路：

  • （1）初始化上下界（注意这里从下标1开始存储有效数据）
  • （2）循环查找key值
  • （2.1）更新中点下标
  • 若中点元素等于key，返回中点下标
  • 若中点元素大于key，证明待查找元素在前半区间，缩小上界
  • 若中点元素小于key，证明待查找元素在后半区间，缩小下界
  • 若没有找到返回0
//[0]非递归算法只需要传入  顺序表  和  待查找数据key 这两个参数
int Search1(SSTable L,KeyType key)
{
    //[1]初始化上下界
    int low = 1, high = L.length;

    //[2]循环查找key值
    while (low<=high)//注意终止条件为low>high
    {
        //[2.1]更新中点下标
        KeyType mid = (low + high) / 2;
        //[2.2]若中点元素等于key，返回中点下标
        if (L.elem[mid].key == key)
        {
            return mid;
        }
        //[2.3]若中点元素大于key，证明待查找元素在前半区间，缩小上界
        else if(L.elem[mid].key > key)
        {
            high = mid - 1;
        }
        //[2.4]若中点元素小于key，证明待查找元素在后半区间，缩小下界
        else
        {
            low = mid + 1;
        }
    }

    //没有找到返回0
    return 0;
}

3.3.4二分查找的递归算法

核心思路与非递归完全一致，只不过传参时需要传入low,high（递归的前提条件）

算法核心思路：

  • （1）先写递归结束条件
  • （2）更新中点下标
  • （3）递归寻找对应元素
  • 若中点元素等于key，返回中点下标
  • 若中点元素大于key，递归查找前半区间
  • 若中点元素等于key，递归查找后半区间
//2.顺序表的二分查找算法（递归）
//有效数据从下标1开始存储

//[0]注意传入  顺序表  和  待查找数据key  起始元素下标 最后一个元素下标 这四个参数（后两个参数是为了递归做准备）
int Search2(SSTable L, KeyType key,int low,int high)
{
    //[1]递归结束条件
    if (low > high)
    {
        return 0;
    }

    //[2]更新中点下标
    KeyType mid = (low + high) / 2;
    
    //递归寻找对应元素
    //[2.1]若中点元素等于key，返回中点下标
    if (L.elem[mid].key == key)
    {
        return mid;
    }
    //[2.2]若中点元素大于key，递归查找前半区间
    else if (L.elem[mid].key > key)
    {
        return Search2(L, key, low, mid - 1);
    }
    //[2.3]若中点元素小于key，递归查找后半区间
    else
    {
        return Search2(L, key, mid + 1, high);
    }
}

3.3.5二分查找的实例分析与相关总结

3.3.5.1实例分析：

以查找21成功为实例：
在这里插入图片描述
在这里插入图片描述
中点值大于key，缩短上半区间
在这里插入图片描述
中间值小于key，缩短下半区间
在这里插入图片描述
找到key值
在这里插入图片描述

3.3.5.2相关总结如下：

以非递减有序排列为实例：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.3.6 两种算法操作一览：

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


//定义动态顺序表初始默认最大容量
#define InitSize 13

typedef int KeyType;
//KeyType:是顺序表中每个关键字的类型



//1.顺序表的表示：

//1.1数据元素类型定义
typedef struct
{
	KeyType key;//关键字域

	//除了关键字域以外，还可以定义其他域
}ElemType;

//ElemType:是顺序表中的数据类型

//1.2顺序表的结构类型定义

typedef struct
{
	ElemType* elem;//顺序表的基地址（动态数组存储）
	int length;//表长
	int maxsize;//顺序表的最大容量
}SSTable;

//SSTable:用来定义一个顺序表



//2.顺序表的一些基本操作：（与之前所学完全一致）
//这里仅涉及初始化，与输出（重点是查找算法）

//2.1顺序表的初始化（动态顺序表）
bool InitSeqList(SSTable* L)
{
    //[0]防止程序潜在异常
    if (L == NULL)
    {
        return false;
    }

    //[1]初始化动态数组的内存空间
    //注意：因为动态顺序表定义时只定义了一个指针，没有给指针分配空间，这是一个极其危险的野指针
    //所以我们需要为它分配一片空间，而且这片空间的大小应该由初始化时定义的InitSize来决定
    L->elem = (ElemType*)malloc(sizeof(ElemType) * InitSize);
    //sizeof(ElemType)*InitSize):本程序中的ElemType是结构体类型（包含了int 类型的 关键字域），所以这里分配了InitSize个结构体类型的空间

    //[2]检查内存分配是否成功
    if (L->elem == NULL)
    {
        printf("顺序表内存分配失败！");
        return false;
    }

    //[3]初始化表长
    L->length = 0;


    //[4]初始化动态顺序表的最大容量
    //注意这里的最大容量是初始值（即前面定义过的InitSize），后续有需求的时候可以进行扩容
    L->maxsize = InitSize;

    return true;
}


//6.动态顺序表的元素插入
//可以类比静态顺序表的插入操作
bool SeqListInsert(SSTable* L, int i, KeyType e)//在顺序表的第i个【元素位序】位置插入一个新元素e
{
    //[1]确保顺序表指针和数据指针不为空
    if (L == NULL || L->elem == NULL)
    {
        printf("顺序表指针为空或数据指针为空！\n");
        return false;
    }


    //[2]判断插入操作是否合法
    //<1>插入位置不合法
    // （比如一个顺序表长度为8，而插入位置是【元素位序】第0位【即数组下标】[-1]，插入位置是【元素位序】第10位【即数组下标】[9]等）
    //注意：数组末的下一个元素的位置是可以插入的（即在顺序表的末尾添加一个元素）此时【元素位序】第Length+1位
    //但是数组末的下下个元素及以后位置不能插入
    if (i<1 || i>L->length + 1)
    {
        printf("插入位置不合法！\n");
        // return false;
    }

    //<2>顺序表已经存满了，不能再插入
    if (L->length >= L->maxsize)//最大容量为可变值maxsize
    {
        printf("顺序表已满！\n");
        return false;
    }

    //[3]将新元素插入到正确的位置------区分数组下标[i-1]和元素位序[i]的排列（元素位序比数组下标大1）
    //<1>将【元素位序】第i位以及第i位之后的所有元素后移一位
    for (int j = L->length; j >= i; j--)
    {
        L->elem[j] = L->elem[j - 1];
    }//现在的j就是数组下标

    //<2>在【元素位序】第i位【即数组下标】第i-1位插入新元素e
    L->elem[i - 1].key = e;

    //[4]顺序表长度+1
    L->length++;

    //[5]返回true,插入成功
    return true;

}



//2.2动态顺序表的输出
bool SeqListPrint(SSTable L)
{
    //[1]判断是否为空表
    if (L.length == 0)
    {
        printf("该顺序表是空表!\n");
        return false;
    }


    //[2]输出顺序表的元素
    printf("SeqList:\n");
    for (int i = 0; i < L.length; i++)
    {
        printf("%d-->", L.elem[i].key);
    }
    printf("end\n");
    return true;
}


//顺序表的查找算法：
//在顺序表L中,查找值为key的数据元素，若成功返回其位置信息，否则返回0；
//注意这里的位置信息就是顺序表数组下标：从1开始（因为我们是从下标1开始存储第一个有效数据的）

//1.顺序表的二分查找算法（非递归）
//有效数据从下标1开始存储

//[0]非递归算法只需要传入  顺序表  和  待查找数据key 这两个参数
int Search1(SSTable L,KeyType key)
{
    //[1]初始化上下界
    int low = 1, high = L.length;

    //[2]循环查找key值
    while (low<=high)//注意终止条件为low>high
    {
        //[2.1]更新中点下标
        KeyType mid = (low + high) / 2;
        //[2.2]若中点元素等于key，返回中点下标
        if (L.elem[mid].key == key)
        {
            return mid;
        }
        //[2.3]若中点元素大于key，证明待查找元素在前半区间，缩小上界
        else if(L.elem[mid].key > key)
        {
            high = mid - 1;
        }
        //[2.4]若中点元素小于key，证明待查找元素在后半区间，缩小下界
        else
        {
            low = mid + 1;
        }
    }

    //没有找到返回0
    return 0;
}


//2.顺序表的二分查找算法（递归）
//有效数据从下标1开始存储

//[0]注意传入  顺序表  和  待查找数据key  起始元素下标 最后一个元素下标 这四个参数（后两个参数是为了递归做准备）
int Search2(SSTable L, KeyType key,int low,int high)
{
    //[1]递归结束条件
    if (low > high)
    {
        return 0;
    }

    //[2]更新中点下标
    KeyType mid = (low + high) / 2;
    
    //[2.1]若中点元素等于key，返回中点下标
    if (L.elem[mid].key == key)
    {
        return mid;
    }
    //[2.2]若中点元素大于key，递归查找前半区间
    else if (L.elem[mid].key > key)
    {
        return Search2(L, key, low, mid - 1);
    }
    //[2.3]若中点元素小于key，递归查找后半区间
    else
    {
        return Search2(L, key, mid + 1, high);
    }
}


//注意：我们将有效数据从数组中下标为1的位置开始存储，即元素位序为2的位置开始存储
//同时需要注意二分查找的前提是：顺序表已排序（非递减有序排列  或者非递增有序排列）
int main()
{
    SSTable L;
    InitSeqList(&L);

    //这里我们直接构造1个非递减有序排列的顺序表
    //有效数据从顺序表下标为1开始存储
    SeqListInsert(&L, 1, -99);
    //第一个数据，即插入到数组下标为0的位置，是垃圾值-99

    SeqListInsert(&L, 2, 5);
    SeqListInsert(&L, 3, 13);
    SeqListInsert(&L, 4, 19);
    SeqListInsert(&L, 5, 21);
    SeqListInsert(&L, 6, 37);
    SeqListInsert(&L, 7, 56);
    SeqListInsert(&L, 8, 64);
    SeqListInsert(&L, 9, 75);
    SeqListInsert(&L, 10, 80);
    SeqListInsert(&L, 11, 88);
    SeqListInsert(&L, 12, 92);

    SeqListPrint(L);

    printf("21查找结果：%d\n", Search1(L, 21));
    printf("60查找结果：%d\n", Search2(L, 60,1,L.length));
    
	return 0;
}

在这里插入图片描述

3.3.7二分查找算法的分析：

3.3.7.1使用二叉判定树进行分析：

以这11个元素为实例：在这里插入图片描述
我们将每次查找的元素下标放在二叉树中的对应位置
（下半区间的元素放在左子树中，上半区间的元素放在右子树中）

则分析结果如图所示：
在这里插入图片描述
得到结论：二分查找的时间复杂度为O(logn)

3.3.7.2二分查找的平均查找长度：（成功时）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.4线性表的分块查找（了解）

分块查找-----为索引查找的一种方法，广泛应用于数据库中：

分块查找的特征：

  • 块内无序
  • 块间有序
    在这里插入图片描述
    查找效率与优缺点分析如下：
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
float_com
关注
专栏目录
算法【线性表的查找-顺序查找】
huajian225的博客
02-26 514
顺序查找 应用范围 顺序表的表示 数据元素类型定义 查找算法示例分析 时间效率分析 如何提高查找效率
数据结构与算法--线性表的查找
SONG_YIH的博客
08-17 2076
一、查找的基本概念 1) 查找表: 查找表是由同一类型的数据元素(或记录)构成的集合 2) 由于集合中的数据元素之间存在着松散的关系，因此查找表是一种应用灵便的结构 3) 查找: 根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素或(记录) // 关键字: 用来标识一个数据元素(或记录)的某个数据项的值 // 主关键字: 可唯一标识一个记录的关键字是主关键字(身份证号--唯一)...
线性表的查找算法-C语言
小北的博客
12-05 6866
了解查找的基本概念，理解顺序查找、折半查找和分块查找的思想，掌握折半查找过程的判定树构造方法，实现线性表的查找算法。
数据结构与算法总结——线性表
sinat_39377093的博客
07-22 1779
数据结构与算法之线性表
数据结构与算法--线性表查找
wumingzei的博客
08-16 1014
顺序表、有序表和索引表的查找方法。各种查找方法的优点、缺点和适用范围。
C语言算法之线性表查找
墨城烟柳ベ旧人殇的博客
05-21 1197
新星计划：数据结构与算法，学习笔记，创作打卡2！本文主要是最简单的几种针对线性表的查找算法。
线性表查找法 -- 分块查找算法
funan_315的博客
05-03 872
对于线性表中的顺序查找及折半查找分析的优缺点，引出分块查找方法，且查询平均长度介于它两之间。并清晰介绍了分块查找的算法思路及优缺点。
数据结构与算法系列--线性表
2302_77343936的博客
10-01 578
针对顺序表的缺点，一种改进的思路是让相邻元素间留有足够的余地，即所有的元素都不考虑相邻的位置，哪里有空位就空到哪里，而只是让每个元素都知道它下一个元素在哪儿就可以了，这样，假设我们在表中的第一个元素，我们便知道了第二个元素的内存地址，在第二个元素，知道第三个元素的内存地址，依此类推，通过遍历的形式便可以找到所有元素的内存地址。这种思想便是线性表链式存储结构建立的前提。1.线性链表:采用链式存储结构的线性表。
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
查找——线性表之折半查找与分块查找
Blusher1的博客
07-09 515
本篇文章主要介绍线性表中的折半查找与分块查找算法，以及三种查找方法的比较。
《数据结构与算法》课程上机实验一（线性表）_C++_数据结构与算法_线性表_
10-03
在IT领域，数据结构与算法是计算机科学的基础，它们直接影响到程序的效率和设计。本实验聚焦于“线性表”，一种基础且重要的数据结构，它在编程中扮演着核心角色。线性表是由n（n>=0）个相同类型元素构成的有限序列...
数据结构与算法－线性表顺序存储及其相关算法 定义线性表节点的结构.pdf
04-18
本资源主要介绍了线性表顺序存储的概念和相关算法，包括顺序表的优缺点、插入、删除、定位等操作的实现和分析。 1. 顺序表的优点包括：不需要为表示结点间的逻辑关系增加额外存储空间，可以方便地随机存取表中的...
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现
青山师
11-04 1484
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现。
数据结构-链表【chapter1】【c语言版】
qq_63152518的博客
11-03 1163
在某些实现中，链表还可能包含一个指向最后一个节点的指针，以便于在尾部插入节点时提高效率。的指针，通常用于传递指针的地址，以便在函数内可以修改这个指针的值。在链表的实现中，使用。来传递指向头指针的地址，这样就可以在函数内部修改头指针的值。：一个变量，它存储另一个变量的地址。如果链表为空，头指针为NULL。：一个指向指针的指针。：链表通常有一个头指针，指向链表的第一个节点。
【数据结构与算法】第8课—数据结构之二叉树(堆)
weixin_70620792的博客
11-02 854
树是一种非线性的数据结构，它是由n(n>=0)个有限节点组成一个具有层次关系的集合，一般是树根朝上，树叶朝下树有一个特殊的节点，叫做根节点，根节点没有前驱节点树的根节点下面又有很多子节点，但是这些子节点是不相交的除根节点外，每棵子树的根节点有且只有一个前驱，但是可以有0个或多个后继，因此，树是递归定义的。
开放寻址法、链式哈希数据结构详细解读
最新发布
m0_61840987的博客
11-06 895
开放寻址法在低负载因子时效率较高，而链式哈希在高负载因子下表现更稳定。
算法中使用的数据结构解释*
qq_24428851的博客
11-03 716
***数据框架术****语****在这篇文章中，我们将研究在DataFrame背景下使用的一些术语。****作为一个组，多个轴被称为轴。*****选择列******行的选择*****让我们仔细看一下它们各自的情况。****列的选择：******[图片上传失败...(image-fae2e6-1667467474168)]******还有一个名为红色的集合，它包含红色的东西****这两个集合有一些共同的东西。******[图片上传失败...(image-b73e45-1667467474168)]****
数据结构模拟题[十]
mufengzhiyu666的博客
11-03 1005
3． 设关键字序列 (k 1， k2，, ， kn-1 ) 是堆，设计算法将关键字序列 (k 1，k 2，, ， kn-1，x) 调整为堆。12. 设有向图 G中的有向边的集合 E={<1，2>，<2，3>，<1，4>，<4，5>，<5，3>，<4，6>，<6，5>} ，则。12. 设一组初始记录关键字序列为 (Q，H，C，Y ，P，A，M ，S，R，D，F，X) ，则按字母升序的第一趟冒。8. 设一组权值集合 W=(15，3，14，2，6，9，16，17) ，要求根据这些权值集合构造一棵哈夫曼树，则这。
数据结构------链表（Java语言描述）
2402_82356599的博客
10-31 380
链表是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针（在双向链表中还有指向前一个节点的指针）。
查找表的概念与线性表查找算法
"本文档介绍了查找表的基本概念和在数据结构中的应用，特别是线性表的查找算法，包括顺序查找和折半查找。此外，还提到了查找表的定义、查找成功的条件以及查找效率的衡量指标——平均查找长度。" 在计算机科学中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值