数组结构与算法-077-085-查找算法

最新推荐文章于 2022-12-15 15:38:48 发布
最新推荐文章于 2022-12-15 15:38:48 发布
阅读量132 收藏
点赞数
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46998705/article/details/108303354
版权

077 线性查找分析和实现

在java中，常用的查找有四种

  • 顺序（线性）查找
  • 二分查找/折半查找
  • 插值查找
  • 斐波那契查找

线性查找
有一个数列：{1，8，10，89，1000，1234}，判断数列中是否包含此名称【顺序查找】，要求：如果找到了，就提示找到，并给出下标值
思路：如果查找到全部符合条件的值
在这里插入图片描述

package com.old.search.seqSearch077;

public class SeqSearch {
    public static void main(String[] args) {
        int[] arr = {1, 9, 11, -1, 34, 89};
        int i = seqSearch(arr, 789);
        System.out.println(i);
    }

    /**
     * 找到一个满足条件的值，就返回
     * @param arr
     * @param value
     * @return
     */
    public static int seqSearch(int[] arr, int value) {
        //线性查找就是逐一比对，发现有相同值，就返回下标
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) {
                return i;
            }
        }
        return -1;
    }
}

078-080 二分查找算法

078 二分查找算法思路图解

二分查找法要在有序数组中使用
对一个有序数组进行二分查找{1，8，10，89，1000，1234}，输入一个数看该数组是否存在此数，并且求出下标，如果没有就提示”没有这个数“

{1，8，10，89，1000，1000，1234}，当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到

思路分析

  • 首先确定该数组中间的下标 mid = (lfet + right) / 2
  • 然后让老板娘查找的数 findVal 和 arr[mid] 比较
  • findVal > arr[mid] ，说明你要查找的数在 mid 的右边，因此需要递归向右查找
  • findVal < arr[mid] ，说明你要查找的数在 mid 的左边，因此需要递归向左查找
  • findVal = arr[mid] 说明找到，就返回

什么时候需要结束递归？

  • 找到就结束递归
  • 递归完整个数组，仍然没有找到 findVal，也需要结束递归, 当 left > right 就需要退出

在这里插入图片描述

079 二分查找算法代码实现

package com.old.search.BinarySearch_078_080;

/**
 * 注意使用二分查找的前提是该数组是有序的,
 *
 * @author
 */
public class BinarySearch {

    public static void main(String[] ew) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        int i = binarySearch(arr, 0,
                arr.length - 1, 10000);
        System.out.println(i);
    }

    /**
     * 二分查找法
     *
     * @param arr     数组
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 需要查找的值
     * @return 如果找到返回下标，如果没有找到，返回 -1
     */
    public static int binarySearch(int[] arr, int left, int right, int findVal) {
        //当 left 大于了 right 时，说明递归了整个数组，但是没有找到
        if (left > right){
            return -1;
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];
        //向右递归
        if (findVal > midVal) {
            return binarySearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {//向左递归
            return binarySearch(arr, left, mid - 1, findVal);
        } else /*if (midVal == findVal)*/ {
            return mid;
        }

        //return -1;
    }

}

080 二分查找算法功能完善

{1，8，10，89，1000，1000，1234}，当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到

package com.old.search.BinarySearch_078_080;

import java.util.ArrayList;
import java.util.List;

/**
 * 注意使用二分查找的前提是该数组是有序的,
 *
 * @author
 */
public class BinarySearch {

    public static void main(String[] ew) {
        //int[] arr = {1, 8, 10, 89, 1000, 1000, 1000, 1000, 1234, 1000}; 这种情况是无法找出最后一个的，因为二分查找必须是要有序的
        int[] arr = {1, 8, 10, 89, 1000, 1000, 1000, 1000, 1234};
        System.out.println("数组长度：" + arr.length);
        int i = binarySearch(arr, 0,
                arr.length - 1, 1000);
        System.out.println(i);
        List list = binarySearchMany(arr, 0,
                arr.length - 1, 1000, new ArrayList());
        System.out.println(list);
        list = videoBinarySearchMany(arr, 0,
                arr.length - 1, 1000);
        System.out.println(list);
        list = myBinarySearchMany(arr, 0,
                arr.length - 1, 1000);
        System.out.println(list);
    }

    /**
     * 二分查找法
     *
     * @param arr     数组
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 需要查找的值
     * @return 如果找到返回下标，如果没有找到，返回 -1
     */
    public static int binarySearch(int[] arr, int left, int right, int findVal) {
        //当 left 大于了 right 时，说明递归了整个数组，但是没有找到
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];
        //向右递归
        if (findVal > midVal) {
            return binarySearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {//向左递归
            return binarySearch(arr, left, mid - 1, findVal);
        } else /*if (midVal == findVal)*/ {
            return mid;
        }

        //return -1;
    }

    /**
     * {1，8，10，89，1000，1000，1234}，当一个有序数组中，
     * 有多个相同的数值时，如何将所有的数值都查找到
     * <p>
     * 思路分析:
     * 1. 在找到 mid 索引值，不要马上返回
     * 2. 向 mid 索引值的左边扫描，将所有满足 1000 的元素的下标，加入到集合中
     * 3. 向 mid 索引值的右边扫描，将所有满足 1000 的元素下标，加入到集合中
     * 4. 将集合返回
     *
     * @param arr     数组
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 需要查找的值
     * @return 如果找到返回下标，如果没有找到，返回 -1
     */
    public static List binarySearchMany(int[] arr, int left, int right, int findVal, List indexList) {
        //当 left 大于了 right 时，说明递归了整个数组，但是没有找到
        if (left > right) {
            return indexList;
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];
        //向右递归
        if (findVal > midVal) {
            return binarySearchMany(arr, mid + 1, right, findVal, indexList);
        } else if (findVal < midVal) {//向左递归
            return binarySearchMany(arr, left, mid - 1, findVal, indexList);
        } else {
            /**
             * 1. 在找到 mid 索引值，不要马上返回
             * 2. 向 mid 索引值的左边扫描，将所有满足 1000 的元素的下标，加入到集合中
             * 3. 向 mid 索引值的右边扫描，将所有满足 1000 的元素下标，加入到集合中
             * 4. 将集合返回
             */
            int temp = mid - 1;
            //向 mid 索引值的左边扫描，将所有满足 1000 的元素的下标，加入到集合中
            while (true) {
                if (temp < 0 || arr[temp] != findVal) {
                    break;
                }
                //否则，就把 temp 放入到集合中
                indexList.add(temp);
                //temp 左移
                temp -= 1;
            }
            indexList.add(mid);

            //向 mid 索引值的右边扫描，将所有满足 1000 的元素下标，加入到集合中
            temp = mid + 1;
            while (true) {
                if (temp > arr.length - 1 || arr[temp] != findVal) {
                    break;
                }
                //否则，就把 temp 放入到集合中
                indexList.add(temp);
                //temp 左移
                temp += 1;
            }

            return indexList;
        }

    }


    /**
     * {1，8，10，89，1000，1000，1234}，当一个有序数组中，
     * 有多个相同的数值时，如何将所有的数值都查找到
     * <p>
     * 思路分析:
     * 1. 在找到 mid 索引值，不要马上返回
     * 2. 向 mid 索引值的左边扫描，将所有满足 1000 的元素的下标，加入到集合中
     * 3. 向 mid 索引值的右边扫描，将所有满足 1000 的元素下标，加入到集合中
     * 4. 将集合返回
     *
     * @param arr     数组
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 需要查找的值
     * @return 如果找到返回下标，如果没有找到，返回 -1
     */
    public static List videoBinarySearchMany(int[] arr, int left, int right, int findVal) {
        //当 left 大于了 right 时，说明递归了整个数组，但是没有找到
        if (left > right) {
            return new ArrayList();
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];
        //向右递归
        if (findVal > midVal) {
            return videoBinarySearchMany(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {//向左递归
            return videoBinarySearchMany(arr, left, mid - 1, findVal);
        } else {

            List resIndexList = new ArrayList();
            /**
             * 1. 在找到 mid 索引值，不要马上返回
             * 2. 向 mid 索引值的左边扫描，将所有满足 1000 的元素的下标，加入到集合中
             * 3. 向 mid 索引值的右边扫描，将所有满足 1000 的元素下标，加入到集合中
             * 4. 将集合返回
             */
            int temp = mid - 1;
            //向 mid 索引值的左边扫描，将所有满足 1000 的元素的下标，加入到集合中
            while (true) {
                if (temp < 0 || arr[temp] != findVal) {
                    break;
                }
                //否则，就把 temp 放入到集合中
                resIndexList.add(temp);
                //temp 左移
                temp -= 1;
            }
            resIndexList.add(mid);

            //向 mid 索引值的右边扫描，将所有满足 1000 的元素下标，加入到集合中
            temp = mid + 1;
            while (true) {
                if (temp > arr.length - 1 || arr[temp] != findVal) {
                    break;
                }
                //否则，就把 temp 放入到集合中
                resIndexList.add(temp);
                //temp 左移
                temp += 1;
            }

            return resIndexList;
        }

    }


    /**
     * int[] arr = {1, 8, 10, 89, 1000, 1000, 1000, 1000, 1234, 1000}; 这种情况是无法找出最后一个的，因为二分查找必须是要有序的
     * 目前这个自己写的有问题，数组越界了
     * @param arr
     * @param left
     * @param right
     * @param findVal
     * @return
     */
    public static List myBinarySearchMany(int[] arr, int left, int right, int findVal) {
        //当 left 大于了 right 时，说明递归了整个数组，但是没有找到
        if (left > right) {
            return new ArrayList();
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];
        //向右递归
        if (findVal > midVal) {
            return videoBinarySearchMany(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {//向左递归
            return videoBinarySearchMany(arr, left, mid - 1, findVal);
        } else {

            List resIndexList = new ArrayList();
            /**
             * 1. 在找到 mid 索引值，不要马上返回
             * 2. 向 mid 索引值的左边扫描，将所有满足 1000 的元素的下标，加入到集合中
             * 3. 向 mid 索引值的右边扫描，将所有满足 1000 的元素下标，加入到集合中
             * 4. 将集合返回
             */
            int temp = mid - 1;
            //向 mid 索引值的左边扫描，将所有满足 1000 的元素的下标，加入到集合中
            while (true) {
                if (temp < 0 && arr[temp] != findVal) {
                    break;
                }
                //否则，就把 temp 放入到集合中
                resIndexList.add(temp);
                //temp 左移
                temp -= 1;
            }
            resIndexList.add(mid);

            //向 mid 索引值的右边扫描，将所有满足 1000 的元素下标，加入到集合中
            temp = mid + 1;
            while (true) {
                if (temp > arr.length - 1 && arr[temp] != findVal) {
                    break;
                }
                //否则，就把 temp 放入到集合中
                resIndexList.add(temp);
                //temp 左移
                temp += 1;
            }

            return resIndexList;
        }
    }
}

081-082 插值查找算法

081 插值查找算法工作原理

插值算法查找原理介绍：

  • 插值查找延河类似于二分查找，不同的是托付查找每次从自适应 mid 处开始查找
  • 将折半查找中的求 mid 索引的公式， low 表示左边索引 left，high 表示右边索引 right 。key 就是 infdVal
  • int mid = low + (high - low) * (key - arr[low]) / arr(high - arr[low]); //插值索引 ， 对应前面的公式，代码中变为：int mid = left + (right - left) * (fidVal - arr[left]) / (arr[right] - arr[left])

在这里插入图片描述

082 插值查找算法代码实现

注意事项：

  • 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快
  • 关键字分布不均匀的情况下，该方法不一定比折半查找要好
package com.old.search.insertSearch_081_082;

import java.util.Arrays;

public class InsertSearch {
    public static void main(String[] qwe) {
        int[] arr = new int[100];
        int length = arr.length;
        for (int i = 0; i < length; i++) {
            arr[i] = (i + 1);
        }
        System.out.println(Arrays.toString(arr));
        int i = insertValueSearch(arr, 0, length - 1, 100);
        System.out.println(i);
    }

    /**
     * 编写插值查找算法
     *
     * @param arr     数组
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 需要查找的值
     * @return 如果找到返回下标，如果没有找到，返回 -1
     */
    public static int insertValueSearch(int[] arr, int left, int right, int findVal) {
        //left 大于 right 或者 查找的值大小或小于小于值 这句话是一定需要的
        if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
            return -1;
        }
        //核心在这句话
        int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
        int midVal = arr[mid];

        if (findVal > midVal) {
            return insertValueSearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {
            return insertValueSearch(arr, left, mid - 1, findVal);
        } else {
            return mid;
        }
    }


}

083-085 斐波那契查找算法

斐波那契查找算法原理

基本介绍

  • 黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是 0.618 。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意想不到的效果。
  • 斐波那契数列（1，1，2，3，5，8，13，21，34，55）发现斐波那契数列的两个相邻数的比例，无限接近 黄金分割 0.618

原理
斐波那契查找原理与前两种相似，仅仅改变了蹭结点（mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近。即mid = low + F(k-1)-1 (F 代表斐波那契数列）

对 F(k - 1) - 1 的理解

  • 由斐波那契数列 F[k] = F[k-1] 的性质，可以得到 (F[k] - 1) = （F[k-1]-1) + (F[k - 2] - 1) + 1。该式说明，只要顺序表的长度为 F[k] - 1 ，则可以将该表分成长度为 F[k - 1] - 1 和 F[k - 2] - 1 的再做，即如图所示。从而中间的位置为 mid = low + F(k - 1) - 1。
  • 类似的，每一子段也可以用相同的方式分割
  • 但顺序表长度 n 不一定刚好等于 F[k] - 1，所以需要将原来的顺序表长度 n 增加至 F[k] - 1。这里的 k 值只要能使得 F[k] - 1 恰好大于或等于 n 即可，由以下代码得到，顺序表长度增加后，新增的位置（从 n + 1 到 F[k] - 1 位置），都赋为 n 位置的值即可。

在这里插入图片描述

084 斐波那契查找代码实现

斐波那契需要有序数组才可执行
以这个数组为例进行查找，输入一个数看该数组是否存在此数：{1，8，10，89，1000，1234}

package com.old.search.FibonacciSearch_082_085;

import java.util.Arrays;

public class FibonacciSearch {

    public static int maxSize = 20;

    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        int i = fibSearch(arr, 12345);
        System.out.println(i);
    }

    /**
     * 因为后面 mid = low + F(k - 1) - 1，需要使用到斐波那契数列，因此
     * 需要先获取到一个斐波那契数列
     * <p>
     * 斐波那契可以递归也可以非递归得到
     * 使用非递归方法得到
     */
    public static int[] fib() {
        int[] f = new int[maxSize];

        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }

        return f;
    }

    /**
     * 编写斐波那契查找算法
     *
     * @param a   数组
     * @param key 需要查找的关键码（值）
     * @return 返回对应下标，如果没有就返回 -1
     */
    public static int fibSearch(int[] a, int key) {
        int low = 0;

        int high = a.length - 1;

        //表示斐波那契分割数值的下标
        int k = 0;

        //存放 mid 值
        int mid = 0;

        //获取斐波那契数列
        int f[] = fib();

        //获取到斐波那契分割数值的下标
        while (high > f[k] - 1) {
            k++;
        }

        /*
        因为 f[k] 可能大于数组的长度 a 的长度，因此需要使用 Arrays类，构造一个新的
        数组，并指向 a

        不足的部分会使用 0 填充
        */
        int[] temp = Arrays.copyOf(a, f[k]);

        /*
        实际上需要使用 a 数组最后的数填充 temp
        举例：
        原数组
        temp 填充之后  {1, 8, 10, 89, 1000, 1234,0, 0, 0}，
        这个for循环将这个将 temp 变为 {1, 8, 10, 89, 1000, 1234, 1234, 1234, 1234}，
        */
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = a[high];
        }

        //使用 while 来循环处理，找到 key
        //只要这个条件满足，就可以一起找
        while (low <= high){
            mid = low + f[k - 1] - 1;
            //说明我们应该继续向，数组的前面查找（左边）
            if (key < temp[mid]){
                high = mid - 1;
                /*
                为什么是 k**
                1.全部元素 = 前面的元素 + 后面的元素
                2. f[k] = f[k - 1] + f[k - 2]
                3. 因为前面有 f[k - 1] 个元素，所以可以继续拆分 f[k - 1] = f[k - 2] + f[k - 3]
                即在 f[k - 1] 的前面继续查找，k--
                即下次循环的时候 mid = f[k - 1 - 1] - 1
                */
                k--;
            }else if (key > temp[mid]){
                //说明应该向数组的后面查找
                low = mid + 1;
                /**
                 * 为什么是 k -= 2
                 * 1. 全部元素 = 前面的元素 + 后面的元素
                 * 2. f[k] = f[k - 1] + f[k - 2]
                 * 3. 因为后面我们有 f [k - 2] 所以可以继续拆分 f[k - 1] = f[k - 3] + f[k - 4]
                 * 4. 即在 f[k - 2] 的前面进行查找 k -= 2
                 * 5. 即下次循环 mid = f[k - 1 - 2] - 1
                 */
                k -= 2;
            }else {
                //需要确定，返回的是哪个下标
                if (mid <= high){
                    return mid;
                }else {
                    return high;
                }
            }
        }
        //如果整个 while 循环中都没有找到，说明没有找到 返回 -1
        return -1;
    }
}

修改一些之后的版本

import java.util.Arrays;

public class FibonacciSearch {
    public static int maxSize = 20;

    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        int i = fibSearch(arr, 12345);
        System.out.println(i);
    }

    /**
     * 因为后面 mid = low + F(k - 1) - 1，需要使用到斐波那契数列，因此
     * 需要先获取到一个斐波那契数列
     * <p>
     * 斐波那契可以递归也可以非递归得到
     * 使用非递归方法得到
     */
    public static int[] fib() {
        int[] f = new int[maxSize];

        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }

        return f;
    }

    /**
     * 编写斐波那契查找算法
     *
     * @param a   数组
     * @param key 需要查找的关键码（值）
     * @return 返回对应下标，如果没有就返回 -1
     */
    public static int fibSearch(int[] a, int key) {
        int low = 0;

        int high = a.length - 1;

        //表示斐波那契分割数值的下标
        int k = 0;

        //存放 mid 值
        int mid = 0;

        //获取斐波那契数列
        int f[] = fib();

        //获取到斐波那契分割数值的下标
        while (high > f[k] - 1) {
            k++;
        }

        /*
        因为 f[k] 可能大于数组的长度 a 的长度，因此需要使用 Arrays类，构造一个新的
        数组，并指向 a

        不足的部分会使用 0 填充
        */
        int[] temp = Arrays.copyOf(a, f[k]);

        /*
        实际上需要使用 a 数组最后的数填充 temp
        举例：
        原数组
        temp 填充之后  {1, 8, 10, 89, 1000, 1234,0, 0, 0}，
        这个for循环将这个将 temp 变为 {1, 8, 10, 89, 1000, 1234, 1234, 1234, 1234}，
        */
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = a[high];
        }

        //使用 while 来循环处理，找到 key
        //只要这个条件满足，就可以一起找
        while (low <= high) {
            mid = low + f[k - 1] - 1;
            //说明我们应该继续向，数组的前面查找（左边）
            if (key < temp[mid]) {
                high = mid - 1;
                /*
                为什么是 k**
                1.全部元素 = 前面的元素 + 后面的元素
                2. f[k] = f[k - 1] + f[k - 2]
                3. 因为前面有 f[k - 1] 个元素，所以可以继续拆分 f[k - 1] = f[k - 2] + f[k - 3]
                即在 f[k - 1] 的前面继续查找，k--
                即下次循环的时候 mid = f[k - 1 - 1] - 1
                */
                k--;
            } else if (key > temp[mid]) {
                //说明应该向数组的后面查找
                low = mid + 1;
                /**
                 * 为什么是 k -= 2
                 * 1. 全部元素 = 前面的元素 + 后面的元素
                 * 2. f[k] = f[k - 1] + f[k - 2]
                 * 3. 因为后面我们有 f [k - 2] 所以可以继续拆分 f[k - 1] = f[k - 3] + f[k - 4]
                 * 4. 即在 f[k - 2] 的前面进行查找 k -= 2
                 * 5. 即下次循环 mid = f[k - 1 - 2] - 1
                 */
                k -= 2;
            } else {
                //需要确定，返回的是哪个下标
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        //如果整个 while 循环中都没有找到，说明没有找到 返回 -1
        return -1;
    }
}

085 斐波那契查找算法小结

1854君
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法-小例子.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
极客时间-数据结构与算法-王争.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
Java数组-二分查找原理
周将的博客
07-28 1261
Java数组-二分查找原理
【数组】之查找详解
Java学习
07-22 248
在java中常用的查找方法有两种：顺序查找和二分法查找（又叫折半查找）。 一、顺序查找 基本思想：顺序查找算法，从数组中的第0个位置到数组结束逐个的与给定的目标进行匹配，如果匹配到即返回位置，查找数组中所有的值都没有匹配上说明没找到即返回-1。 public static int sequenceSearch(int[] arr, int key) { for (int i = 0;...
数组原理详解及python语法实现
weixin_45459911的博客
03-23 760
一、基本特点 1、数组（Array）是一种线性表数据结构。 说到这里，就先介绍一下线性表和非线性表： 线性表就是数据排成一条线一样的数据结构，每个线性表最多只有前后两个方向，常见线性表数据结构有：数组、链表、队列、栈。 非线性表与线性相对立，在非线性表中，数据之间并不是简单的前后关系，常见数据结构有：二叉树、堆等。 数组作为典型的线性表数据结构，其用一组连续的内存空间，来存储一组具有相同类型的数据...
Java数组的几种常用操作方法(排序算法及查找)
jxq1994的博客
07-27 8635
数组的查找 查找是在数组中寻找特定元素的过程。 线性查找法 线性查找法将要查找的关键字key与数组中的元素逐个进行比较。如果匹配成功，线性查找法则返回与关键字匹配的元素在数组中的下标；如果没有匹配成功，则返回-1。下面给出线性查找法的程序： private static int LinearSearch(int[] list,int key) { // TODO A...
查找算法的学习
捕翼^的博客
05-16 213
查找算法 在java中，常用的查找有四种: 顺序(线性)查找 二分查找/折半查找 插值查找 斐波那契查找 线性查找 线性查找就是顺序查找 有一个数列： {1,8, 10, 89, 1000, 1234} ，判断数列中是否包含此名称【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值。如果查找到全部符合条件的值，则全部返回 代码实现： package com.atguigu.search; import java.util.ArrayList; import java.util.List; /*
数据结构与算法-学习笔记 Java 版.zip
最新发布
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
DataStructure-尚硅谷-数据结构与算法-数据结构.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
python算法与数据结构-常用查找算法一(37)
weixin_30699955的博客
06-25 291
一、什么是查找 查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。 查找表（Search Table）：由同一类型的数据元素（或记录）构成的集合 关键字（Key）：数据元素中某个数据项的值，又称为键值。 主键（Primary Key）：可唯一地标识某个数据元素或记录的关键字。 　　搜索是在一个项目集合中找到一个特定项目的算法...
Java数据结构-折半查找(二分查找)
02-04 133
查找要求： 1.必须采用顺序存储结构。 2.必须按关键字大小有序排列。 查找思想： 首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。 代码1-非递归查找： public static int Search(int arr[], in
对数组中数据的查找方法详解——二分查找（折半查找）和线性查找
lmbuhuiku的博客
12-15 1528
对数组中数据的查找方法详解——二分查找（折半查找）和线性查找。 最详细解析，包看包会！！！
初识数组查找（顺序查找法和二分查找法）
forever的博客
09-25 3567
先来了解一下查找是干什么的？查找就是给定一个值，然后在大量信息中寻找这个特定的值。在计算机应用中，查找是常用的基本算法，一般有七大查找算法，分别为：顺序查找、二分查找、插值查找、斐波那契查找、树表查找、分块查找、哈希查找。 今天，forever 也是初识查找算法，就先来说说顺序查找和二分查找吧！ 一、顺序查找（线性查找） 查找原理：顺序查找也叫线性查找，就是从数组的开头开始顺序扫描，依次将其扫描值与其给定值比较。若相等则查找成功；若扫描结束，仍未找到该值，则查找失败。 1.C语言线性查找实现顺序数组查找对应
二分查找与实例分析
乌龙茶不是可燃的嘛的博客
07-30 178
二分查找 二分查找思路分析 1.首先确定该数组的中间的下标 mid = (left + right)/2 mid = left +(right -left)/2 2.然后让需要查找的数findval和arr[mid]比较 findval > arr[mid] 说明你要查找的数在mid的右边，因此需要递归的向右查找 findval < arr[mid] 说明你要查找的数在mid的左边，因此需要递归的向左查找 findval == arr[mid] 说明你要查找的数找到了，返回 结束递归的条件： 1
java的折半查找_java基础-数组的折半查找原理
weixin_39723899的博客
02-12 285
java基础-数组的折半查找原理作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。如果让你写一个数组的查找功能，需求如下：在一个数组中，找一个元素，是否存在于数组中， 如果存在就返回这个元素，如果没有这个元素，就可以返回一个负数。今天我们来介绍一下折半查找的原理，并自己用代码实现折半查找。一.数组的折半查找原理二分查找发，也叫折半查找，它的前提就是被查找的数组的元素，必须是有序(本篇博...
数据结构算法——二分查找（BinarySearch）
WXH0722的博客
07-09 360
1.二分查找的思路解析 二分查找(Bineary Search)： 1.首先确定该数组的中间下标 mid = (left+right)/2; 2.将要查找的数（findVal）与arr[mid]比较，假设此处数组为从小到大排序，会出现以下情况： (1) findVal > arr[mid] ,待查找数在arr[mid]的右边，向右递归查找 (2) findVal < arr[m...
二分查找
莫逸雪的博客
12-30 154
题目 {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000. 代码 public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int[] arr={1,8,10,89...
二分查找法-当有序数组中有多个相同的数值
ytc958374686的博客
12-24 1613
思路：因为数组是有序的，当找到了想要查询的值的位置的时候，查看其左右两边的值是否和它相等，相等则把位置记录下来。 import java.util.ArrayList; public class BinarySearch { public static void main(String[] args) { int[] array = {1, 8, 10, 89, 100...
C语言解析数据结构与算法-金典教材解析
"《数据结构与算法-C语言描述-金典算法教材》是Mark Allen Weiss的经典著作，专注于数据结构和算法分析，采用C语言作为实现工具。本书在全球500多所大学被用作教材，深入浅出地介绍了抽象数据类型和算法效率评估。" ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值