查找算法总结

最新推荐文章于 2022-09-14 19:38:24 发布
最新推荐文章于 2022-09-14 19:38:24 发布
阅读量74 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 hash 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43812167/article/details/113788767
版权

查找算法总结


顺序查找初始版： 

#include <iostream>
using namespace std;
int Sequential_Search(int* array, int n, int key)
{
    int i;
    for(i = 0; i < n; i++)
    {
        if(array[i] == key)
        {
            return i;
        }
    }
    return -1;
}

int main()
{
    int array[] = {9, 3, 7, 2, 6};
    if(Sequential_Search(array, 5, 6) >= 0)
    {
        cout << "找到了" << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }
}

在这里插入图片描述

优化版：

#include <iostream>
using namespace std;
int Sequential_Search(int* array, int n, int key)
{
    int i = n;
    array[0] = key;
    while (array[i] != key)
    {
        i--;
    }
    return i;
}

int main()
{
    int array[] = {-1, 9, 3, 7, 2, 6};
    if(Sequential_Search(array, 5, 9) > 0)
    {
        cout << "找到了" << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }
}

在这里插入图片描述
参考资料：大话数据结构：297

折半查找：

#include <iostream>
using namespace std;
int Binary_Search(int* array, int n, int key)
{
    int low, high, mid;
    low = 0;
    high = n - 1;
    while(low <= high)
    {
        mid = (low + high) / 2;
        if(key < array[mid])
        {
            high = mid - 1;
        }
        else if(key > array[mid])
        {
            low = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

int main()
{
    int array[] = {2, 7, 9, 11, 18, 32, 97, 101};
    if(Binary_Search(array, 8, 16) >= 0)
    {
        cout << "找到了" << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }
}

在这里插入图片描述
折半查找需要一个有序的序列所以，直接给了一个有序的数组

插值查找：

#include <iostream>
using namespace std;
int Binary_Search(int* array, int n, int key)
{
    int low, high, mid;
    low = 0;
    high = n - 1;
    while(low <= high)
    {
        mid = low + (high - low) * (key -array[low]) / (array[high] - array[low]);
        if(key < array[mid])
        {
            high = mid - 1;
        }
        else if(key > array[mid])
        {
            low = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

int main()
{
    int array[] = {2, 7, 9, 11, 18, 32, 97, 101};
    if(Binary_Search(array, 8, 9) >= 0)
    {
        cout << "找到了" << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }
}

在这里插入图片描述
参考资料：大话数据结构：302

斐波那契查找：

#include <iostream>
using namespace std;
const int MAXSIZE = 20;

void Fibonacci(int* F)
{
    F[0] = 0;
    F[1] = 1;
    for(int i = 2; i < MAXSIZE; ++i)
    {
        F[i] = F[i - 1] + F[i - 2];
    }
}

int Fibonacci_Search(int* array, int n, int key)
{
    int low, high, mid, i, k;
    low = 0;
    high = n - 1;
    k = 0;
    int F[MAXSIZE];
    Fibonacci(F);
    while(n > F[k] - 1)
    {
        k++;
    }
    for(i = n; i < F[k] - 1; i++)
    {
        array[i] = array[n];
    }
    while(low <= high)
    {
        mid = low + F[k - 1] - 1;
        if(key < array[mid])
        {
            high = mid - 1;
            k = k - 1;
        }
        else if(key > array[mid])
        {
            low = mid + 1;
            k = k - 2;
        }
        else
        {
            if(mid <= n)
            {
                return mid;
            }
            else
            {
                return n;
            }
        }
    }
    return -1;
}

int main()
{
    int array[20] = {2, 7, 9, 11, 18, 32, 97, 101};
    if(Fibonacci_Search(array, 8, 9) >= 0)
    {
        cout << "找到了" << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }
}

由于算法当找出数组长度在斐波那契数列中的位置时，会再向数组中写东西，所以讲数组的容量设的比较大。

#include <iostream>
using namespace std;

typedef struct BiTNode
{
    int data;
    struct BiTNode* lchild;
    struct BiTNode* rchild;
}BiTNode, *BiTree;

bool SearchBST(BiTree T, int key, BiTree f, BiTree* p)
{
    if(!T)
    {
        *p = f;
        return false;
    }
    else if(key == T->data)
    {
        *p = T;
        return true;
    }
    else if(key < T->data)
    {
        return SearchBST(T->lchild, key, T, p);
    }
    else
    {
        return SearchBST(T->rchild, key, T, p);
    }
}

bool InsertBST(BiTree* T, int key)
{
    BiTree p = nullptr, s = nullptr;
    if(!SearchBST(*T, key, nullptr, &p))
    {
        s = (BiTree)malloc(sizeof(BiTNode));
        s->data = key;
        s->lchild = s->rchild = nullptr;
        if(!p)
        {
            *T = s;
        }
        else if(key < p->data)
        {
            p->lchild = s;
        }
        else
        {
            p->rchild = s;
        }
        return true;
    }
    return false;
}

bool Delete(BiTree *p)
{
    BiTree q, s;
    if((*p)->rchild == nullptr)
    {
        q = *p;
        *p = (*p)->lchild;
        free(q);
    }
    else if((*p)->lchild == nullptr)
    {
        q = *p;
        *p = (*p)->rchild;
        free(q);
    }
    else
    {
        q = *p;
        s = (*p)->lchild;
        while(s->rchild)
        {
            q = s;
            s = s->rchild;
        }
        (*p)->data = s->data;
        if(q != *p)
        {
            q->rchild = s->lchild;
        }
        else
        {
            q->lchild = s->lchild;
        }
        free(s);
    }
    return true;
}

bool DeleteBST(BiTree* T, int key)
{
    if(!*T)
    {
        return false;
    }
    else
    {
        if(key == (*T)->data)
        {
            return Delete(T);
        }
        else if(key < (*T)->data)
        {
            return DeleteBST(&(*T)->lchild, key);
        }
        else
        {
            return DeleteBST(&(*T)->rchild, key);
        }
    }
}

void PrintTree(BiTree tree)
{
    if(tree != nullptr)
    {
        cout << tree->data << endl;
        PrintTree(tree->lchild);
        PrintTree(tree->rchild);
    }
    
}

int main()
{
    int a[10] = {62, 88, 58, 47, 35, 73, 51, 99, 37, 93};
    BiTree T = nullptr;
    for(int i = 0; i < 10; i++)
    {
        InsertBST(&T, a[i]);
    }
    PrintTree(T);
    DeleteBST(&T, 99);
    PrintTree(T);
}

在这里插入图片描述
这里要注意一个细节：Delete函数中的参数p实际上是要删除元素的父元素的lchild或者rchild。

参考资料：大话数据结构327

AVL树：

#include <iostream>
using namespace std;

typedef struct BiTNode
{
    int data;
    int bf;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

void R_Rotate(BiTree *p)
{
    BiTree L;
    L = (*p)->lchild;
    (*p)->lchild = L->rchild;
    L->rchild = (*p);
    *p = L;
}

void L_Rotate(BiTree *p)
{
    BiTree R;
    R = (*p)->rchild;
    (*p)->rchild = R->lchild;
    R->lchild = (*p);
    *p = R;
}

#define LH +1
#define EH 0
#define RH -1
void LeftBalance(BiTree* T)
{
    BiTree L, Lr;
    L = (*T)->lchild;
    switch(L->bf)
    {
        case LH:
            (*T)->bf = L->bf = EH;
            R_Rotate(T);
            break;
        case RH:
            Lr = L->rchild;
            switch(Lr->bf)
            {
                case LH: (*T)->bf = RH;
                        L->bf = EH;
                        break;
                case EH: (*T)->bf = L->bf = EH;
                        break;
                case RH: (*T)->bf = EH;
                        L->bf = LH;
                        break;
            }
            Lr->bf = EH;
            L_Rotate(&(*T)->lchild);
            R_Rotate(T);
    }   
}

void RightBalance(BiTree* T)
{
    BiTree R, Rl;
    R = (*T)->rchild;
    switch (R->bf)
    {
        case RH:
            (*T)->bf = R->bf = EH;
            L_Rotate(T);
            break;
        case LH:
            Rl = R->lchild;
            switch(Rl->bf)
            {
                case LH: (*T)->bf = RH;
                        R->bf = EH;
                        break;
                case EH: (*T)->bf = R->bf = EH;
                        break;
                case RH: (*T)->bf = EH;
                        R->bf = LH;
                        break;
            }
            Rl->bf = EH;
            R_Rotate(&(*T)->rchild);
            L_Rotate(T);
    }
}

bool InsertAVL(BiTree* T, int e, bool* taller)
{
    if(!*T)
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        (*T)->data = e;
        (*T)->lchild = (*T)->rchild = nullptr;
        (*T)->bf = EH;
        *taller = true;
    }
    else
    {
        if(e == (*T)->data)
        {
            *taller = false;
            return false;
        }
        if(e < (*T)->data)
        {
            if(!InsertAVL(&(*T)->lchild, e, taller))
            {
                return false;
            }
            if(taller)
            {
                switch ((*T)->bf)
                {
                case LH:
                    LeftBalance(T);
                    *taller = false;
                    break;
                case EH:
                    (*T)->bf = LH;
                    *taller = true;
                    break;
                case RH:
                    (*T)->bf = EH;
                    *taller = false;
                    break;
                default:
                    break;
                }
            }
        }
        else
        {
            if(!InsertAVL(&(*T)->rchild, e, taller))
            {
                return false;
            }
            if(*taller)
            {
                switch((*T)->bf)
                {
                    case LH:
                        (*T)->bf = EH;
                        *taller = false;
                        break;
                    case EH:
                        (*T)->bf = RH;
                        *taller = true;
                        break;
                    case RH:
                        RightBalance(T);
                        *taller = false;
                        break;
                }
            }
        }
    }
    return true;
}

void PrintTree(BiTree tree)
{
    if(tree != nullptr)
    {
        cout << tree->data << endl;
        PrintTree(tree->lchild);
        PrintTree(tree->rchild);
    }
    
}

int main()
{
    int i;
    int a[10] = {3, 2, 1, 4, 5, 6, 7, 10, 9, 8};
    BiTree T = nullptr;
    bool taller;
    for(i = 0; i < 10; i++)
    {
        InsertAVL(&T, a[i], &taller);
    }
    PrintTree(T);
}

在这里插入图片描述
散列查找：

#include <iostream>
using namespace std;
#define SUCCESS 1
#define UNSUCCESS 0
#define HASHSIZE 12
#define NULLIKEY -32768
typedef struct
{
    int* elem;
    int count;
}HashTable;

int m = 0;

bool InitHashTable(HashTable* H)
{
    int i;
    m = HASHSIZE;
    H->count = m;
    H->elem = (int*)malloc(m * sizeof(int));
    for(i = 0; i < m; i++)
    {
        H->elem[i] = NULLIKEY;
    }
    return true;
}

int Hash(int key)
{
    return key % m;
}

void InsertHash(HashTable* H, int key)
{
    int addr = Hash(key);
    while(H->elem[addr] != NULLIKEY)
    {
        addr = (addr + 1) % m;
    }
    H->elem[addr] = key;
}

bool SearchHash(HashTable H, int key, int* addr)
{
    *addr = Hash(key);
    while(H.elem[*addr] != key)
    {
        *addr = (*addr + 1) % m;
        if(H.elem[*addr] == NULLIKEY || *addr == Hash(key))
        {
            return UNSUCCESS;
        }
    }
    return SUCCESS;
}

int main()
{
    HashTable* table = new HashTable();
    int addr;
    InitHashTable(table);
    InsertHash(table, 2198);
    InsertHash(table, 7278);
    if(SearchHash(*table, 2198, &addr))
    {
        cout << "找到了" << endl; 
    }
    if(!SearchHash(*table, 5, &addr))
    {
        cout << "没有找到" << endl;
    }
    delete table->elem;
    delete table;
}

在这里插入图片描述

qq_43812167
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分查找算法总结
Summer_night_star的博客
02-18 7536
1 二分查找简介   二分查找也叫折半查找，是一种常见的查找方法，它将原本是线性时间提升到了对数时间范围，大大缩短了搜索时间。   二分查找必须具备两个条件，一是数列必须使用顺序存储结构（例如数组），二是数列必须有序。 2 二分查找的原理及实现   以升序数列为例，比较一个元素与数列中的中间位置的元素的大小，如果比中间位置的元素大，则继续在后半部分的数列中进行二分查找；如果比中间位置的元素小，则在数列的前半部分进行比较；如果相等，则找到了元素的位置。   每次比较的数列长度都会是之前数列的一半，直到找到相等
查找算法总结+查找+线性查找+二分查找+哈希查找+树查找+算法
最新发布
06-29
查找算法是计算机科学中一种常见的算法，用于在数据结构中快速定位特定的元素。根据数据结构的不同，常见的查找算法包括线性查找、二分...查找算法总结+查找+线性查找+二分查找+哈希查找+树查找+算法 算法学习 python
5.实现泛型二分查找方法
c1776167012的博客
12-07 605
我们都知道二分查找，下面我们尝试写一个适用于所有类型的数组二分查找泛型方法。 代码如下： /** * 泛型方法：二分查找法 * @param array 查找数组 * @param key 查找元素 * @param <T> 类型变量 * @return */ public static <T extends Comparable<? super T>> int search(T[] array, T key) { int low = 0;
二分查找c++实现
liutaiyi8的博客
08-22 1254
#include&lt;iostream&gt; using namespace std; /* 二分查找的思想：每次用要查找的key'值与midle值比较，key值大，low变为midle+1 否则heigh变为midle-1直到low=hight */ int Bin(int *array,int size,int key){ if(array == NULL || s...
常用查找算法总结
DayDayUp
02-13 3047
一、顺序查找 　　条件：无序或有序队列。 　　原理：按顺序比较每个元素，直到找到关键字为止。 　　时间复杂度：O(n) 二、二分查找（折半查找） 　　条件：有序数组，折半查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，折半查找能得到不错的效率。但对于需要频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用。 　　原理：查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束； 　　　　　如果某一特定元素大于或者小于中间
数据结构–七大查找算法总结
热门推荐
fafawf的博客
08-06 5万+
转 数据结构–七大查找算法总结 2017年08月15日 21:06:17 阅读数：10610 ...
数据结构-查找算法总结
Yummy
09-07 2655
本文将对数据结构中各种查找算法进行总结。
排序算法和查找算法总结
HelloCode的博客
05-30 2608
#排序算法总结 1.冒泡排序 解释： ​ 所谓冒泡排序，就是如同水里的泡泡一样，将合适的值一次次往上冒，直到所有数据全部处理完成。 在数据中的解释就是：从第一个数开始，每次都将前一个数与后一个数作比较，如果前一个数大于后一个数，则将两者交换位置（否则不交换），此时，后一个数值已变化，然后再将后一个数与后后一个数作比较，重复操作，直到所有的数都比较完成。 算法过程： ​ 先定义一个外循环，控制整个...
数据结构与算法【Java】06---七大查找算法总结
鹤鸣呦呦、、的博客
09-14 1617
七大查找算法，查找算法分类，查找算法时间复杂度分析，查找算法代码实现，顺序查找，二分查找，插值查找，斐波那契查找，分块查找，哈希查找，树表查找，哈希表解决冲突的方法
查找算法总结大全(C/C++语言实现)
qq_41854911的博客
07-25 2877
文章目录1. 顺序查找2. 二分查找3. 插值查找4. 斐波那契查找5. 树表查找**6. 分块查找**7. 哈希查找 参考：Data Structure & Algorithm] 七大查找算法 查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找。本文简单概括性的介绍了常见的七种查找算法，说是七种，其实二分查找、插值查找以及斐波那契查找都可以归为一类——插值查找。插值查找和斐波那契查找是在二分查找的基础上的优化查找算法。树表查找和哈希查找会在
C++数据结构查找算法总结
09-13
C++数据结构经典查找算法总结，包含详细可执行代码以及算法讲解！
排序查找算法总结
03-20
排序查找算法总结 排序算法是计算机科学中的一种基本算法，用于对数据进行排序。在各种排序算法中，每种算法都有其特点和应用场景。本文将对10种经典的排序算法进行总结，并对每种算法的时间复杂度、空间复杂度和...
查找算法总结---（附代码）
10-14
查找算法在计算机科学中扮演着至关重要的角色，它们在数据处理和信息检索中起到核心作用。本文主要讨论了七种常见的查找算法，并提供了相应的C++代码实现，包括静态和动态查找、无序与有序查找的区别，以及不同算法...
路由查找算法
03-10
自己做的路由查找算法ppt，上课用。主要从四个方面总结，1.Internet地址结构的发展2. 路由查找算法3. 路由查找算法的评价4. 相关进展
Java实现的快速查找算法示例
08-29
Java实现的快速查找算法示例 Java实现的快速查找算法示例是指通过Java语言实现的快速查找算法，旨在解决查找问题的高效解决方案。快速查找算法是指在一个数组中查找第k个大的数的算法，通过将数组分成两部分，左边...
zb.rar_查找算法
09-19
总结，折半查找算法是一种高效的查找技术，尤其适用于已排序的数据结构。通过不断缩小查找范围，它能在较短的时间内找到目标元素，对于提升软件的效率具有重要意义。通过阅读“zb.rar”中的“zb.txt”文件，我们可以...
常用的 STL 查找算法
12-22
查找少不了循环遍历，在这里总结下常用的STL查找算法； 　查找有三种，即点线面： 　点是查找目标为单个元素； 　线是查找目标为区间； 　面是查找目标为集合； 　针对每个类别的查找，默认的比较函数是相等，...
查找算法总结：符号表与数据结构
"该资源是关于搜索算法的总结，涵盖了符号表、二叉查找树、平衡查找树、散列表、单词查找树以及字符串查找和B树等数据结构和算法。" 在计算机科学中，搜索算法是解决问题的核心工具之一，尤其在处理大量数据时。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值