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

news2024/11/26 7:44:05

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线性表的分块查找（了解）

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

分块查找的特征：

  • 块内无序
  • 块间有序
    在这里插入图片描述
    查找效率与优缺点分析如下：
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

selenium的webdriver常用方法和属性介绍(2)

selenium的webdriver常用方法和属性介绍(2)

selenium的webdriver介绍 从selenium导入webdriver模块&#xff0c;在pycharm中跳转webdriver模块的__init__.py文件&#xff0c;内容如图所示&#xff1a;从selenium包的子目录中导入了很多模块并做了重命名&#xff0c;用于支持如下 Chrome/Edge/Ie/Firefox/Safari浏览器。 使…
阅读更多...
基于深度学习的多焦点图像融合系统【数据集+深度学习模型+源码+PyQt5界面】

基于深度学习的多焦点图像融合系统【数据集+深度学习模型+源码+PyQt5界面】

深度学习多焦点聚焦图像融合 文章目录 研究背景代码下载链接一、效果演示1.1 界面设计1.2 图像融合演示11.3 图像融合演示21.4 图像融合演示3 二、技术原理2.1 引言2.2 融合策略2.3 深度特征的提取2.4 融合策略2.4.1 利用深度特征计算模糊度2.4.2 去噪与平滑2.4.3 图像融合 三、…
阅读更多...
计算机网络——p2p

计算机网络——p2p

流媒体是指在网络上以流式传输技术实时播放的多媒体内容&#xff0c;如音频、视频等。以下是关于流媒体的详细介绍&#xff1a; 一、工作原理 数据分割与传输&#xff1a; 流媒体技术将多媒体文件分割成较小的数据包。这些数据包按照特定的顺序进行编号&#xff0c;然后通过网络…
阅读更多...
Luminar激光雷达公司裁员重组的深度分析

Luminar激光雷达公司裁员重组的深度分析

在科技行业风起云涌的今天，每一家企业都面临着前所未有的挑战与机遇。当地时间9月23日，美国激光雷达领域的领军企业Luminar Technologies向美国证券交易委员会（SEC）提交了一份8-K报告，正式宣布了一项重大的业务重组计划，其核心内容是通过进一步裁员来优化成本结构，以期在…
阅读更多...
【英语】3. 词源

【英语】3. 词源

文章目录 前言动词变名词解释e.g. 一、词根二、介词短语spect/spec: means see, look 合成词三、介词本身的意思总结参考文献 前言 进行英语前后缀的复习 动词变名词 解释 外国的表达方式&#xff1a;更多地偏向静态&#xff0c;因此更多地使用名词 e.g. (rather Chinglish…
阅读更多...
【数据结构与算法】排序算法

【数据结构与算法】排序算法

3.7 排序算法 概述 比较排序算法 算法最好最坏平均空间稳定思想注意事项冒泡O(n)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)Y比较最好情况需要额外判断选择O( n 2 n^2 n2)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)N比较交换次数一般少于冒泡堆O( n l o g n nlogn nlogn)O( n l o g n nlogn …
阅读更多...
【Linux】认识Linux内核中进程级别的文件结构体【files_struct】＆文件IO模型初步演示

【Linux】认识Linux内核中进程级别的文件结构体【files_struct】＆文件IO模型初步演示

前言 大家好吖&#xff0c;欢迎来到 YY 滴 系列 &#xff0c;热烈欢迎&#xff01; 本章主要内容面向接触过C的老铁 主要内容含&#xff1a; 欢迎订阅 YY滴C专栏&#xff01;更多干货持续更新&#xff01;以下是传送门&#xff01; YY的《C》专栏YY的《C11》专栏YY的《Linux》…
阅读更多...
高效医疗：Spring Boot医院管理解决方案

高效医疗：Spring Boot医院管理解决方案

1系统概述 1.1 研究背景 如今互联网高速发展&#xff0c;网络遍布全球&#xff0c;通过互联网发布的消息能快而方便的传播到世界每个角落&#xff0c;并且互联网上能传播的信息也很广&#xff0c;比如文字、图片、声音、视频等。从而&#xff0c;这种种好处使得互联网成了信息传…
阅读更多...
算法题总结（十一）——二叉树下

算法题总结（十一）——二叉树下

257、二叉树的所有路径 给你一个二叉树的根节点 root &#xff0c;按 任意顺序 &#xff0c;返回所有从根节点到叶子节点的路径。 叶子节点 是指没有子节点的节点。 示例 1&#xff1a; 输入&#xff1a;root [1,2,3,null,5] 输出&#xff1a;["1->2->5",&…
阅读更多...
【设计模式】软件设计原则——依赖倒置合成复用

【设计模式】软件设计原则——依赖倒置合成复用

依赖倒置引出 依赖倒置 定义&#xff1a;高层模块不应该依赖低层模块&#xff0c;二者都应该依赖抽象&#xff1b;抽象不应该依赖细节&#xff0c;细节应该依赖抽象。面向接口编程而不是面向实现编程。 通过抽象使用抽象类、接口让各个类or模块之间独立不影响&#xff0c;实现…
阅读更多...
Charles安卓抓包环境配置

Charles安卓抓包环境配置

下载安装Charles 官网搜索然后直接下载就可以了 抓HTTP的包 HTTP代理 在Proxy->Proxy Settings里配置HTTP代理 手机上配置代理 进入WIFI&#xff0c;找到连接的网络&#xff0c;打开高级选项&#xff0c;里面有一个代理选项&#xff0c;将其改为手动&#xff0c;然后…
阅读更多...
＜＜机器学习实战＞＞12-14节笔记：机器学习模型可信度、逻辑回归模型及多分类问题处理

＜＜机器学习实战＞＞12-14节笔记：机器学习模型可信度、逻辑回归模型及多分类问题处理

12机器学习模型可信度 是否检验模型的指标好就一定说明模型可用&#xff1f;不是&#xff0c;必须得保证训练的样本和整天基本满足同一分布。 统计学习和机器学习区别&#xff1a;统计学习是根据样本模拟总体规律进而去预测&#xff08;当然要比对样本和总体的统计量是否一致&…
阅读更多...
Bloom Filter 布隆过滤器

Bloom Filter 布隆过滤器

目录 简介 Bloom Filter的基本原理 实现 使用 HashFunc越多&#xff0c;性能越好吗&#xff1f; 如何尽量避免误判&#xff1f; 应用 布隆过滤器优点 简介 Bloom Filter是一种空间效率极高的概率数据结构&#xff0c;它用于测试一个元素是否属于集合。Bloom Filter的优…
阅读更多...
wc命令：统计文本行数、单词数、字节数

wc命令：统计文本行数、单词数、字节数

一、命令简介 ​wc​&#xff08;word count&#xff09;是一个在类 Unix 系统中常用的命令行工具&#xff0c;用于统计文本文件的 行数​、单词数 ​和 字节数​。 ​​ ‍ 二、命令参数 ​wc​ 命令的基本语法如下&#xff1a; wc [选项] 文件选项&#xff1a; ​-c​…
阅读更多...
Spring Validation 参数校验框架

Spring Validation 参数校验框架

目录 一.Maven依赖 二.参数校验 常用注解 1.Body参数校验 2.Params参数校验 2.1.Query参数校验 2.2.Path参数校验 三.全局异常处理器捕获校验异常 四.分组校验 1.分组校验 2.案例 2.1.登录 2.2.注册 五.嵌套校验 六.集合校验 七.自定义校验 八.快速失败(Fail …
阅读更多...
全球IP归属地查询-IP地址查询-IP城市查询-IP地址归属地-IP地址解析-IP位置查询-IP地址查询API接口-IP查询城市-IP解析城市

全球IP归属地查询-IP地址查询-IP城市查询-IP地址归属地-IP地址解析-IP位置查询-IP地址查询API接口-IP查询城市-IP解析城市

IP地址查询接口是指能够返回IP地址相关信息的网络接口&#xff0c;其返回的信息通常包括IP地址的归属地&#xff08;如国家、省份、城市等&#xff09;、运营商信息以及其他技术细节。以下是一些常见的IP地址查询接口及其特点&#xff1a; 一、国内IP地址查询接口 百度IP地址查…
阅读更多...
Burp Suite为何能抓到HTTPS的明文流量，Wireshark可以吗，公司电脑的加密流量也是被监控了吗？

Burp Suite为何能抓到HTTPS的明文流量，Wireshark可以吗，公司电脑的加密流量也是被监控了吗？

在前期博文《万字图文详解HTTPS协议通信过程&#xff0c;结合抓包实战解析带你一次看透HTTPS&#xff01;》中&#xff0c;我们知悉HTTPS通信内容是用会话密钥加密的&#xff0c;但不少细心的读者存在疑问&#xff1a;为何对于使用HTTPS协议的站点&#xff0c;在Burp Suite中拦…
阅读更多...
5.人员管理模块(以及解决运行Bug)——帝可得管理系统

5.人员管理模块(以及解决运行Bug)——帝可得管理系统

目录 前言一、页面修改表单展示修改 二、新增对话框修改三、修改对话框修改修改时展示创建时间 四、解决页面展示错误五 、 解决【java.lang.NullPointerException: null】 Bug 前言 提示&#xff1a;本篇完成人员管理模块的开发&#xff0c;具体需求、修改代码的路径和最终效…
阅读更多...
2024年国庆节有哪些必囤的好物？搜罗到了五款超实用的数码好物！

2024年国庆节有哪些必囤的好物？搜罗到了五款超实用的数码好物！

​今年国庆节好多商家推出了一系列促销的活动&#xff0c;以庆祝这一重要节日。在这举国欢腾的日子里&#xff0c;除了享受假期带来的闲暇时光&#xff0c;也是时候犒劳一下自己&#xff0c;添置一些实用的数码用品了。为此&#xff0c;我特别为您搜罗到了五款超实用的数码好物…
阅读更多...
考研笔记之操作系统（四） - 文件管理

考研笔记之操作系统（四） - 文件管理

文件管理 1. 简介1.1 前情回顾1.2 文件的属性1.3 文件内部数据的组织方式1.4 操作系统向上提供的文件功能1.5 文件应如何放在外存 2. 文件的逻辑结构2.1 无结构文件2.2 有结构文件2.2.1 顺序文件2.2.2 索引文件2.2.3 索引顺序文件2.2.4 多级索引顺序文件 3. 文件目录3.1 基本概…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023