[笔记]查找算法(线性查找、二分查找、插值插值、斐波那契查找)、排序算法(堆排序)

最新推荐文章于 2022-04-30 21:46:54 发布
最新推荐文章于 2022-04-30 21:46:54 发布
阅读量349 收藏 2
点赞数 1
文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44072872/article/details/108745277
版权

查找算法

1、查找算法

常用的查找算法有：

  1. 顺序（线性）查找
  2. 二分查找/折半查找
  3. 插值查找
  4. 斐波那契（黄金分割）查找

1.1、线性查找算法

  1. 线性查找的数列可以是有序的，也可以是无序的。
  2. 有一个数列： {1, 9, 11, -1, 34, 89}，判断数列中是否包含待查找的数值。要求：如果找到了，就提示找到，并给出待查找值的下标值。
public class SeqSearch {
    public static void main(String[] args) {
        int arr[] = {1, 9, 11, -1, 34, 89}; //无序的数组
        int index = seqSearch(arr, 11);
        if (index == -1) {
            System.out.println("没有找到");
        } else {
            System.out.println("找到，下标为" + index);
        }
    }

    /**
     * 线性查找算法
     * 这里实现的线性查找是只要找到一个满足条件的值，就返回其下标值
     * 也就是说 默认数组是不重复的
     * 找到即返回其下标值，未找到返回-1
     *
     * @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;
    }
}
  1. 数组重复{1, 9, 89, 11, -1, 89, 34, 89, 9}，要求查找到全部符合条件的值。
import java.util.ArrayList;

public class SeqSearch2 {
    public static void main(String[] args) {
        int arr[] = {1, 9, 89, 11, -1, 89, 34, 89, 9}; //无序的重复数组
        ArrayList<Integer> arrayList = seqSearch2(arr, 89);
        if (arrayList.isEmpty()) {
            System.out.println("没有找到");
        } else {
            System.out.println("找到，下标为" + arrayList);
        }
    }

    /**
     * 线性查找算法
     * 这里实现的线性查找是要求找到重复数组中，所有符合条件值的下标
     * 找到即返回其下标集合，未找到返回空集合
     *
     * @param arr   待查找的数组
     * @param value 待查找的值
     * @return 待查找值在数组中的下标值集合
     */
    public static ArrayList<Integer> seqSearch2(int[] arr, int value) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        //线性查找是逐一比对，发现有相同值，就返回下标值
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) {
                arrayList.add(i);
            }
        }
        return arrayList;
    }
}

1.2、二分查找/折半查找算法

  1. 二分查找要求在一个有序数组中才可以使用。如果是无序数组，可以先进行排序，再进行二分查找。
  2. 对有序数组{1, 8, 10, 89, 1000, 1234}进行二分查找，输入一个数看看该数组是否存在此数，并求出其下标，如果不存在则提示"没有找到"。

二分查找的思路分析：

  1. 首先确定该数组的中间下标
    mid = ( left + right ) / 2
  2. 然后让需要查找的数findVal和arr[mid]进行比较
    2.1 findVal > arr[mid]，说明你要查找的数在mid的右边，因此需要向右递归的查找。
    2.2 findVal < arr[mid]，说明你要查找的数在mid的左边，因此需要向左递归的查找。
    2.3 findVal == arr[mid]，说明找到，就返回。

// 什么时候我们结束递归？

  1. 找到就结束递归。
  2. 递归完整个数组，仍然没有找到findVal，此时也需要结束递归，条件判断可写为，当left > right ，就结束递归。
public class BinarySearch {
    public static void main(String[] args) {
        //注意：使用二分查找的前提，必须要求数组是有序的。
        int arr[] = {1, 8, 10, 89, 1000, 1234}; //无重复的数组
        int index = binarySearch(arr, 0, arr.length, 1000);
        if (index == -1) {
            System.out.println("没有找到");
        } else {
            System.out.println("找到，下标为" + index);
        }
    }

    //二分查找算法
    /**
     * @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 { //找到，返回下标值
            return mid;
        }
    }
}
  1. {1, 8, 10, 89, 1000, 1234}，当一个有序数组中，有多个相同的数组时，如何将所有的数组都找到并返回其下标，比如这里的1000。

思路分析：

  1. 在找到mid 索引值时，不要马上返回。
  2. 向mid 索引值的左边进行扫描，将左边所有满足条件（这里指1000）的元素的下标，加入到ArrayList集合中。
  3. 向mid 索引值的右边进行扫描，将右边所有满足条件（这里指1000）的元素的下标，加入到ArrayList集合中。
  4. 将ArrayList集合返回
public class BinarySearch2 {
    public static void main(String[] args) {
        //注意：使用二分查找的前提，必须要求数组是有序的。
        int arr[] = {1, 8, 10, 89, 1000, 1000,1000, 1000, 1234};
        ArrayList<Integer> arrayList = binarySearch2(arr, 0, arr.length, 1000);
        if (arrayList.isEmpty()) {
            System.out.println("没有找到");
        } else {
            System.out.println("找到，下标为" + arrayList);
        }
    }

    //二分查找算法

    /**
     * @param arr     数组
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 要查找的值
     * @return 如果找到就返回arrayList集合，如果没有找到，就返回空集合
     */
    public static ArrayList<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        //当 left > right ，说明已经递归完整个数组，但仍然没有找到
        if (left > right) {
            return arrayList;
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];
        if (findVal > midVal) { //向右进行递归
            return binarySearch2(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) { //向左进行递归
            return binarySearch2(arr, left, mid - 1, findVal);
        } else {
            //找到mid，先加入到arrayList中
            arrayList.add(mid);
            // 在找到mid 索引值时，不要马上返回。
            // 向mid 索引值的左边进行扫描，将左边所有满足条件（这里指1000）的元素的下标，加入到ArrayList集合中。
            int temp = mid - 1;
            while (true) {
                //这里的判断条件：
                //temp < 0 即向左扫描完所有，break跳出循环
                //或者 当找到的值不等于待查找的值时，break，因为是有序数组，所以只要不查找到不等于即可
                if (temp < 0 || arr[temp] != findVal) {
                    break;
                }
                //否则，就将temp放入到集合中
                arrayList.add(temp);
                temp -= 1; //temp 左移
            }
            // 向mid 索引值的右边进行扫描，将右边所有满足条件（这里指1000）的元素的下标，加入到ArrayList集合中。
            temp = mid + 1;
            while (true) {
                if (temp > arr.length - 1 || arr[temp] != findVal) {
                    break;
                }
                arrayList.add(temp);
                temp += 1;
            }
            // 将ArrayList集合返回
            return arrayList;
        }
    }
}

1.3、插值查找算法

  1. 插值查找原理介绍：
    插值查找算法类似于二分查找，不同的是插值查找每次从自适应的mid处开始查找。
  2. 将二分查找中求mid 索引的公式改成以下公式，left 表示左边索引，right 表示右边索引，findVal 表示要查找的值。
    在这里插入图片描述
    用代码表示为：
    在这里插入图片描述
  3. 插值查找注意事项：
    3.1 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快。
    3.2 关键字分布不均匀的情况下，该方法不一定比二分查找要好。
  4. 插值查找案例：
    请对一个 1 ~ 100 的有序数组进行插值查找，输入一个数看看该数组是否存在此数，并求出其下标，若不存在，则提示"没有找到"。
public class InsertValueSearch {
    public static void main(String[] args) {
        int[] arr = new int[100];
        for (int i = 0; i < 100; i++) {
            arr[i] = i + 1;
        }
        int index = insertValSearch(arr, 0, arr.length - 1, 55);
        if (index == -1) {
            System.out.println("没有找到");
        } else {
            System.out.println("找到，下标为：" + index);
        }
    }

    //插值查找算法
    //说明：插值查找算法也要求数组是有序的
    public static int insertValSearch(int arr[], int left, int right, int findVal) {
        //注意：findVal < arr[0] 和 findVal > arr[arr.length - 1] 必须需要
        //否则，我们得到的mid可能越界
        if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
            return -1;
        }
        //求出插值查找的自适应mid
        int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
        int midVal = arr[mid];
        if (findVal > midVal) { //向右边递归扫描
            return insertValSearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {
            return insertValSearch(arr, left, mid - 1, findVal);
        } else {
            return mid;
        }
    }
}

1.4、斐波那契（黄金分割法）查找算法

  1. 斐波那契（黄金分割法）查找基本介绍：
    1）黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这一部分之比。取其前三位数字的近似值是0.618。
    2）斐波那契数列{1, 1, 2, 3, 5, 8, 13, 21, 34, 55}，发现斐波那契数列的两个相邻数的比例 ，无限接近黄金分割值0.618。
  2. 斐波那契原理：
    斐波那契查找原理与二分查找、插值查找两种相似，仅仅改变了中间结点(mid)的位置，mid不再是中间或插值得到的位置，而是位于黄金分割点附近，即 mid = low + F(k-1) - 1 (F代表斐波那契数列)，如下图所示：
    在这里插入图片描述

对F（k-1）-1的理解：

  1. 由斐波那契数列F[K] = F[K-1] + F[K-2]的性质，可以得到
    (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。
  2. 类似的，每一段字段也可以用相同的方式分割。
  3. 但顺序表长度n不一定刚好等于F[k] - 1，所以需要将原来的顺序表长度n增加至F[k] - 1。这里的k值只要能使得F[k] - 1恰好大于或者等于 n 即可，由以下代码得到，顺便表长度增加后，新增的位置（从n+1 到F[k] - 1位置）都赋值为n位置的值即可。
	while(n > fib(k) - 1){
		k++;
	}
  1. 斐波那契查找案例：
    请对一个有序数组进行斐波那契查找{1, 8, 10, 89, 1000, 1234}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示"没有找到"。
import java.util.Arrays;

public class FibonacciSearch {
    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        int index = fibSearch(arr, 1234);
        if (index == -1) {
            System.out.println("没有找到");
        } else {
            System.out.println("找到，下标为：" + index);
        }
    }

    //因为后面 mid = low + F(k-1) - 1，需要使用到斐波那契数列，因此我们需要先获取到一个斐波那契数列
    //非递归方法得到一个斐波那契数列
    public static int[] fib() {
        int maxSize = 20;
        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;
    }

    //使用非递归的方式编写斐波那契查找算法
    public static int fibSearch(int[] arr, int findVal) {
        int low = 0;
        int high = arr.length - 1;
        int k = 0; //表示斐波那契分割数值的下标
        int mid = 0; //存放mid值
        int f[] = fib(); //获取到斐波那契数列
        //获取到斐波那契分割数值的下标
        while (high > f[k] - 1) {
            k++;
        }
        //因为 f[k] 值可能大于arr的长度，因此我们需要使用Arrays类，构造一个新的数组，并指向temp[]
        //不足的部分Arrays类会自动用0补充
        int[] temp = Arrays.copyOf(arr, f[k]);
        //实际上需要使用arr数组的最后一个数值补充temp空余部分
        //例如：
        //temp = {1, 8, 10, 89, 1000, 1234, 0, 0} => {1, 8, 10, 89, 1000, 1234, 1234, 1234};
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = arr[high];
        }

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

2、排序算法

2.1、堆排序

2.1.1、堆排序基本介绍

1）堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好平均时间复杂度均为O(nlogn)，它也是不稳定排序。
2）堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆。注意：没有要求结点的左孩子的值和右孩子的值的大小关系。
3）每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
4）大顶堆举例说明：
在这里插入图片描述
5）小顶堆举例说明：
在这里插入图片描述
6）一般升序采用大顶堆，降序采用小顶堆（采用堆后会进行排序比较）

2.1.2、堆排序的基本思想

堆排序的基本思想是：

  1. 将待排序序列构造成一个大顶堆
  2. 此时，整个序列的最大值就是堆顶的根节点。
  3. 将其与末尾元素进行交换，此时末尾就为最大值。
  4. 然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
2.1.3、堆排序步骤图解说明

要求：给你一个数组{4,6,8,5,9},要求使用堆排序法，将数组升序排序。
步骤一：构造初始堆。
将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。原始的数组[4,6,8,5,9]。

  1. 假设给定无序序列结构如下：
    在这里插入图片描述
  2. 此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点下标为arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。
    在这里插入图片描述
  3. 找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。
    在这里插入图片描述
  4. 这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。
    在这里插入图片描述
    此时，我们就将一个无序序列构造成了一个大顶堆。

步骤二：将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

  1. 将堆顶元素9和末尾元素4进行交换。
    在这里插入图片描述
  2. 重新调整树结构，使其继续满足堆定义。
    在这里插入图片描述
  3. 再将堆顶元素8与末尾元素5进行交换，得到第二大元素8。

在这里插入图片描述
4. 后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序。
在这里插入图片描述
再简单总结下堆排序的基本思路：

  1. 将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
  2. 将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
  3. 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
2.1.4、堆排序代码实现

要求：给你一个数组{4,6,8,5,9}，要求使用堆排序法，将数组升序排序。
代码实现：

import java.util.Arrays;

public class HeapSort {
    //测试堆排序
    public static void main(String[] args) {
        int arr[] = {4, 6, 8, 5, 9, 10, 99, -1, -4};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    //编写一个堆排序的方法
    public static void heapSort(int arr[]) {
        int temp = 0;
        System.out.println("堆排序");

        //堆排序算法代码：
        //1. 将一个无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }
        //2. 将堆顶元素与末尾元素交换，将最大元素“沉”到数组末端
        //3. 重新调整树结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换，直到整个序列有序
        for (int i = arr.length - 1; i > 0; i--) {
            //交换
            temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            adjustHeap(arr, 0, i);
        }
    }
    //将一个数组（顺序存储的二叉树），调整成一个大顶堆（升序排序用大顶堆，降序用小顶堆）

    /**
     * 作用：完成将以 i 对应的非叶子结点的树调整成大顶堆
     *
     * @param arr    待调整的数组
     * @param i      表示非叶子结点在数组中的索引
     * @param length 表示对多少个元素进行调整，因为length会随着最大值和最小值的交换而减小
     */
    public static void adjustHeap(int arr[], int i, int length) {
        int temp = arr[i]; //先取出当前非叶子结点的值，保存在临时变量中
        //开始调整
        //说明：
        //k = i * 2 + 1 表示k是i结点的左子结点
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && arr[k] < arr[k + 1]) { //说明左右子结点存在，且左子结点的值小于右子结点的值
                k++; //k指向右子结点
            }
            if (arr[k] > temp) { //如果子结点大于父结点
                arr[i] = arr[k]; //把较大的值赋给当前的非叶子结点
                i = k; //!!! i指向k
            }
        }
        //当for循环结束后，我们已经将以i为父结点的树的最大值放在了顶部
        arr[i] = temp; //将temp值放到调整后的位置
    }
}

结果如下：
在这里插入图片描述

•••
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
常见查找算法
Guizy
05-28 1万+
一、顺序查找二、折半查找(二分查找)基本思路: 选定这批数中居中位置的一个数 与所查数进行比较, 看是否为所找之数, 若不是,利用数据的有序性,可以决定所找的数是在选定前还是在之后, 从而很快可以将查找范围缩小一半. 以同样的方法在选定的区域进行查找,每次都会将查找范围缩小一半,从而可以快速的找到所查找之数.#define Length 10 int main() { // 创建数组 int...
十大排序、七大查找算法python实现——堆排序(heap sort)
qq_36614831的博客
07-08 290
十大排序、七大查找算法python实现——堆排序(heap sort) def adjust_heap(L, i): n = len(L) if i >= n/2: return L left_index = 2 * i + 1 right_index = 2 * i + 2 max_index = i if left_index < n and L[left_index] > L[max_..
搜索算法（快排，堆排）
weixin_42369746的博客
06-29 204
数组中的第K个最大元素 # class Solution: # def findKthLargest(self, nums: List[int], k: int) -> int: # if len(nums)<k: # return # low = 0 # high = len(nums) - 1 # self.quicksort(nums,low,high,k) # return.
数据结构与算法：查找、排序、树、堆
weixin_40355471的博客
04-30 453
目录查找算法二分查找跳表散列表哈希算法排序算法冒泡排序插入排序选择排序快速排序归并排序排序算法选择，以qsort()函数为例树二叉树存储二叉树遍历二叉树二叉查找树二叉查找树与散列表平衡二叉查找树AVL树红黑树堆堆和堆排序存储堆堆排序快速排序与堆排序 查找算法 二分查找 二分查找是对一个有序的数据集合进行查找，通过每次跟区间中间的元素对比，将待查找的区间缩小为之前的一半，直到找到元素或者区间为空为止 对于排好序的数组来说，使用二分查找，查找某个元素的时间复杂度为：O(logn) 二分查找的局限性 1、二分查找
使用堆查找前K个最大值兼谈程序优化(中)
weixin_30929295的博客
05-11 151
上篇谈到， 之前的程序使用堆查找前K个最大值的效率并不理想，本篇尝试对程序进行优化，以提高程序效率。 一、 算法设计方面 要提高程序效率， 首先从算法设计方面，即时间复杂度方面考虑。 由于查找前K个最大值总要遍历整个列表，因此，其效率必定不小于线性的，而前面已经谈到，使用堆查找其效率平均情况下可以达到线性， 因此， ...
数据结构实验：实现插值和斐波那契查找
10-12
关于有序表的查找，有折半查找、插值查找、斐波那契查找等，它们的原理和实现方法各有不同，对不同数据的处理也各有优劣。 查找在计算机数据处理中是经常使用的操作。查找算法的效率高低直接关系到应用系统的性能。...
二分查找、插值查找、斐波那契查找对比C++实现
01-10
二分查找，O(logn)的经典查找算法，实现在一个非下降序列中快速查找一个值是否...插值查找是对二分查找的一个扩展，对于接近线性递增的序列效率极高，其他情况效率一般。 斐波那契查找，纯娱乐用的东西，存在意义不明？
二分查找、插值查找、斐波那契查找对比C++的实现
04-18
C++二分查找、插值查找、斐波那契查找对比C++的实现源码，不是完整程序，仅是核心算法文件 想要跑起来 自己要懂得动动手咯
[数据结构与算法] 查找算法
12-22
查找算法 线性查找二分查找差值查找斐波那契查找 鉴于在排序算法时, 搞得比较乱的情况, 导致查找不太方便. 因此, 在写查找算法时, 我会将所有的东西都写在一起, 便于查找和阅读 在java中，我们常用的查找有四种: ...
函数递归练习（斐波那契数列，二分查找）
12-21
2斐波那契数列 public static int fibonacci(int n){ if(n==1||n==2){ return 1; } return fibonacci(n-1)+fibonacci(n-2); } public static void main(String[] args) { int reslut=fibonacci(9); System.out...
五种查找算法总结
llw01的专栏
05-06 919
下列五种查找算法，除顺序查找外，其他算法的思路基本相同： 　　先对数据按某种方法进行排序，然后使用相应的规则查找。 因此，搞清排序算法才是关键。 一、顺序查找 　　条件：无序或有序队列。 　　原理：按顺序比较每个元素，直到找到关键字为止。 　　时间复杂度：O(n) 二、二分查找（折半查找） 　　条件：有序数组 　　原理：查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素
终于从树堆里爬出来了——堆排序(基于二叉树)基本思想、步骤、复杂度及python代码，欢迎交流
weixin_45221012的博客
04-23 240
基于二叉树的堆排序基本思想、步骤及python代码实现，复杂度分析。 图很好理解，代码难理解。
堆排序查找前N个最大数和二分查找算法
wodet的专栏
11-25 3585
先了解堆排序概念:堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。 （1）用大根堆排序的基本思想 ① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区 ② 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足
排序算法之堆(heap)
GeekWill的博客
10-26 4108
排序
【转】七大查找算法总结
zhuhongde的博客
06-23 5428
参考博客 1.顺序查找 思路：从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。 2.二分查找 思路：也称为折半查找，属于有序查找算法。用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，...
堆排序算法详解
热门推荐
Gandoph的博客
10-14 3万+
一、堆排序算法原理和动态图解        将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将它移走(其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次最大值。如此反复执行，就能得到一个有序序列了。这个过程其实就是先构建一个最大/最小二叉堆，然后不停的取出最大/最小元素（头结点），插入到新的队...
测试二分查找、直接选择排序等算法的时间复杂度
sanqima的专栏
07-25 1026
        一、二分查找         二分查找，又称折半查找，进行二分查找的前提是，该线性表或者树已经排好序，这里以线性表为例，假设线性表已经按关键字有序排列，且为递增有序排列。         二分查找的思路：设线性表R[left, right]是当前的查找区间，首先确定该区间的中点位置mid = (left+right)/2, 然后将待查的K值与R[mid].key进行比较，分
python——算法（时间复杂度，空间复杂度，二分查找，排序们）
weixin_30758821的博客
11-28 765
算法（Algorithm）概念：一个计算过程，解决问题的方法 递归的两大特点： 1、自己调用自己　　2、有穷性（python默认只能递归999次）自己修改递归深度：sys.setrecursionlimit(100000) def func1(x): if x>0: print(x) func1(x-1) def func2(x):...
六种查找算法效率比较
淡云阁
07-16 4054
接着上次的排序算法讨论，这次谈的是六种查找算法，分别是：顺序查找、折半查找、二叉树查找、索引查找、开地址哈希查找方法、拉链法哈希查找方法。 　　由于查找一个数的过程，无论运用哪种算法对于电脑来说速度都是非常快的，都在1ms之内，无法用计时函数测试出来。所以为了能够直观准确地表示出各个算法间的差异，此程序用了循环查找的方法，具体的思想是：先随机生成3000个数作为查找的数据源，再随机生成3000（
二分查找、插值查找和斐波那契查找的时间复杂度
最新发布
11-17
二分查找、插值查找和斐波那契查找的时间复杂度如下： 1. 二分查找的时间复杂度为O(log n)。 2. 插值查找的时间复杂度也为O(log n)，但是在数据分布比较均匀的情况下，插值查找的效率比二分查找更高。 3. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值