27 查找算法

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量108 收藏
点赞数 1
分类专栏： # C语言 文章标签： 算法 数据结构 链表 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62213357/article/details/128945418
版权

【例】顺序查找

顺序查找又称线性查找，它对于顺序表和链表都是适用的。对于顺序表，可通过数组下标递增来顺序扫描每个元素；对于链表，则通过指针 next 来依次扫描每个元素

于前面咱们已经实战了顺序表用数组实现，现在我们实战顺序表用指针，也就是申请一个堆空间，使用方式和数组还是一致的

#include <cstdio>
#include <cstdlib>
#include <ctime>

typedef int ElemType;
typedef struct{
    ElemType* elem;//整型指针
    int TableLen;//存储动态数组里面元素的个数
}SSTable;

int Search_Seq(SSTable ST,ElemType key)
{
    ST.elem[0]=key;//让零号元素作为哨兵
    int i;
    for(i=ST.TableLen-1;ST.elem[i]!=key;--i);
    return i;
}

//init进行了随机数生成，随机数生成考研不会考
void ST_Init(SSTable& ST,int len)
{
    //多申请了一个位置，为了存哨兵，不使用哨兵也可以，为了和王道书保持一致
    ST.TableLen=len+1;
    ST.elem=(ElemType*) malloc(sizeof(ElemType)*ST.TableLen);
    int i;
    srand(time(NULL));//随机数生成
    for(i=1;i<ST.TableLen;i++)//因为第0个是哨兵，所以从1随机
    {
        ST.elem[i]=rand()%100;
    }
}
void ST_print(SSTable ST)
{
    for(int i=0;i<ST.TableLen;i++)
    {
        printf("%3d",ST.elem[i]);
    }
    printf("/n");
}

int main()
{
    SSTable ST;
    ElemType key;
    int pos;//存储查询元素的位置
    ST_Init(ST,10);
    ST_print(ST);
    printf("请输入要搜索的key值：\n");
    scanf("%d",&key);
    pos= Search_Seq(ST,key);
    if(pos)
    {
        printf("查找成功 位置为%d\n",pos);
    } else{
        printf("查找失败\n");
    }
    return 0;
}

【例】折半查找

折半查找又称二分查找，它仅适用于有序的顺序表。

针对顺序表有序，使用 qsort 来排序，

qsort 的使用方法如下：

#include <stdlib.h>
void qsort( void *buf, size_t num, size_t size, int (*compare)(const void *, const void *) );

buf:要排序数组的起始地址，也可以是指针，申请了一块连续的堆空间

num：数组中元素的个数

size：数组中每个元素所占用的空间大小

compare:比较规则，需要我们传递一个函数名，这个函数由我们自己编写，

返回值必须是 int 类型，形参是两个 void 类型指针，这个函数我们编写，但是是qsort 内部调用的，相当于我们传递一种行为给 qsort。

代码流程:

  1. 我们初始化顺序表，随机 10 个元素

  1. 使用 qsort 进行排序，排序完毕后，打印

  1. 输入要查找的元素值，存入变量 key 中

  1. 通过二分查找查找对应 key 值，找到则输出在顺序表中的位置，没找到输出未找到

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

typedef int ElemType;

typedef struct {
    ElemType* elem;//整型指针
    int TableLen;//存储动态数组里边元素的个数
}SSTable;

//init 进行了随机数生成，折半查找我们没有使用哨兵
void ST_Init(SSTable& ST, int len)
{
    ST.TableLen = len;
    ST.elem = (ElemType*)malloc(sizeof(ElemType) * ST.TableLen);
    int i;
    srand(time(NULL));//随机数生成
    for (i = 0; i < ST.TableLen; i++)
    {
        ST.elem[i] = rand() % 100;
    }
}

void ST_print(SSTable ST)
{
    for (int i = 0; i < ST.TableLen; i++)
    {
        printf("%3d", ST.elem[i]);
    }
    printf("\n");
}

//时间复杂度 logn
int BinarySearch(SSTable L, ElemType key)
{
    int low = 0, high = L.TableLen - 1, mid;
    while (low <= high)
    {
        mid = (low + high) / 2;
        if (L.elem[mid] == key)
            return mid;//等于就找到了
        else if (L.elem[mid] > key)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return -1;
}

int compare(const void* left, const void* right)//left，right 是任意两个元素的地址值
{
    return *(ElemType*)left - *(ElemType*)right;
//return *(ElemType*)right - *(ElemType*)left;//从大到小
}

//顺序查找 与 折半查找
int main()
{
    SSTable ST;
    ElemType key;
    int pos;//存储查询元素的位置
    ST_Init(ST, 10);
    qsort(ST.elem, ST.TableLen, sizeof(ElemType), compare);//qsort 实现的是快排
    ST_print(ST);
    printf("二分查找，请输入要搜索的 key 值:\n");
    scanf("%d", &key);
//有序数组
    pos = BinarySearch(ST, key);//二分查找，也叫折半查找
    if (pos != -1)
    {
        printf("查找成功 位置为 %d\n", pos);
    }
    else {
        printf("查找失败\n");
    }
    return 0;
}

【例】二叉排序树

二叉排序树（也称二叉查找树）或者是一棵空树，或者是具有下列特性的二叉树：

1）若左子树非空，则左子树上所有结点的值均小于根结点的值。

2）若右子树非空，则右子树上所有结点的值均大于根结点的值。

3）左、右子树也分别是一棵二叉排序树。

步骤：首先我们新建了一颗二叉排序树，使用的是非递归的方法新建，当然递归的代码也给出了，不过注释了。然后针对建好的二叉排序树进行了中序遍历输出，接着对二叉排序树进行查找，我们可以看到二叉排序树的最大查找次数是树的高度。

#include <stdio.h>
#include <stdlib.h>
typedef int KeyType;
typedef struct BSTNode{
    KeyType key;
    struct BSTNode *lchild,*rchild;
}BSTNode,*BiTree;
//54,20,66,40,28,79,58
// 王道书上的递归写法，代码简单，但是理解有难度
//int BST_Insert(BiTree &T,KeyType k)
//{
// if(NULL==T)
// { //为新节点申请空间，第一个结点作为树根，后面递归再进入的不是树根，是为叶子结点
// T=(BiTree)malloc(sizeof(BSTNode));
// T->key=k;
// T->lchild=T->rchild=NULL;
// return 1;//代表插入成功
// }
// else if(k==T->key)
// return 0;//发现相同元素，就不插入
// else if(k<T->key)//如果要插入的结点，小于当前结点
// //函数调用结束后，左孩子和原来的父亲会关联起来，巧妙利用了引用机制
// return BST_Insert(T->lchild,k);
// else
// return BST_Insert(T->rchild,k);
//}
//54,20,66,40,28,79,58
int BST_Insert(BiTree& T, KeyType k)
{
    if (NULL == T)
    { //为新节点申请空间，第一个结点作为树根，T 是树根
        T = (BiTree)malloc(sizeof(BSTNode));
        T->key = k;
        T->lchild = T->rchild = NULL;
        return 1;//代表插入成功
    }
    BiTree p = T,parent;//p 用来遍历,parent 用来存 p 的父亲
    while (p)
    {
        parent = p;
        if (k == p->key)
        {
            return 0;
        }
        else if (k < p->key)
        {
            p = p->lchild;
        }
        else {
            p = p->rchild;
        }
    }
//开始申请空间并插入
    BiTree pnew = (BiTree)malloc(sizeof(BSTNode));
    pnew->key = k;
    pnew->lchild = pnew->rchild = NULL;
    if (k > parent->key)
    {
        parent->rchild = pnew;//新结点在父亲的右边
    }
    else {
        parent->lchild = pnew;//新结点在父亲的左边
    }
}
//创建二叉排序树
void Creat_BST(BiTree &T,KeyType str[],int n)
{
    T=NULL;//T 是树根
    int i=0;
    while(i<n)
    {
        BST_Insert(T,str[i]);//把某一个结点放入二叉查找树
        i++;
    }
}
//也可以用递归实现，只不过循环查找已经非常简单清晰，用递归必要性不强
BSTNode *BST_Search(BiTree T,KeyType key,BiTree &p)
{
    p=NULL;//存储要找的结点的父亲
    while(T!=NULL&&key!=T->key)
    {
        p=T;
        if(key<T->key) T=T->lchild;//比当前节点小，就左边找
        else T=T->rchild;//比当前节点大，右边去
    }
    return T;
}
void InOrder(BiTree T)
{
    if(T!=NULL)
    {
        InOrder(T->lchild);
        printf("%3d",T->key);
        InOrder(T->rchild);
    }
}
//二叉排序树的创建，中序遍历，查找，删除
int main()
{
    BiTree T=NULL;//树根
    BiTree parent;//存储父亲结点的地址值
    BiTree search;
    KeyType str[7]={54,20,66,40,28,79,58};//将要进入二叉排序树的元素值
    Creat_BST(T,str,7);
    InOrder(T);
    printf("\n");
    search=BST_Search(T,40,parent);
    if(search)
    {
        printf("找到对应结点，值=%d\n",search->key);
    }else{
        printf("未找到对应结点\n");//没找到 search 返回的是 NULL
    }
    return 0;
}

【例】二叉排序树删除

#include <cstdio>
#include <cstdlib>

typedef int KeyType;
typedef struct BSTNode{
    KeyType key;
    struct BSTNode *lchild,*rchild;
}BSTNode,*BiTree;
//54,20,66,40,28,79,58
// 王道书上的递归写法，代码简单，但是理解有难度
//int BST_Insert(BiTree &T,KeyType k)
//{
// if(NULL==T)
// { //为新节点申请空间，第一个结点作为树根，后面递归再进入的不是树根，是为叶子结点
// T=(BiTree)malloc(sizeof(BSTNode));
// T->key=k;
// T->lchild=T->rchild=NULL;
// return 1;//代表插入成功
// }
// else if(k==T->key)
// return 0;//发现相同元素，就不插入
// else if(k<T->key)//如果要插入的结点，小于当前结点
// //函数调用结束后，左孩子和原来的父亲会关联起来，巧妙利用了引用机制
// return BST_Insert(T->lchild,k);
// else
// return BST_Insert(T->rchild,k);
//}
//54,20,66,40,28,79,58

int BST_Insert(BiTree& T, KeyType k)
{
    if (NULL == T)
    { //为新节点申请空间，第一个结点作为树根，T 是树根
        T = (BiTree)malloc(sizeof(BSTNode));
        T->key = k;
        T->lchild = T->rchild = NULL;
        return 1;//代表插入成功
    }
    BiTree p = T,parent;//p 用来遍历,parent 用来存 p 的父亲
    while (p)
    {
        parent = p;
        if (k == p->key)
        {
            return 0;
        }
        else if (k < p->key)
        {
            p = p->lchild;
        }
        else {
            p = p->rchild;
        }
    }
//开始申请空间并插入
    BiTree pnew = (BiTree)malloc(sizeof(BSTNode));
    pnew->key = k;
    pnew->lchild = pnew->rchild = NULL;
    if (k > parent->key)
    {
        parent->rchild = pnew;//新结点在父亲的右边
    }
    else {
        parent->lchild = pnew;//新结点在父亲的左边
    }
}
//创建二叉排序树
void Creat_BST(BiTree &T,KeyType str[],int n)
{
    T=NULL;//T 是树根
    int i=0;
    while(i<n)
    {
        BST_Insert(T,str[i]);//把某一个结点放入二叉查找树
        i++;
    }
}
//也可以用递归实现，只不过循环查找已经非常简单清晰，用递归必要性不强
BSTNode *BST_Search(BiTree T,KeyType key,BiTree &p)
{
    p=NULL;//存储要找的结点的父亲
    while(T!=NULL&&key!=T->key)
    {
        p=T;
        if(key<T->key) T=T->lchild;//比当前节点小，就左边找
        else T=T->rchild;//比当前节点大，右边去
    }
    return T;
}
//这个书上没有二叉排序树删除代码--考大题没那么高
void DeleteNode(BiTree &root,KeyType x){
    if(root == NULL){
        return;
    }
    if(root->key>x){
        DeleteNode(root->lchild,x);//往左子树找要删除的结点
    }else if(root->key<x){
        DeleteNode(root->rchild,x);//往右子树找要删除的结点
    }else{ //查找到了删除节点
        if(root->lchild == NULL){ //左子树为空，右子树直接顶上去
            BiTree tempNode = root;//用临时的存着的目的是一会要 free
            root = root->rchild;
            free(tempNode);
        }else if(root->rchild == NULL){ //右子树为空，左子树直接顶上去
            BiTree tempNode = root;//临时指针
            root = root->lchild;
            free(tempNode);
        }else{ //左右子树都不为空
//一般的删除策略是左子树的最大数据 或 右子树的最小数据 代替要删除的节点(这里采用查找左子树最大数据来代替)
            BiTree tempNode = root->lchild;
            while(tempNode->rchild!=NULL){//向右找到最大的
                tempNode = tempNode->rchild;
            }
            root->key = tempNode->key;//把 tempNode 对应的值替换到要删除的值的位置上
            DeleteNode(root->lchild,tempNode->key);//删除 tempNode
        }
    }
}
void InOrder(BiTree T)
{
    if(T!=NULL)
    {
        InOrder(T->lchild);
        printf("%3d",T->key);
        InOrder(T->rchild);
    }
}
//二叉排序树的创建，中序遍历，查找，删除
int main()
{
    BiTree T=NULL;//树根
    BiTree parent;//存储父亲结点的地址值
    BiTree search;
    KeyType str[7]={54,20,66,40,28,79,58};//将要进入二叉排序树的元素值
    Creat_BST(T,str,7);
    InOrder(T);
    printf("\n");
    search=BST_Search(T,40,parent);
    if(search)
    {
        printf("找到对应结点，值=%d\n",search->key);
    }else{
        printf("未找到对应结点\n");//没找到 search 返回的是 NULL
    }
    DeleteNode(T,40);//删除某个结点
    InOrder(T);
    printf("\n");
    return 0;
}
orientation750
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法二十七：子序列
闲狗的博客
07-04 3116
描述 给定一个字符串，求出该字符串有多少不同的子序列。 子序列：字符串中按顺序抽出一些字符得到的串。比如字符串abcd里，ab、ac、ad、abc、acd都是子序列。 输入 输入一个字符串。 输出 输出不同的子序列的个数除以23333得到的余数。 样例输入 ababc 样例输出 23 样例解释 有这些子序列： a，b，c，aa，ab，ac，ba，bb，bc，aba...
算法()-最大、括号
sinat_40624829的博客
09-13 394
考虑所有的删除情况，采用广度优先，第一层为原字符串表达式，第二层为删除一个字符，第三层为删除两个字符的情况，不断广度优先遍历，直至找到第一个有效的删除数量，即为最少数量。给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…dp[i] 表示以下标 i字符结尾的最长有效括号的长度,（以s[i]结尾能构成的有效字符串的长度）依据s[i] 与之前的括号的配对情况，更行dp数组。遍历完字符串，查看栈是否为空，空则有效，非空，无效。
【愚公系列】2021年12月 Python教学课程 27-算法
热门推荐
时光隧道
12-16 3万+
文章目录一、算法的概念二、算法效率衡量 一、算法的概念 算法是计算机处理信息的本质，计算机程序本质上是通过一个算法来告诉计算机确切的步骤，来执行一个指定的任务。 算法是独立存在的一种解决问题的方法和思想。 对于算法而言，实现的语言并不重要，重要的是思想。 算法可以有不同的语言描述实现版本（如 C 描述、C++描述、Python 描述等），我们现在是在用 Python 语言进行描述实现。 算法的五大特性 输入: 算法具有 0 个或多个输入 输出: 算法至少有 1 个或多个输出 有穷性: 算法在有限的步骤之
数据结构与算法27
boximiayu的博客
05-05 119
Leecode100 题目 给定两个二叉树，编写一个函数来检验它们是否相同。 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 分析 这道题，题目描述佷短，首先，给了条件是两个二叉树，要求是写出代码实现将两棵树比较并返回出是否相同。这佷明显就用递归实现。 解法 根据分析，通过递归实现。通过判断两结点是否相同和其左右子树是否相同来实现递归。 public class Solutio...
C语言 FBI树
u013545389的专栏
02-08 1845
算法训练 FBI树   时间限制：1.0s   内存限制：256.0MB        问题描述 　　我们可以把由“0”和“1”组成的字符串分为三类：全“0”串称为B串，全“1”串称为I串，既含“0”又含“1”的串则称为F串。 　　FBI树是一种二叉树，它的结点类型也包括F结点，B结点和I结点三种。由一个长度为2N的“01”串S可以构造出一棵FBI树T，递归的构造
数学推导+纯Python实现机器学习算法27：LDA线性判别分析
weixin_37737254的博客
06-14 1236
Python机器学习算法实现Author：louwillMachine Learning Lab 线性判别分析（Linear Discriminant Analysis，...
路由查找算法
03-10
自己做的路由查找算法ppt，上课用。主要从四个方面总结，1.Internet地址结构的发展2. 路由查找算法3. 路由查找算法的评价4. 相关进展
Java实现的快速查找算法示例
08-29
Java实现的快速查找算法示例 Java实现的快速查找算法示例是指通过Java语言实现的快速查找算法，旨在解决查找问题的高效解决方案。快速查找算法是指在一个数组中查找第k个大的数的算法，通过将数组分成两部分，左边...
二分查找算法
01-15
二分查找算法 二分查找算法是一种高效的查找算法，适用于已经排好序的数组或链表中查找特定的元素。该算法的时间复杂度为O(log n)，远远优于顺序查找算法的O(n)。 二分查找算法的基本思想是将数组或链表分成两个...
sjjg.rar_查找算法
09-24
在IT领域，查找算法是计算机科学中的核心概念之一，它涉及到如何在数据集合中寻找特定元素。本实验“sjjg.rar_查找算法”聚焦于数据结构与算法的实践应用，特别是查找算法的实现。这个压缩包包含了相关课程资料和...
查找算法1
08-08
查找算法是计算机科学中至关重要的一类算法，它们用于在数据集合中寻找特定的元素或信息。在本讨论中，我们将深入探讨查找算法的基本概念、时间复杂度以及几种常见的查找算法。 首先，查找算法的核心在于“关键字”...
算法27-----第N个数字
weixin_33922670的博客
09-05 233
1、题目： 在无限的整数序列1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...中找到第n个数字。 注意: n是正数且在32为整形范围内(n < 231)。 示例 1: 输入: 3 输出: 3 示例 2: 输入: 11 输出: 0 说明: 第11个数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9,...
算法导论--以KMP实现的字符串匹配
x13262608581的博客
05-04 297
以KMP实现的字符串匹配 性质 给定模式集合，和源集合。 算法输出源集合中和模式匹配的所有相关处的起始位置。 接口设计 template<typename T> class CharacterMatch { public: CharacterMatch(); ~CharacterMatch(); public: DataStruct::Array::DynArray<in...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 852
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
cf场+线性dp
xxx_jsu的博客
07-23 306
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 152
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 246
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 493
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 241
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
哈希表与查找算法解析
"第九章 查找 数据结构中的查找算法详解" 在计算机科学中，查找算法是数据处理的关键技术之一，主要用于在数据结构中寻找特定信息。本节主要关注数据结构中的查找表及其相关操作。查找表是由同一类型数据元素或记录...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值