常见算法简介

已于 2024-03-20 21:10:03 修改
阅读量1.9k 收藏 47
点赞数 48
分类专栏： Java学习 文章标签： 数据结构 java
于 2024-03-18 14:58:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoshuaishuai01/article/details/136786391
版权

查找算法

基本查找（顺序查找）

顺序查找也称为线形查找，属于无序查找算法。从数据结构线的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败。

    public static void main(String[] args) {
        //基本查找/顺序查找
        //核心：
        //从0索引开始挨个往后查找

        //需求：定义一个方法利用基本查找，查询某个元素是否存在
        //数据如下：{131, 127, 147, 81, 103, 23, 7, 79}


        int[] arr = {131, 127, 147, 81, 103, 23, 7, 79};
        int number = 82;
        System.out.println(basicSearch(arr, number));

    }

    //参数：
    //一：数组
    //二：要查找的元素

    //返回值：
    //元素是否存在
    public static boolean basicSearch(int[] arr, int number){
        //利用基本查找来查找number在数组中是否存在
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == number){
                return true;
            }
        }
        return false;
    }

二分查找

​也叫做折半查找，元素必须是有序的，从小到大，或者从大到小都是可以的。如果是无序的，也可以先进行排序。但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义。

核心逻辑：一次排除一半 

    public static void main(String[] args) {
        //二分查找/折半查找
        //核心：
        //每次排除一半的查找范围

        //需求：定义一个方法利用二分查找，查询某个元素在数组中的索引
        //数据如下：{7, 23, 79, 81, 103, 127, 131, 147}

        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
        System.out.println(binarySearch(arr, 150));
    }

    public static int binarySearch(int[] arr, int number){
        //1.定义两个变量记录要查找的范围
        int min = 0;
        int max = arr.length - 1;

        //2.利用循环不断的去找要查找的数据
        while(true){
            if(min > max){
                return -1;
            }
            //3.找到min和max的中间位置
            int mid = (min + max) / 2;
            //4.拿着mid指向的元素跟要查找的元素进行比较
            if(arr[mid] > number){
                //4.1 number在mid的左边
                //min不变，max = mid - 1；
                max = mid - 1;
            }else if(arr[mid] < number){
                //4.2 number在mid的右边
                //max不变，min = mid + 1;
                min = mid + 1;
            }else{
                //4.3 number跟mid指向的元素一样
                //找到了
                return mid;
            }

        }
    }

插值查找

如果我能在二分查找的基础上，让中间的mid点，尽可能靠近想要查找的元素，就更能提高查找的效率了。二分查找中原来查找点计算如下：mid=(low+high)/2, 即mid=low+1/2*(high-low);我们可以将查找的点改进为如下：mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，这样，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。可以理解成根据要查找的值在数组数据值中的比例，缩短查找路径。但是有局限，数据分布均匀的值用这种效果会好一点，不均匀反而会变差；只要把中点计算方式修改一下就好。

斐波那契查找

这个就比较复杂了，先粗略估算数组长度，再在斐波那契数列找一个值，然后将数组扩展为这个数目的元素，（本质上也是一种二分查找）并对这些元素进行分割，缩小范围，进行查找；这个理论上要更高效，这就是数学上的东西了，我数学不好，就不卖弄了，这个不作为重点。

 分块查找

当数据表中的数据元素很多时，可以采用分块查找。汲取了顺序查找和折半查找各自的优点，既有动态结构，又适于快速查找。分块查找适用于数据较多，但是数据不会发生变化的情况，如果需要一边添加一边查找，建议使用哈希查找。

分块查找过程：

  1. 需要把数据分成N多小块，块与块之间不能有数据重复的交集。
  2. 给每一块创建对象单独存储到数组当中
  3. 查找数据的时候，先在数组查，当前数据属于哪一块
  4. 再到这一块中顺序查找

分块原则：

  • 前一块最大值要小于后一块所有；
  • 块数量为数字个数开平方根； 

扩展原则： 

  • 数据没有明显规律时候分块按照不存在交集的逻辑去分
  • 分完之后确定每一块的最大最小值
  • 接着对这些块采用二分法或者顺序遍历看看要查找的数据在不在范围内
  • 在的话遍历找到索引即可

哈希查找后面再说； 

排序算法

冒泡排序

核心逻辑：相邻数据两两比较，小的放前面，大的放后面（升序）；

public static void main(String[] args) {
        /*
            冒泡排序：
            核心思想：
            1，相邻的元素两两比较，大的放右边，小的放左边。
            2，第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推。
            3，如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以。
        */


        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};

        //2.利用冒泡排序将数组中的数据变成 1 2 3 4 5

        //外循环：表示我要执行多少轮。 如果有n个数据，那么执行n - 1 轮
        for (int i = 0; i < arr.length - 1; i++) {
            //内循环：每一轮中我如何比较数据并找到当前的最大值
            //-1：为了防止索引越界
            //-i：提高效率，每一轮执行的次数应该比上一轮少一次。
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //i 依次表示数组中的每一个索引：0 1 2 3 4
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        printArr(arr);




    }

    private static void printArr(int[] arr) {
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

选择排序 

非常像之前比较大小时候采用的“擂台赛”，其过程（升序）如下：

  1. 从0索引开始，就假定它是最小的，然后依次跟后面的数据比大小，如果后面的数据比他小，那么就交换这两个位置的数据，继续拿着0索引的值向后比完，这样一轮下来，第一个位置必定是最小值；
  2. 从索引1开始重复上述过程，重复数组长度-1次就好；
 public static void main(String[] args) {

        /*
            选择排序：
                1，从0索引开始，跟后面的元素一一比较。
                2，小的放前面，大的放后面。
                3，第一次循环结束后，最小的数据已经确定。
                4，第二次循环从1索引开始以此类推。

         */


        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};


        //2.利用选择排序让数组变成 1 2 3 4 5
        //外循环：几轮
        //i:表示这一轮中，我拿着哪个索引上的数据跟后面的数据进行比较并交换
        for (int i = 0; i < arr.length -1; i++) {
            //内循环：每一轮我要干什么事情？
            //拿着i跟i后面的数据进行比较交换
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }


        printArr(arr);


    }
    private static void printArr(int[] arr) {
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

 插入排序

核心是从左向右（升序），先遍历一次数组，看看左边到哪个位置开始不是升序了，这时，就按照这个位置将数组划分为两部分，左边有序的一部分和右边无序的一部分。将无序部分开始的索引记下来，从它开始遍历无序的一部分一次插入左边有序的那一部分；插入时候，从有序的那一部分由左向右或者由右向左利用二分法或者依次遍历插入到合适位置，当无序那一部分没有值了，遍历结束，排序结束。

public static void main(String[] args) {
        /*
            插入排序：
                将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。
                遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。
                N的范围：0~最大索引

        */
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

        //1.找到无序的哪一组数组是从哪个索引开始的。  2
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > arr[i + 1]){
                startIndex = i + 1;
                break;
            }
        }

        //2.遍历从startIndex开始到最后一个元素，依次得到无序的哪一组数据中的每一个元素
        for (int i = startIndex; i < arr.length; i++) {
            //问题：如何把遍历到的数据，插入到前面有序的这一组当中

            //记录当前要插入数据的索引
            int j = i;

            while(j > 0 && arr[j] < arr[j - 1]){
                //交换位置
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                j--;
            }

        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

快速排序 

先了解递归：递归是指方法自己调用自己的过程；

 直接递归自己会导致无限套娃下去，从而内存溢出，所以一定要有出口；

举例：用递归求1~100的和：

public static void main(String[] args) {
        System.out.println(getSum(100));
    }

    public static int getSum(int num) {
        if (num == 1) {
            return 1;
        }
        return num + getSum(num - 1);
    }

快速排序（升序）借用的就是递归思想：

  1. 第一次排序时候把0索引记录的值拿出来，然后把1索引的位置定义为start，数组最后一位定义为end；
  2. 然后先拿end位置的值和0索引的值比，如果发现0索引的值大于end索引的值，end指针停住，接着去执行start索引，拿它来和0索引的值比，如果0索引的值小于start索引的值，就停住start指针；
  3. 这时，将start索引的值和end索引的值交换，交换完成后继续2步骤，直到end和start指向了同一个数据，这时候拿0索引的基准值和这个值交换位置，即找到了0索引对应数字的正确位置。
  4. 这时候，0索引的位置归位，把交换出来的值递归调用该方法，找到全部的正确位置后，排序完成；
     /*
       快速排序：
           第一轮：以0索引的数字为基准数，确定基准数在数组中正确的位置。
           比基准数小的全部在左边，比基准数大的全部在右边。
           后面以此类推。
     */

       int[] arr = {1,1, 6, 2, 7, 9, 3, 4, 5, 1,10, 8};


       //int[] arr = new int[1000000];

      /* Random r = new Random();
       for (int i = 0; i < arr.length; i++) {
           arr[i] = r.nextInt();
       }*/


       long start = System.currentTimeMillis();
       quickSort(arr, 0, arr.length - 1);
       long end = System.currentTimeMillis();

       System.out.println(end - start);//149

       System.out.println(Arrays.toString(arr));
       //课堂练习：
       //可以利用相同的办法去测试一下，选择排序，冒泡排序以及插入排序运行的效率
       //得到一个结论：快速排序真的非常快。

      /* for (int i = 0; i < arr.length; i++) {
           System.out.print(arr[i] + " ");
       }*/

   }


   /*
    *   参数一：我们要排序的数组
    *   参数二：要排序数组的起始索引
    *   参数三：要排序数组的结束索引
    * */
   public static void quickSort(int[] arr, int i, int j) {
       //定义两个变量记录要查找的范围
       int start = i;
       int end = j;

       if(start > end){
           //递归的出口
           return;
       }



       //记录基准数
       int baseNumber = arr[i];
       //利用循环找到要交换的数字
       while(start != end){
           //利用end，从后往前开始找，找比基准数小的数字
           //int[] arr = {1, 6, 2, 7, 9, 3, 4, 5, 10, 8};
           while(true){
               if(end <= start || arr[end] < baseNumber){
                   break;
               }
               end--;
           }
           System.out.println(end);
           //利用start，从前往后找，找比基准数大的数字
           while(true){
               if(end <= start || arr[start] > baseNumber){
                   break;
               }
               start++;
           }



           //把end和start指向的元素进行交换
           int temp = arr[start];
           arr[start] = arr[end];
           arr[end] = temp;
       }

       //当start和end指向了同一个元素的时候，那么上面的循环就会结束
       //表示已经找到了基准数在数组中应存入的位置
       //基准数归位
       //就是拿着这个范围中的第一个数字，跟start指向的元素进行交换
       int temp = arr[i];
       arr[i] = arr[start];
       arr[start] = temp;

       //确定6左边的范围，重复刚刚所做的事情
       quickSort(arr,i,start - 1);
       //确定6右边的范围，重复刚刚所做的事情
       quickSort(arr,start + 1,j);

   }

要注意的是：从0开始做基准就一定要先移动end，再移动start不然会出问题 

Lambda表达式

与面向对象不同，Lambda表达式就是一种在意逻辑不在意对象的体现，可以用来简化代码。

 此外，还可以省略：

  • 参数类型可以省略
  • 只有一个参数时，参数的括号也可以省；
  • 方法体只有一行，大括号，分号，return都可以省；
Arrays.sort(arr, (o1,o2) -> o1 - o2);

 综合练习：

练习一：

定义数组，存储人类对象，利用Arrays中的方法进行排序

要求：属性得有姓名，年龄，身高；按照年龄大小排序；若年龄相同，比较身高，身高相同，按照姓名首字母（姓名暂时用拼音代替）；

public static void main(String[] args) {
        Person person1 = new Person("xiaozhang", 18, 1.66);
        Person person2 = new Person("xiaowang", 18, 1.76);
        Person person3 = new Person("xiaozhao", 19, 1.86);
        Person person4 = new Person("az", 19, 1.86);
        Person[] people = {person1, person2, person3, person4};
        Arrays.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                double temp = o1.getAge() - o2.getAge();
                //年龄相同比身高
                temp = temp == 0 ? o1.getHeight() - o2.getHeight() : temp;
                //身高相同比姓名首字母
                temp = temp == 0 ? o1.getName().compareTo(o2.getName()) : temp;
                if (temp > 0) {
                    return 1;
                } else if (temp < 0) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });
        for (int i = 0; i < people.length; i++) {
            System.out.println(people[i].getName());
        }
    }
}

class Person {
    private String name;
    private int age;
    private double height;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public Person() {
    }

    public Person(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

练习二：

求第十二个斐波那契数列的值（递归的方法）：

 public static void main(String[] args) {
        //第一个月，1
        //第二个月，1
        //第三个月，2
        //第四个月，3
        //第五个月，5
        //第五个月，8
        System.out.println(getSum(12));
    }

    public static int getSum(int month) {
        if (month ==1 || month == 2){
            return 1;
        }
        return getSum(month-1)+getSum(month-2);
    }

练习三：

一堆桃子，猴子第一天吃了一半后，又吃了一个 ；之后每天都这样，然后吃到第十天没吃呢，就只剩一个了，问最初共有多少桃子？

    public static void main(String[] args) {
        //我这个思路是把第十天视作第一天，即第一天已知
        //然后去推第十天
        System.out.println(getSum(10));
    }

    public static int getSum(int day) {
        if (day == 1) {
            return 1;
        }
        return (getSum(day - 1) + 1) * 2;
    }

练习四：

某人去爬楼梯，有时他走两个台阶，有时他走一个台阶，若楼梯总长20阶，问他有几种爬楼梯方法？（去掉了一个1的斐波那契数列）

    public static void main(String[] args) {
        System.out.println(getSum(20));
    }

    public static int getSum(int count) {
        if (count == 1) {
            return 1;
        }
        if (count== 2){
            return 2;
        }
        return getSum(count-1)+getSum(count-2);
    }

zhuxs223
关注
  • 48
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见：计算机常见算法面试题1
08-08
简介：计算机考研之家搜集的华为C语言经典面试题，来试试你的C语言水平吧。每道题都附有详细解答和讲解，很有参考价值的C语言面试题。怎么判断链表中是否有环？bool
机器学习算法简介
07-05
机器学习算法简介,大概有10种常见算法 机器学习算法简介,大概有10种常见算法
PnP 算法简介 代码解析
01-10
PnP 算法简介 代码解析本期公开课将详细讲述常见的PnP求解算法。PnP求解算法是指通过多对3D与2D匹配点，在已知或者未知相机内参的情况下，利用最小化重投影误差来求解相机外参的算法。PnP求解算法是SLAM前端位姿跟踪部分中常用的算法之一，本次公开课，将详细讲述P3P、DLT、EPnP、UPnP、优化求解等多种常见的PnP求解算法。接下来，让我们一起深入学习PnP算法吧！
MATLABj简介和常用算法.rar
01-05
MATLAB是一种功能强大的数值计算和科学计算软件，常用于各种应用场景。以下是一些常见的MATLAB应用场景： 1. 科学与工程计算：MATLAB提供了各种数值计算、线性代数、优化、信号处理等功能，适用于科学研究、工程计算、模拟和建模等领域。 2. 数据可视化：MATLAB具有丰富的绘图和可视化功能，可以将数据以图形的形式展示出来，帮助用户更好地理解和分析数据。 3. 图像处理与计算机视觉：MATLAB提供了强大的图像处理库，可用于图像的滤波、增强、分割、特征提取等操作，同时也可用于计算机视觉任务，如目标检测、图像识别等。 4. 信号处理与通信：MATLAB提供了丰富的信号处理工具箱，用于信号分析、滤波器设计、频谱分析、通信系统设计等。 5. 数值模拟与仿真：MATLAB可以进行各种物理、工程、数学模型的模拟与仿真，例如机械系统、电路系统、动力系统等。 6. 控制系统设计：MATLAB提供了控制系统工具箱，用于控制系统的建模、仿真和控制算法设计。 7. 金融建模与风险管理：MATLAB在金融领域也有广泛应用，用于金融数据分析、金融工程、风险管理等方面。
Feed流及其常见算法简介
HappinessSourceL的博客
08-23 6916
消息来源[1]（英语：web feed、news feed、syndicated feed又译为源料[2]、馈送[3]、信息提供[4]、供稿[5]、摘要、源[6]、新闻订阅、网源[7]）是一种数据格式，网站可通过它将最新信息传播给用户，用户能够订阅网站的先决条件是网站可提供持续更新的信息。 以上摘自wiki 什么是Feed？ Feed是一个互联网早起概念，本意是RSS中用来接
常见算法简介及实现
qq_39719415的博客
08-10 1391
1、选择排序 选择排序是一种基础、稳定的排序算法，用第一个元素V1和其他所有元素一个一个对比，比较出最小的元素Vmin，再把V1与Vmin的数组下标位置交换；之后第二个再和剩下的所有元素比较 …，这样一直循环比较整个数组，即可得到一个有序的数组。时间复杂度为n的2次方。 实现代码（java）： public static void xuanze_sort(){ int data []={1,3,2,22,33,4,6,5}; for(int i=0;i<data
人工智能常见算法简介
喜欢打酱油的老鸟
02-15 1万+
https://www.toutiao.com/a6657717023583240712/   人工智能的三大基石—算法、数据和计算能力，算法作为其他之一，是非常重要的，那么人工智能都会涉及哪些算法呢？不同算法适用于哪些场景呢？ 一、按照模型训练方式不同可以分为监督学习（Supervised Learning），无监督学习（Unsupervised Learning）、半监督学习（Semi-...
AI语音识别常见算法简介--目录参考
justlpf的专栏
07-06 1239
参考文章:随笔分类 - AI大语音（ASR） AI大语音（一）——语音识别基础 AI大语音（二）——语音预处理 AI大语音（三）—傅里叶变换家族 AI大语音（四）——MFCC特征提取 语音识别算法的现状 AI智能语音识别算法原理 三 AI智能语音识别算法原理 一 声学基础知识 ...
目前常见加密算法简介
热门推荐
小帅的博客
10-12 1万+
艾伦·麦席森·图灵在二战期间主要负责破译德国人的密码系统Enigma，破解密码需要大量的计算，图灵深知工欲善其事必先利其器的道理，于是一台叫作CO-LOSSUS的计算机在1943年被研制出来，后来这种电子计算机总共生产了10台，他们出色完成了密码破译工作。 后来甚至有人将二战胜利原因归咎于图灵机的诞生，虽然有些夸大，但图灵机的诞生确实加快了二战的结束这是不可否认的。而图灵机战胜的不是法西斯...
常见加密相关算法简介
tnb_ml的博客
09-29 1912
常见加密相关算法简介 消息摘要算法 对称加密算法 非对称加密算法 国密算法 消息摘要算法： 相同的明文数据经过相同的消息摘要算法会得到相同的密文结果值。 数据经过消息摘要算法处理，得到的摘要结果值，是无法还原为处理前的数据的。 数据摘要算法也被称为哈希（Hash）算法或散列算法。 消息摘要算法一般用于签名验签。 消息摘要算法主要分三类：MD（Message Digest，消息摘要算法）、SHA（Secure Hash Algorithm，安全散列算法）和MAC（Message Authenticati
高可用：负载均衡的常见算法有哪些？
03-18
高可用：负载均衡的常见算法有哪些？ 内容包含： 简介、详解、面试指南
数据结构（一）初识数据结构
无人罪的博客
05-08 254
数据的组织方式要以问题为核心，提高解决问题的效率数据的结构服务于具体的对数据操作（增，删，改，查），考虑数据组织方式就是如何提高数据操作的效率根据数据存储方式划分数据空间，同样的根据数据空间（数据量大小）划分数据存储方式。
数据结构---顺序表
最新发布
2301_78724721的博客
05-09 706
数据结构是由“数据”和“结构”两词组合⽽来。什么是数据？常⻅的数值1、2、3、4.....、教务系统⾥保存的⽤⼾信息（姓名、性别、年龄、学历等 等）、⽹⻚⾥⾁眼可以看到的信息（⽂字、图⽚、视频等等），这些都是数据 什么是结构？当我们想要使⽤⼤量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独⽴的变量对于程序来说，可读性 ⾮常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的 ⽅式。
相交链表（数据结构）
Jason_from_China的博客
05-08 225
160. 相交链表 - 力扣（LeetCode）
二叉树习题汇总
qq_74336191的博客
05-08 488
所以，其实这道题和相同的树有点类似，都是先比较根节点，再比较根节点的左右子树。对称二叉树是左子树和右子树进行比较， 左子树的左子树与右子树的右子树进行比较，以及左子树的右子树与右子树的左子树进行比较。可以通过比较根节点的左右子节点是否相等，以及递归地比较左子树的左子节点与右子树的右子节点，左子树的右子节点与右子树的左子节点，来判断二叉树是否对称。今天我们学习了7道二叉树的练习题，说句心里话，第一次我做题的时候，也是迷迷糊糊，磕磕碰碰，但是多做几遍，多画一画图，我相信，小伙伴们都能学会~Ready Go!
初阶数据结构之单链表详解
2302_80837091的博客
05-08 696
在实现单链表的操作之前，我们应该把结点定义出来，已知结点内存储结点数据（data）和下一个结点的地址（即一个指向下一个结点的指针），因此我们可以用结构体来定义结点。//定义结点//数据域//指针域}SLNode;//定义结点//数据域//指针域}SLNode;//单链表初始化//单链表的新增节点(把新增的数据转换为结点结构体类型)//单链表尾插结点//单链表头插结点//打印单链表//单链表尾删结点//单链表头删//单链表查找数据//单链表删除指定位置结点。
数据结构——堆排序
coisinilove
05-08 379
堆是具有下列性质的完全二叉树:每个结点的值都小于或等于其左右孩子结点的值(称为小根堆) 或 每个结点的值都大于或等于其左右孩子结点的值(称为大根堆)。
【数据结构和算法】--链表
liuxu324的博客
05-05 247
链表的操作
网页爬取算法模型简介
02-06
网页爬取算法模型是指通过程序自动抓取网页信息的方法。它可以模拟浏览器行为，获取网页中的文本、图片、视频等信息。常见的网页爬取算法模型有：基于关键字的搜索爬虫、基于链接的爬虫、基于结构化数据的爬虫等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值