常见查找算法

最新推荐文章于 2022-01-06 11:41:37 发布
最新推荐文章于 2022-01-06 11:41:37 发布
阅读量185 收藏
点赞数
分类专栏： 面试 文章标签： 算法 查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17589253/article/details/102876535
版权

常见查找算法

本篇介绍了几种常见的查找算法：顺序查找、二分查找、插值查找、斐波那契查找、二叉树查找

准备工作

public class SearchDemo {

    /** 普通无序数组 */
    private int[] normalArr = new int[20];
    /** 有序递增数组 */
    private int[] sortedlArr = new int[20];
    /** num1：无序算法要查找的整数；num2：有序算法要查找的整数；index：找到的数在对应数组中的索引，没有则为-1 */
    private int num1, num2, index = -1;

    @BeforeEach
    public void before() {
        Random random = new Random();
        for (int i = 0; i < normalArr.length; i++) {
            normalArr[i] = random.nextInt(1000);
        }
        // 增数列
        int num = 0;
        for (int i = 0; i < sortedlArr.length; i++) {
            sortedlArr[i] = (num += random.nextInt(30));
        }
        num1 = normalArr[random.nextInt(20)];
        num2 = sortedlArr[random.nextInt(20)];
    }

顺序查找

顾名思义，遍历数组中元素，直到找到匹配的为止，数组是否有序不影响该算法

优点：

对数组无要求，可以对无序数组中进行查找

缺点：

时间复杂度高，不适宜在大量数据中查找

/**
 * 顺序查找
 */
@Test
public void sequentialSearch() {
    if (normalArr.length <= 0) {
        return;
    }
    if (normalArr.length == 1) {
        index = normalArr[0] == num1 ? 0 : -1;
        return;
    }
    for (int i = 0; i < normalArr.length; i++) {
        if (normalArr[i] == num1) {
            index = i;
            break;
        }
    }
    System.out.println("normalArr: " + Arrays.toString(normalArr));
    if (index == -1) {
        System.out.println("num=" + num1);
        System.out.println("数组中没有该数字");
    } else {
        System.out.println("num=" + num1);
        System.out.println("normalArr[" + index + "]=" + normalArr[index]);
        System.out.println("验证" + (num1 == normalArr[index] ? "" : "不") + "通过");
    }
}

结果如下：

normalArr: [791, 108, 892, 759, 945, 446, 976, 524, 536, 909, 691, 899, 417, 801, 733, 237, 601, 552, 929, 48]

num=791

normalArr[0]=791

验证通过

二分查找

每次从数组的动态范围（第一次是整个数组）内取中间位置的数比较，将要查找的数锁定在两个更小的范围之一，逐步缩小范围，直到查找到对应的数或者算法结束

优点：查询速度快

缺点：要求数组有序

二分查找适宜于基本没有数据变动且查找操作频繁的有序数组

/**
 * 二分查找
 */
@Test
public void binarySearch() {
    if (sortedlArr.length <= 0) {
        return;
    }
    if (sortedlArr.length == 1) {
        index = sortedlArr[0] == num2 ? 0 : -1;
        return;
    }
    if (num2 < sortedlArr[0] || num2 > sortedlArr[sortedlArr.length - 1]) {
        return;
    }
    int start = 0;
    int end = sortedlArr.length - 1;
    while (start <= end) {
        if (start == end) {
            if (sortedlArr[start] == num2) {
                index = start;
            }
            break;
        }
        int mid = (start + end) / 2;
        int midNum = sortedlArr[mid];
        if (midNum == num2) {
            index = mid;
            break;
        }
        if (midNum > num2) {// (start, mid)
            end = mid - 1;
        }
        if (midNum < num2) {// (mid, end)
            start = mid + 1;
        }
    }
    System.out.println("sortedlArr: " + Arrays.toString(sortedlArr));
    if (index == -1) {
        System.out.println("num=" + num2);
        System.out.println("数组中没有该数字");
    } else {
        System.out.println("num=" + num2);
        System.out.println("sortedlArr[" + index + "]=" + sortedlArr[index]);
        System.out.println("验证" + (num2 == sortedlArr[index] ? "" : "不") + "通过");
    }
}

结果如下：

sortedlArr: [16, 32, 43, 49, 58, 73, 90, 119, 122, 130, 147, 149, 175, 179, 199, 214, 221, 229, 234, 254]

num=234

sortedlArr[18]=234

验证通过

插值查找

插值查找是对二分查找的改进，改进之处在对mid即判断的数的位置的取值方法上，二分法是直接去中间位置，而插值查找则向着离查找的数更近似的方式去取数组中的判断数的位置使得每一次取数离查找目标更近，从而更快的找到目标数字

优点：

查询速度快

对于关键字分布均匀的数组来说，查询速度将优于折半查找。如果关键字分布不均匀，则查询速度与折半查找速度近似

缺点：

与二分查找一样，要求数组有序

插值查找适宜于基本没有数据变动且查找操作频繁的有序数组

/**
 * 插值查找
 */
@Test
public void insertSearch() {
    if (sortedlArr.length <= 0) {
        return;
    }
    if (sortedlArr.length == 1) {
        index = sortedlArr[0] == num2 ? 0 : -1;
        return;
    }
    if (num2 < sortedlArr[0] || num2 > sortedlArr[sortedlArr.length - 1]) {
        return;
    }
    int low = 0;
    int high = sortedlArr.length - 1;
    int mid;
    while (low <= high) {
        if (low == high) {
            if (num2 == sortedlArr[low]) {
                index = low;
            }
            break;
        }
        int highValue = sortedlArr[high];
        int lowValue = sortedlArr[low];
        mid = low + (num2 - lowValue) / (highValue - lowValue) * (high - low);
        if (num2 == sortedlArr[mid]) {
            index = mid;
            break;
        }
        if (num2 > sortedlArr[mid]) {
            low = mid + 1;
        }
        if (num2 < sortedlArr[mid]) {
            high = mid - 1;
        }
    }
    System.out.println("sortedlArr: " + Arrays.toString(sortedlArr));
    if (index == -1) {
        System.out.println("num=" + num2);
        System.out.println("数组中没有该数字");
    } else {
        System.out.println("num=" + num2);
        System.out.println("sortedlArr[" + index + "]=" + sortedlArr[index]);
        System.out.println("验证" + (num2 == sortedlArr[index] ? "" : "不") + "通过");
    }
}

结果如下：

sortedlArr: [1, 2, 22, 25, 38, 40, 44, 53, 70, 80, 99, 122, 148, 155, 170, 188, 204, 223, 250, 250]

num=80

sortedlArr[9]=80

验证通过

斐波那契查找

也是对二分查找的改进，斐波那契数列的定义是F(k)=1, k∈[1, 2]或F(k)=F(k-1)+F(k-2), k≥3，而k趋向于正无穷时，F(k)/F(k-1)≈F(k-1)/F(k-2)=0.618，即黄金分割比例，通过将中间取数改进为按照黄金分割比例取数，提高查找效率，算法思路在如下的方法注释中

优点：

查询速度快

相比于插值查找，斐波那契查找不受数值影响

查询速度优于二分查找

缺点：

要求数组有序

该算法可能会调整原数组长度，即需要在数组后边以最后一个值填充，不论是使用辅助函数还是构建新数组，会消耗空间资源

斐波那契查找适宜于基本没有数据变动且查找操作频繁的有序数组

/**
 * 斐波那契查找
 *
 * n表示数组长度
 * F(k)表示斐波那契数列
 *
 * 令 F(k)-1=n
 * 而F(k) = F(k-1)+F(k-2)
 * 所以 F(k-1)+F(k-2)-1=n
 *
 * 原来的二分查找的mid
 * mid=low+(low+high)/2
 *
 * 因为拿的是F(k-1)比较，而F(k-1)>=F(k-2)，所以mid的位置在数组中间偏右边，即右边的黄金分割点
 * 所以新的mid这样算
 * mid=low+F(k-1)-1，减1防止索引溢出，参考k=2的情况
 *
 * 判断的情况分三种讨论:
 *
 * =：mid即查找值
 *
 * >：查找值在mid右边，所以low=mid+1，即查找值在范围[mid+1, high]中，而high=n-1，mid+1=low+F(k-1)，
 * 元素个数为：(n-1)-(low+F(k-1))+1=n-low-F(k-1)=F(k)-1-low-F(k-1)=F(k-2)-1-low
 * 即查找值在黄金分割中较小的范围内，所以k要自减2
 *
 * <：查找值在mid左边，所以high=mid-1，即查找值在范围[low, mid-1]中，而low=0，mid-1 = low+F(k-1)-2，
 * 元素个数为：low+F(k-1)-2-low+1=low+F(k-1)-1
 * 即查找值在黄金分割中较大的范围内，所以k自减1
 */
@Test
public void fibonacciSearch() {
    if (sortedlArr.length <= 0) {
        return;
    }
    if (sortedlArr.length == 1) {
        index = sortedlArr[0] == num2 ? 0 : -1;
        return;
    }
    int len = sortedlArr.length;// 数组长度
    Integer[] fibonacciArr = getFibonacciArray(len);// 获取相应的斐波那契数列
    int fibonacciArrHighValue = fibonacciArr[fibonacciArr.length - 1];// 获取斐波那契数列中最后一个，即最大的数
    int highValue = sortedlArr[sortedlArr.length - 1];// 获取有序数组中最大的数
    // 有序数组作填充处理
    int[] tmp = null;
    if (fibonacciArrHighValue - 1 > len) {
        int[] _tmp = new int[fibonacciArrHighValue - 1];
        System.arraycopy(sortedlArr, 0, _tmp, 0, len);
        Arrays.fill(_tmp, len, _tmp.length, highValue);
        tmp = sortedlArr;
        sortedlArr = _tmp;
    }
    int low = 0, high = sortedlArr.length - 1;
    int k = fibonacciArr.length - 2;
    int mid;
    while (k >= 0) {
        mid = low + fibonacciArr[k] - 1;
        if (sortedlArr[mid] == num2) {
            index = mid;
            break;
        } else if (num2 > sortedlArr[mid]) {
            low = mid + 1;
            k = k - 2;
        } else {
            high = mid - 1;
            k--;
        }
    }
    // 有序数组还原
    if (sortedlArr.length != len) {
        sortedlArr = tmp;
    }
    System.out.println("sortedlArr: " + Arrays.toString(sortedlArr));
    if (index == -1) {
        System.out.println("num=" + num2);
        System.out.println("数组中没有该数字");
    } else {
        System.out.println("num=" + num2);
        System.out.println("sortedlArr[" + (index >= len ? len - 1 : index) + "]=" + sortedlArr[index]);
        System.out.println("验证" + (num2 == sortedlArr[index] ? "" : "不") + "通过");
    }
}



/**
 * 根据数组的长度获取对应的斐波那契数列
 *
 * @param len 数列长度
 * @return
 */
private Integer[] getFibonacciArray(int len) {
    List<Integer> list = new ArrayList<>();
    if (len > 0) {
        int i = 0;
        int a = 0, b = 0, num = 0;
        while (true) {
            if (i == 0) {
                a = 1;
                list.add(a);
                num = 1;
            } else if (i == 1) {
                b = 1;
                list.add(b);
                num = 1;
            } else {
                num = a + b;
                list.add(num);
                a = b;
                b = num;
            }
            if (num - 1 >= len) {
                break;
            }
            i++;
        }
    }
    Integer[] array = list.toArray(new Integer[list.size()]);
    return array;
}

结果如下：

sortedlArr: [2, 15, 27, 47, 47, 49, 49, 66, 70, 72, 94, 95, 97, 98, 127, 142, 161, 176, 180, 190]

num=66

sortedlArr[7]=66

验证通过

二叉树查找

主要利用了二叉排序树的性质，对于一个二叉排序树中的任意节点，其左子节点（存在时）小于该节点的值，其右子节点（存在时）大于该节点的值，即对二叉排序树中序遍历，可得到有序数列

优点：

可排序无序数组

插入和查找的效率都快

缺点：

需要额外空间（构建二叉树结构）

当查找的原数组有序时，不适宜用二叉树查找，此时二叉树查找等同于顺序查找（除非在插入时对二叉树结构进行优化）

本例中采用先序遍历进行查找

/**
 * 二叉树查找
 */
@Test
public void binaryTreeSearch() {
    SortedBinaryTree tree = new SortedBinaryTree(normalArr);
    index = tree.indexOf(num1);
    System.out.println("normalArr: " + Arrays.toString(normalArr));
    if (index == -1) {
        System.out.println("num=" + num1);
        System.out.println("数组中没有该数字");
    } else {
        System.out.println("num=" + num1);
        System.out.println("normalArr[" + index + "]=" + normalArr[index]);
        System.out.println("验证" + (num1 == normalArr[index] ? "" : "不") + "通过");
    }
}

/**
 * 二叉排序树
 * 二叉排序树是二叉树的一种，对于二叉排序树而言，若
 * 一个节点有左或右子节点，则始终存在左节点的值不小于（或不大于）
 * 父节点，右节点的值不大于（或不小于）父节点，即对二叉排序树
 * 进行中序遍历，得到的数列是有序的
 */
@Getter
@Setter
private static class SortedBinaryTree {

    private Node head;// 头节点
    private Integer min;// 二叉树中最小值
    private Integer max;// 二叉树中最大值
    private Integer currentIndex;

    public SortedBinaryTree(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            add(arr[i]);
        }
    }

    /**
     * 按照中序遍历从小到大的方式对新增节点作处理
     * 等值放在左子节点，或者不加也可以
     * 思路：
     * @param num
     */
    public void add(int num) {
        if (null == head) {
            currentIndex = 0;
            head = new Node(num, currentIndex);
            min = max = num;
            return;
        }
        Node node;
        node = head;
        while (true) {
            if (num > node.num) {// 该值比当前节点的值大，放到该节点的右子树上
                if (null == node.right) {
                    node.right = new Node(num, ++currentIndex);
                    break;
                }
                node = node.right;
            } else {// 该值不大于当前节点的值，放到该节点的左子树上
                if (null == node.left) {
                    node.left = new Node(num, ++currentIndex);
                    break;
                }
                node = node.left;
            }
        }
        min = min > num ? num : min;
        max = max < num ? num : max;
    }

    /**
     * 返回其在数组中的索引
     * @param num
     * @return
     */
    public int indexOf(int num) {
        if (num >= min && num <= max) {
            Node node = head;
            while (null != node) {
                if (num == node.num) {
                    return node.index;
                } else if (num > node.num) {
                    node = node.right;
                } else {
                    node = node.left;
                }
            }
        }
        return -1;
    }

    /**
     * 树的节点模型
     */
    private class Node {
        private int num;
        private int index;// 在数组中的索引
        private Node left;// 左子节点
        private Node right;// 右子节点

        public Node(int num, int index) {
            this.num = num;
            this.index = index;
        }
    }
}

结果如下：

normalArr: [444, 504, 431, 389, 988, 326, 356, 918, 681, 624, 538, 419, 917, 527, 977, 680, 865, 853, 132, 602]

num=624

normalArr[9]=624

验证通过

 

1024的浪漫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++常用查找算法总结（一）
程序猿老樊的博客
07-29 2万+
        查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找，字段的查找，等等。 1、查找算法总结 (1). 最容易理解的查找算法，顺序查找法     　说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表。 　　基本思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关...
几种常用查找算法的比较
09-08
几种常用查找算法的比较，内含顺序查找、二分查找、二叉树查找、哈希表查找。
关于查找的有哪些常见算法？
Riseboy的博客
05-17 1117
查找专题查找的概念查找表操作⽅方式分类(静态/动态)顺序表查找(Sequential Search)代码实现优化（增加哨兵，将key存储在a[0]）折半查找(Binary Search)代码实现查找范围优化（插值查找）斐波拉契查找(Fibonacci Search)代码实现有序查找-总结动态查找表二叉排序树(Binary Sort Tree)⼆二叉排序树(Binary Sort Tree) — 树结构定义二叉排序树(Binary Sort Tree) — 查找操作代码实现二叉排序树(Binary Sort
查找算法-4种常用的查找算法
GGB__的博客
09-13 4752
文章目录一、排序算法是什么？1.算法解读2.查找算法简介二、查找算法介绍及实现1.顺序查找算法描述代码实现：2.二分查找/折半查找算法描述代码实现：3.插值查找算法描述代码实现：4.斐波那契查找算法描述代码实现： 一、排序算法是什么？ 1.算法解读 这里引入百度百科的解释： 谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。
常见的查找算法
qq_55627064的博客
01-06 2014
查找 查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算。 常见的查找算法： 顺序(线性)查找 二分查找（折半查找） 插值查找 斐波那契查找 1、顺序(线性)查找 顺序查找也称为线形查找，从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。 代码实现： package com.xawl.search; //线性查找 public class SeqSearch {
aaa.rar_常用查找算法_查找和排序
09-20
常用排序和查找算法的源程序，包括冒泡排序，选择排序，插入排序，折半查找，c++实现
常用查找算法
11-21
查找算法 •1 概念 •2 顺序查找 •3 二分查找 •4 分块查找 •5 哈希表查找
常用的 STL 查找算法
12-22
查找少不了循环遍历，在这里总结下常用的STL查找算法； 　查找有三种，即点线面： 　点是查找目标为单个元素； 　线是查找目标为区间； 　面是查找目标为集合； 　针对每个类别的查找，默认的比较函数是相等，...
PHP常用的排序和查找算法
10-23
主要介绍了PHP四种基本排序算法和两种查找算法示例,本文用一个实例讲解冒泡排序法、快速排序法、选择排序法、插入排序法的使用,需要的朋友可以参考下
常用的STL查找算法
09-03
主要介绍了常用的STL查找算法的相关资料，十分的详细,需要的朋友可以参考下
ch16_查找算法_
10-02
各种查找算法。常用算法集（C语言描述）。
常用排序查找算法详解
03-05
常用排序查找算法详解：各种排序查找算法
二分查找算法.zip
最新发布
04-24
常见的贪心算法包括最小生成树算法中的Prim算法、Dijkstra算法等。 字符串匹配算法：字符串匹配算法用于在一个字符串（文本）中查找一个子串（模式）的出现位置。常见的字符串匹配算法包括暴力匹配、KMP算法、Boyer...
常用查找算法[定义].pdf
10-12
常用查找算法[定义].pdf
数据结构排序查找常用算法实现.zip
08-16
主要包含冒泡 插入 选择 希尔 快速排序 堆排序 折半查找等常用的数据结构排序算法的实现
常用的四种查找算法总结
陈同学
04-05 2039
1.线性查找： 线性查找常用于判断数组中是否有要查找的值，通过直接遍历数组，判断元素是否相等即可。由于线性查找很简单，直接贴代码。 这里的代码只实现了，查找第一个元素的下标，如果找到所有元素可以定义一个集合，将return i；改成向集合中添加元素即可。 public class SeqSearch { public static int seqSearch(int[]arr...
总结四种常见的查找算法
qq_42190335的博客
08-02 4523
四种常见的查找算法1、顺序查找1.1、定义1.2、代码体现2、二分查找2.1、定义2.2、思路分析2.3、代码体现3、插值查找3.1、定义3.2、代码体现4、斐波那契查找4.1、定义4.2、原理4.3、代码体现 1、顺序查找 1.1、定义 顺序查找又名线性查找，是一种最简单的查找方法，它的基本思想是从第一个记录开始，逐个比较记录的关键字，直到和给定的K值相等，则查找成功；若比较结果与文件中n个记录的关键字都不等，则查找失败。 1.2、代码体现 public class SequenceSearch {
常用查找算法总结
hjhomw的博客
09-25 1973
查找是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）查找表按照操作方式分为静态查找表和动态查找表。静态查找表：只作查找操作的查找表。它的主要操作是： （1）查询某个“特定的”元素是否在查找表中 （2）检索某个“特定的”数据元素和各种属性动态查找表：在查找过程中同时插入查找表中不存在的数据元素，或者从查找表中删除已经存在的某个数据元素。它的主要操作是： （1）查找时插
查找算法时间复杂度表格
12-06
以下是常见查找算法的时间复杂度表格： | 算法 | 平均时间复杂度 | 最坏时间复杂度 | | --- | --- | --- | | 线性查找 | O(n) | O(n) | | 二分查找 | O(log n) | O(log n) | | 哈希表查找 | O(1) | O(n) | 其中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值