数据结构与算法 查找算法(线性查找,二分查找,插值查找,斐波那契查找) 附有详细流程分析图!

已于 2022-06-14 09:47:28 修改
阅读量987 收藏 4
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 文章标签： 算法 java leetcode
于 2022-06-04 22:29:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44819566/article/details/125126622
本文介绍了Java中的高级查找算法，包括线性查找、二分查找（单元素与多元素）、插值查找和斐波那契查找。讲解了每种方法的工作原理、代码实现及优缺点，适用于数据结构和算法学习者。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Tips: 采用java语言,关注博主,底部附有完整代码

工具:IDEA

本篇介绍查找算法:

  • 线性查找
  • 二分查找(寻找单个元素)
  • 二分查找(寻找所有元素)
  • 插值查找
  • 斐波那契查找
名称效果图
线性查找线性查找gif
二分查找二分查找gif
插值查找插值查找(理想状态)
斐波那契数列斐波那契数列
斐波那契查找斐波那契执行过程

线性查找算法

重点:

  • 从头到尾一个一个循环

线性查找比较简单,就算刚入门也应该会,直接看代码了!

流程图

线性查找gif

完整代码

# 线性查找
/*
 * @param ints: 原始数据
 * @param findValue: 查找元素
 * return -1未找到
 */
public static int findIndex(int[] ints, int findValue) {
    for (int i = 0; i < ints.length; i++) {
        if (findValue == ints[i]) {
            return i;
        }
    }
    return -1;
}

使用:

int[] ints = new int[]{12, 4, 16, 1, 20, 21, 5, 8, 10, 3};

int index = findIndex(ints, 20);
if (index == -1) {
    System.out.println("没有找到元素");
} else {
    System.out.printf("找到元素下标为=%d\n", index);
}

优缺点分析

优点:

  • 简单
  • 无需排序,从头到位一个一个判断

缺点:

  • 从头到位一个一个判断,效率低

二分查找(寻找单个元素)

重点:

  • 寻找数组必须有序

  • 一半一半的找

  • 指针记录

指针记录

这里的指针和C中的指针不同

这里的指针可以理解为下标,就是找一个临时的数来记录当前位置

二分查找只需要3个指针

  • 开始指针
  • 结束指针
  • 中间指针

每次值和中间位置做比较

如果需要寻找的元素findValue > 中间位置 ,说明 findValue 在中间指针右边

所以需要将 开始指针 = 中间指针 + 1

如果 findValue < 中间位置 ,说明findValue在中间指针左侧

所以需要将 结束指针 = 中间指针

最终需要找的元素和当前元素相同时候,说明找到了该元素,返回下标即可!

流程图

二分查找gif

完整代码

方式一:

递归法:

/**
 * @param ints[]: 需要查找的数组
 * @param start: 开始位置
 * @param end: 结束位置
 * @param findValue:需要找的元素
 * return -1:没有找到元素
 */
public static int findIndex(int[] ints, int start, int end, int findValue) {
    System.out.println("方式一");

   // 如果左侧指针 > 右侧指针,说明开始位置已经超出结束位置 说明没找到元素 返回-1即可
    if (start > end) {
        return -1;
    }
    // 中间位置
    int middle = (end + start) / 2;
    System.out.printf("开始位置=%d\t结束位置=%d\t居中元素位置=%d\n", ints[start], ints[end], ints[middle]);

    // 查找元素 > 中间位置
    if (findValue > ints[middle]) {
        return findIndex(ints, middle + 1, end, findValue);
      
    } else if (findValue < ints[middle]) {
        // 查找元素 < 中间位置
        return findIndex(ints, start, middle, findValue);
    } else {
        return middle;
    }
}

方式二:

非递归法:

/**
 * @param ints[]: 需要找的数组
 * @param findValue: 需要找的元素
 * return -1:没有找到
 */
public static int findIndex2(int[] ints, int findValue) {
    // 开始指针
    int start = 0;
    // 结束指针
    int end = ints.length - 1;

    while (true) {
        if (start > end) {
            return -1;
        }
        // 中间元素
        int middle = (end + start) / 2;
        System.out.printf("开始位置=%d\t结束位置=%d\t居中元素位置=%d\n", ints[start], ints[end], ints[middle]);

        // 当前元素 > middle 元素
        if (findValue < ints[middle]) {
            // 向左找元素
            end = middle;
        } else if (findValue > ints[middle]) {
            start = middle + 1;
        }

        if (ints[middle] == findValue) {
            return middle;
        }
    }
}

使用:

int[] ints = new int[]{2, 6, 17, 23, 42, 44, 51, 55, 75, 242, 253, 332, 432, 542, 638, 761};
// 方式一 递归法
int index = findIndex(ints, 0, ints.length - 1, 253);

// 方式二 非递归法
//        int index = findIndex2(ints, 332);

if (index == -1) {
  System.out.println("没有找到元素");
} else {
  System.out.printf("找到元素下标为:%d\t值为=%d\n", index, ints[index]);
}

这两种方式思想都是一样的!

优缺点分析

优点:

  • 正常情况(99%)下比线性查找找的快,特别是数据量非常大的情况下,效果会更加明显

缺点:

  • 需要数组是有序的
  • 中间指针(mid)不够灵性,没次都是分一半来找

中间指针不够灵性,那么就引出了接下来要介绍的插值查找 和 斐波那契查找了!

二分查找(寻找所有元素)

技巧:

根据普通二分查找,先找到单个元素,然后向前遍历,和向后遍历,吧元素相同的元素都记录起来即可

因为二分查找的数组是有序的,所以需要找的元素,在数组中一定是连续的!

例如:

截屏2022-06-04 16.00.11

完整代码

public static ArrayList<Integer> findIndex(int[] ints, int findValue) {
    // 用来存储找到的元素
    ArrayList<Integer> temp = new ArrayList<>();

    int start = 0;
    int end = ints.length - 1;

    while (true) {
        if (start > end) {
            return temp;
        }
        // 中间元素
        int middle = (end + start) / 2;
        System.out.printf("开始位置=%d\t结束位置=%d\t居中元素位置=%d\n", ints[start], ints[end], ints[middle]);

        // 当前元素 > middle 元素
        if (findValue < ints[middle]) {
            // 向左找元素
            end = middle;
        } else if (findValue > ints[middle]) {
            start = middle + 1;
        }

        // 找到元素
        if (ints[middle] == findValue) {
            int tempIndex = middle;

            System.out.println("率先找到的位置为" + middle);
            // 循环之前的元素
            while (true) {
                // 保证tempIndex在数组中 并且当前元素 == 寻找的元素
                if (tempIndex >= 0 && ints[tempIndex] == findValue) {
                    temp.add(tempIndex);
                    System.out.println("之前的元素 = " + tempIndex);
                    tempIndex--;
                } else {
                    // 如果上一个元素 和findValue不想等，那么就退出循环
                    break;
                }
            }

            tempIndex = middle;
            // 循环之后的元素
            while (true) {
                tempIndex++;
                // 保证在数组中 并且 当前元素 == 寻找的元素
                if (tempIndex <= ints.length - 1 && ints[tempIndex] == findValue) {
                    temp.add(tempIndex);
                    System.out.println("之后的元素 = " + tempIndex);
                } else {
                    // 如果下一个元素 和findValue不想等，那么就退出循环
                    break;
                }
            }
            return temp;
        }
    }
}

调用:

int[] ints = new int[]{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};
int findValue = 4;
ArrayList<Integer> temp = findIndex(ints, findValue);

if (temp.size() == 0) {
    System.out.println("没有找到元素");
} else {
    System.out.printf("需要找的元素为%d\t找到元素下标集合为:%s\n", findValue, temp);
}

调用结果:

开始位置=1	结束位置=5	居中元素位置=4
率先找到的位置为7
之前的元素 = 7
之前的元素 = 6
之后的元素 = 8
之后的元素 = 9
需要找的元素为4	找到元素下标集合为:[7, 6, 8, 9]

这段代码也比较简单,只是在找到元素中向前遍历,和向后遍历,找到相同的元素返回即可!

插值查找

重点:

  • 步长几乎一样

上面二分查找也说到了他的缺点, 中间指针(mid)不够灵性,每次都切一半来找位置

插值查找是对二分查找的一次小升级,升级了中间指针的变化,不过只有在特定场景能用,并不适合所有的场景!

步长几乎一样

在插值查找中,不仅需要查找数组有序,而且需要每个元素的步长几乎一样使用起来才比较快

什么叫步长几乎一样? 什么叫步长?

步长:

假设当前寻找数组为 [1,2,3,4,5,6,7,8,9,10] 可以看出每个元素仅隔1位,所以说他的步长为1

假设当前寻找数组为 [6, 12, 18, 19, 22, 24, 30, 36, 42, 43, 44, 46, 48, 54, 60]每个元素隔6位,那么他的步长为6

理想状态

先来看步长相同的理想状态:

截屏2022-06-04 15.57.25

首先可以获取到48在整个数组中的占比:

  • A = findValue - ints[start]
  • B = ints[end] - ints[start]

48在整个数组中的占比为 = A / B

数组的长度为 end - start

所以需要找的元素的下标就可以得到公式(end - start) * A / B

带入完整公式:

mid = (end - start) * (findValue - ints[start]) / (ints[end] - ints[start])

带入数据:

mid = (9 - 0) * (48 - 6) / (60 - 6)
	  = 9 * 42 / 54 
	  = 7

完整效果图:

插值查找(理想状态)

代码和二分查找代码完全类似

只需要吧之前 mid = (end - start) / 2 改为

mid = (end - start) * (findValue - ints[start]) / (ints[end] - ints[start]) 就是插值排序!

这样一来,只需要一次寻找,就能快速找到想要的下标

但是,但是,但是这是理想状态,俗话说理想很丰满,现实很骨感

不理想状态

假如数据没有这么完整,数据是长这样呢:

截屏2022-06-04 15.41.39

可以看出,这样一来,步长完全不规律,再次带入刚才的公式试试能否找到具体值

刚才公式 mid = (end - start) * (findValue - ints[start]) / (ints[end] - ints[start])

带入数据:

mid = (14 - 0) * (48 - 6) / (60 - 6)
		= 14 * 42 / 54      
		= 10

可以看出,虽然没有一次性找到想要的值,找到的是下标10,但是已经和预想结果很相近了

此时状态变成了这样:

截屏2022-06-04 15.45.34

此时 start = mid + 1

再次带入刚才的公式:

mid = (end - start) * (findValue - ints[start]) / (ints[end] - ints[start])

mid = (14 - 11) * (48 - 46) / (60 - 46)
		= 3 * 2 / 14      
		= 0

可以看出,现在已经出错了,mid已经不在start 和 end之间了,这样一来就会导致无限的循环下去…

再次优化一下插值排序

优化前:

mid = (end - start) * (findValue - ints[start]) / (ints[end] - ints[start])

优化后:

mid =start + (end - start) * (findValue - ints[start]) / (ints[end] - ints[start])

这样一来,就不会一直无限循环下去了

来看看完整不理想状态流程图:

插值查找算法(不理想状态)

优化后理想状态流程图:

插值查找算法(优化后)

完整代码

 public static int findValue(int[] ints, int value) {
        // 开始位置
        int start = 0;
        // 结束位置
        int end = ints.length - 1;
        // 插值位置
        int mid = 0;

        while (true) {
            // 如果开始位置 = 结束位置 那么就结束循环
            if (start > end) {
                break;
            }

            //  (value - ints[start]) / (ints[end] - ints[start]) 找到值在数组中的大致位置
            // (end - start) 获取到查找的长度
            mid = start + (end - start) * (value - ints[start]) / (ints[end] - ints[start]);

            System.out.printf("start = %d\tend = %d\tmid = %d\n", start, end, mid);
            // value < 当前中间位置
            if (value < ints[mid]) {
                end = mid - 1;
            } else if (value > ints[mid]) {
                start = mid + 1;
            } else {
                // 找到元素
                return mid;
            }

            // 如果开始位置 和找的元素相等 那么就返回开始位置
            if (value == ints[start]) {
                return start;
            }

            // 如果结束位置 和找的元素相等 那么就返回结束位置
            if (value == ints[end]) {
                return end;
            }
        }
        return -1;
    }

调用代码:

int[] ints = new int[]{6, 12, 18, 19, 22, 24, 30, 36, 42, 43, 44, 46, 48, 54, 60};

int index = findValue(ints, 48);
if (index != -1)
  System.out.printf("当前找到的下标为%d\t元素为%d\n", index, ints[index]);

优缺点分析:

优点:

  • 如果在数组步长完全一致的情况下可以通过一次循环就找到想要的下标

缺点:

  • 自认为没啥用… 现实情况绝对比这个复杂,而且不可能这么完美的步长相同
  • 感觉不如普通二分查找…
  • 如果第一次没有找到,那么mid只能龟速移动.
  • 不建议使用.

斐波那契查找

前沿: 斐波那契算法也是对二分查找的升级版本

  • 二分查找: 每隔一半开始找
  • 斐波那契: 找到完美分割点来进行查找

什么是斐波那契参考文档

斐波那契数组:

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, …]

特性:

  • fib[0] = 1

  • fib[1] = 1

  • fib[2] = fib[1] + fib[0]

  • fib[3] = fib[2] + fib[1]

  • fib[4] = fib[3] + fib[2]

  • …

来看看效果图:

斐波那契数列

得出公式: fib[n] = fib[n-1] + fib[n - 2]

由此可以得出: 假设当前数组长度为13, 在斐波那契数列中对应的是下标7

那么当前就可以通过 fib[n] = fib[n-1] + fib[n - 2] 分割为

  • fib[n - 1] = 8
  • fib[n - 2] = 5

fib[n - 1] 就是 0-7的元素

fib[n - 2] 就是8-12的元素

所以mid 就是

mid = fib[n-1] - 1 
		= 8 - 1 
		= 7

思路

斐波那契数组为: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, …]

  1. 首先创建一个斐波那契数列,用来寻找完美分割点

  2. 找到需要查找数组长度对应的斐波那契值

    例如当前数组长度为9,那么对应的斐波那契值就是13

    例如当前数组长度为22, 那么对应的斐波那契子就是34

  3. 创建一个临时数组,将当前数组的长度,转变为斐波那契找对应值的长度,临时数组不足位补最后一位

    假设当前数组值为[2, 6, 17, 23, 42, 44, 51, 55, 75] length = 9

    那么转变后的数组为:[2, 6, 17, 23, 42, 44, 51, 55, 75, 75, 75, 75] length = 12

    这样做的目的是为了可以吧数组分为2部分

    • start 至 mid (0至7)
    • mid 至 end (8至11)

    所以由得出

    start = 0
end = 11
mid = fib[n - 1] - 1 
    = 8 - 1
    = 7

  4. **如果查找的值在mid左侧,**并且没有找到,那么指向斐波那契的指针就 减1

    这里为什么要减1?

    还是按照上面的例子,当前数组长度为[2, 6, 17, 23, 42, 44, 51, 55, 75, 75, 75, 75] length = 12, 需要找的元素为 23

    • start = 0 value = 2

    • end = 11 value = 75

    • mid = 7 value = 55

    那么第一次找值的时候,23 < mid (55),第二次的时候就变成了

    • start = 0 value = 2
    • end = 6 value = 51

    此时范围缩小到了0-7,对应的斐波那契至为8,下标为5

    斐波那契数值8和下标为5,又可以通过 fib[k] = fib[k-1] + fib[k-2]得知

    • fib[k-1] = 5
    • fib[k - 2] = 3

    所以第二次的黄金分割点就是fib[k-1] -1,就是 5-1 = 4

  5. 如果查找的值在mid右侧,并且没有找到,那么只想斐波那契的指针就 减2

​ 这里减2和上面减1是相同的道理,就不过多赘述

效果图:

斐波那契执行过程

斐波那契数组为: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, …]

小结:

斐波那契数组中的每个元素就是一个长度,以34来举例,假设当前查找的数组ints长度, 21 < ints.length < 34

那么就让他的长度转变为34

那么第一次找值的mid(黄金分割点)就是21 - 1,这里减1是因为从0开始计算

如果没有找到

  • findValue > ints[mid] 向右查找 并且记录斐波那契的指针 减2
  • findValue < ints[mid] 向左查找 并且记录的斐波那契指针 减1

依次递归,如果确实数组中有需要寻找的值,那么就可以找到!

本质就是二分查找的逻辑,只是采用斐波那契数列的特性,改变了mid的值!

完整代码

# 斐波那契
		/**
     * @param ints  查找的数组
     * @param value 需要查找的元素
     */
    public static int findValue(int[] ints, int value) {

        // 开始位置
        int start = 0;
        // 结束位置
        int end = ints.length - 1;
        // 黄金分割点位置
        int mid = 0;
        // 斐波那契数列
        int[] fib = fib();
        System.out.println("获取到的数据为:" + Arrays.toString(fib()));

        // 表示斐波那契分隔下标
        int fibIndex = 0;

        // end  数组长度
        // fib[fibIndex] -1 = 斐波那契具体值
        // 因为是从0 开始计算 所以 fib[fibIndex] -1
        while (end > fib[fibIndex] - 1) {
            fibIndex++;
        }

        // ints = 当前数组
        // fib[fibIndex] = 拷贝长度
        // 给ints 扩容出一个新的数组 用来进行二分查找
        int[] temp = Arrays.copyOf(ints, fib[fibIndex] - 1);
        for (int i = end; i < temp.length; i++) {
            // 将int最后一个值 赋值给temp
            temp[i] = ints[ints.length - 1];
        }
        System.out.printf("temp[] = %s\tlength = %d\n", Arrays.toString(temp), temp.length);

        // 如果开始位置 <= 结束位置
        while (start <= end) {
            // mid = 中间位置
            if (fibIndex >= 1) {
                mid = start + fib[fibIndex - 1] - 1;
            } else {
                mid = (end + start) / 2;
            }
            System.out.printf("此时start = %d\tend = %d\tmid = %d\tfibIndex = %d\tmidValue = %d\n", start, end, mid, fibIndex, temp[mid]);
            // 当前值 < mid 说明 在左侧
            if (value < temp[mid]) {
                end = mid;
                fibIndex -= 1;
//                System.out.println("fibIndex减1 = " + fibIndex);
            } else if (value > temp[mid]) {
                // 当前值 > mid 说明在右侧
                start = mid + 1;
                fibIndex -= 2;
//                System.out.println("fibIndex减2 = " + fibIndex);
            } else {
                // 防止下标越界
                if (mid > ints.length - 1) {
                    return ints.length - 1;
                }
                return mid;
            }

            // 如果搜索值 = 当前结束位置 那么就直接返回结束位置
            if (value == temp[end]) {
                return end;
            }

            // 如果搜索值 = 开始位置 那么就直接返回开始位置
            if (value == temp[start]) {
                return start;
            }
        }
        return -1;
    }

    // 斐波那契数列
    public static int[] fib() {
        int[] temp = new int[mMaxSize];
        temp[0] = 1;
        temp[1] = 1;
        for (int i = 2; i < mMaxSize; i++) {
            temp[i] = temp[i - 1] + temp[i - 2];
        }
        return temp;
    }

调用:

# 斐波那契
  
System.out.println("斐波那契查找");
int[] ints = new int[]{2, 6, 17, 23, 42, 44, 51, 55, 75};
int index = findValue(ints, 23);
if (index != -1)
    System.out.printf("查询的结果下标为:%d\t具体值 = %d\n", index, ints[index]);
else
    System.out.println("没找到该元素");

完整代码

猜你喜欢:

原创不易,您的点赞就是对我最大的支持!

解锁 LeetCode 新境界，数据结构与算法引领前行
AI 算法实战派
05-11 864
在当今竞争激烈的技术领域，掌握数据结构与算法是程序员必备的技能之一。LeetCode 作为一个知名的在线编程平台，提供了丰富的算法问题，涵盖了各种数据结构和算法类型。本文的目的是引导读者充分利用 LeetCode 平台，通过系统学习数据结构与算法，提升解决编程问题的能力。文章将涵盖常见的数据结构（如数组、链表、栈、队列、树等）和算法（如排序算法、搜索算法、动态规划等），并结合 LeetCode 上的实际问题进行讲解。核心概念与联系：介绍数据结构与算法的基本概念以及它们之间的联系。
最短路径算法详解（附有C++详细代码）
Weirdo的博客
06-03 3586
Dijkstra算法作为一种经典的最短路径算法，在多个领域有着广泛的应用。通过优化和变种，可以进一步提高算法的性能和适用性。随着计算机技术的不断发展和应用领域的不断拓展，最短路径算法将继续发挥重要作用，为各种实际问题提供有效的解决方案。未来，随着人工智能和大数据技术的不断发展，最短路径算法将与其他先进技术相结合，为解决更复杂、更大规模的问题提供更加高效、智能的解决方案。
二分查找算法流程图流程图举例
05-26
数据结构中简单的二分查找（折半查找）流程图实例
斐波那契查找算法
aeg84268的博客
09-26 124
斐波那契查找的核心是： 1）当key=a[mid]时，查找成功； 2）当key<a[mid]时，新的查找范围是第low个到第mid-1个，此时范围个数为F[k-1] - 1个，即数组左边的长度，所以要在[low, F[k - 1] - 1]范围内查找； 3）当key>a[mid]时，新的查找范围是第mid+1个到第high个，此时范围个数为F[k-2] - ...
【数据结构】查找— —线性表的查找(顺序查找、折半查找、分块查找)
qq_43581971的博客
11-10 1265
查找之顺序查找、折半查找、分块查找
[数组查找]1.图解线性查找及其代码实现
大象不下象棋的博客
05-26 417
在数组中从头开始依次往下查找即可
插值查找 c语言算法流程图,插值查找算法流程图
weixin_28858229的博客
05-24 502
值法又称“内插法”，是利用函数f ***x***在某区间中已知的若干点的函数值，作出适当的特定函数，在区间的其他点上用这特定函数的值作为函数f ***x***的近似值，这种方法称为插值法。如果这特定函数是多项式，就称它为插值多项式。以下是小编为大家整理的关于，给大家作为参考，欢迎阅读!插值法的原理插值法”的原理是根据比例关系建立一个方程，然后，解方程计算得出所要求的数据，例如：假设与A1对应的数据...
swift-algorithm-club：Swift中的算法和数据结构，并附有说明！
02-05
2. **搜索算法**：包括线性搜索、二分搜索以及更高级的搜索算法如广度优先搜索（BFS）和深度优先搜索（DFS）。这些搜索技术在解决各种问题时起着关键作用，例如在图或树结构中查找路径。 3. **数据结构**：如数组、...
【Java编程教育】精选五个典型Java案例分析：涵盖核心语法、算法、面向对象、异常处理及设计模式的深度解析与实战演练
最新发布
06-11
案例二通过递归和非递归方式实现斐波那契数列，分析了不同实现的时间复杂度；案例三展示了面向对象设计中的继承与多态，通过抽象类和子类实现图形类体系；案例四讨论了异常处理与资源管理，强调了try-with-resources...
【计算机科学】Java算法大全：涵盖排序、搜索、图算法等核心领域经典实现及优化技巧介绍了Java编程语言
05-14
接着阐述了8种搜索算法，从基本的二分查找扩展到高级的深度优先搜索和广度优先搜索。第三部分聚焦于15种图算法，探讨了最短路径问题（Dijkstra、Bellman-Ford）和最小生成树问题（Prim、Kruskal）。第四部分深入讲解...
数据结构：折半查找/二分查找算法，详解，图解 -- 数据结构算法集
九瓜的博客
06-05 9146
给出一个list和一个元素，判断出list中是否存在该元素 浅短理解： 折半查找算法是对于有序的序列而言的，每次查找后折半，大概缩短了一半的查找区间，是一种效率较高的查找算法。 要求： list必须是顺序结构，且按照关键词大小进行有序排列。 思路： 在有序序列中查找元素，每次取序列中间的元素，如果与要查找元素相等，程序结束； 如果查找元素大于中间元素，则取中间元素后面的序列再进行如上的查找； 如果查找元素小于中间元素，则取中间元素前面的序列再进行如上的查找； 直到找到元素相等，查找成功，或者序列为空，查找失
斐波那契查找算法 -数据结构
weixin_34392435的博客
12-14 125
这个是我本人写的斐波那契查找算法，和网上的其他思路略有不同，特贴出来： 1）没有预先存储斐波那契的数组，整个的搜索数据长度可以变动； 2）mid索引的变动是动态变化的，根据斐波那契的回退方法； #include<stdlib.h>#include<stdio.h> #define INF 32767#define SIZE 92int Feibinaci(int s...
数据结构与算法——插值查找算法实现
qq_38099207的博客
06-22 308
插值查找算法 与二分查找的不同点 原理：int mid = (high-low) / 2;//二分查找 int mid = (high - low) * (findVal - arr[low]) / (arr[high] - arr[low]);//插值查找 至于为什么这个公试会比较快，欢迎*大的朋友给我上上课 算法实现 public class InsertValueSearchDe...
线性查找(思路分析和代码实现) [数据结构][Java]
m0_57001006的博客
08-22 270
【代码】线性查找(思路分析和代码实现) [数据结构][Java]
【图解算法数据结构】（六）查找算法
闻韶
08-04 282
【图解算法数据结构】（六）查找算法
数据结构——线性表的查找
Labrador_Katie的博客
02-22 5333
查找查找的概念线性表的查找顺序查找（线性查找）折半查找（二分或对分查找）分块查找 查找的概念 主关键字：可唯一地标识一个记录的关键字就是主关键字 次关键字：用以识别若干记录的关键字就是次关键字 对查找表经常进行的操作： 查询某个“特定的”数据元素是否在查找表中 检索某个“特定的”数据元素的各种属性 在查找表中插入一个数据元素 删除查找表中的某个数据元素 查找表可以分为两类： 静态查找表：   仅作“查询”（检索）操作的查找表 动态查找表：   作“插入”和“删除”操作的查找表   有时在查询之后，还需
java实现插值查找算法
dongyu1703的博客
09-06 274
package course; import java.util.Arrays; // 插值查找是二分查找的改进，mid的值用自适应的方法求得 // 对于数据量较大，关键字分布比较均匀的查找表来说采用插值查找速度较快 // 关键字分布不均匀(跳跃性很大)的情况下，该方法不一定比折半查找要好 public class InsertValueSearch { public static voi...
数据结构查找算法之平衡二叉树【附Java代码实现，图解】
ppBlog
05-09 405
平衡二叉树，又称为 AVL 树。实际上就是遵循以下两个特点的二叉树： 每棵子树中的左子树和右子树的深度差不能超过 1； 二叉树中每棵子树都要求是平衡二叉树； 平衡因子：每个结点都有其各自的平衡因子，表示的就是其左子树深度同右子树深度的差。平衡二叉树中各结点平衡因子的取值只可能是：0、1 和 -1。 二叉排序树转化为平衡二叉树；当平衡二叉树由于新增数据元素导致整棵树的平衡遭到破坏时，就需要根据实际情况做出适当的调整，假设距离插入结点最近的“不平衡因子”为 a。则调整的规律可归纳为以下 4 种情况
严蔚敏《数据结构》C语言版题解与算法解析
9. **第九章 查找**：涉及不同的查找算法，如顺序查找、二分查找、哈希查找等。 10. **第十章 内部排序**：讲解了各种排序算法，如冒泡排序（如1.16题所示）、插入排序、选择排序、快速排序、归并排序、堆排序等。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

s10g

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值