十大经典排序算法【快速了解】

news2024/11/20 12:19:12

文章目录

    • 一、算法分类
    • 二、经典排序算法总览
    • 三、算法复杂度
    • 四、代码实现

一、算法分类

十种常见排序算法可以分为两大类：

  • 比较类排序：
    • 通过比较来决定元素间的相对次序
    • 由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
  • 非比较类排序：
    • 不通过比较来决定元素间的相对次序
    • 它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
      在这里插入图片描述

二、经典排序算法总览

十大经典算法分别是：

  • 冒泡排序

    • 冒泡排序（Bubble Sort）是基于交换的排序
    • 每次遍历需要排序的元素，依次比较相邻的两个元素的大小，如果前一个元素大于后一个元素则两者交换，保证最后一个数字一定是最大的（假设按照从小到大排序
    • 即最后一个元素已经排好序，下一轮只需要保证前面 n-1 个元素的顺序即可。

    在这里插入图片描述

过程演示：待排序数组 {5, 4, 7, 1, 6, 2}，升序排序

算法步骤：

  1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  3. 针对所有的元素重复以上的步骤，除了最后一个；
  4. 重复步骤1~3，直到排序完成。
  • 选择排序
    • 前面说的冒泡排序是每一轮比较确定最后一个元素，中间过程不断地交换。
    • 而选择排序就是每次选择剩下的元素中最小的那个元素，与当前索引位置的元素交换，直到所有的索引位置都选择完成。

在这里插入图片描述
【算法步骤】n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

  1. 初始状态：无序区为R[1..n]，有序区为空；
  2. 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。
    • 该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换
    • 使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
  3. n-1趟结束，数组有序化了。
  • 插入排序
    • 选择排序是每次选择出最小的放到已经排好的数组后面
    • 而插入排序是依次选择一个元素，插入到前面已经排好序的数组中间，确保它处于正确的位置。
    • 当然，这是需要已经排好的顺序数组不断移动。

在这里插入图片描述
【算法步骤】一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

  1. 从第一个元素开始，该元素可以认为已经被排序；
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  5. 将新元素插入到该位置后；
  6. 重复步骤2~5。
  • 希尔排序
    • 希尔排序（Shell’s Sort）又称“缩小增量排序”（Diminishing Increment Sort），是插入排序的一种更高效的改进版本。
    • 插入排序的痛点在于不管是否是大部分有序，都会对元素进行比较，如果最小数在数组末尾，想要把它移动到数组的头部是比较费劲的。
    • 希尔排序是在数组中采用跳跃式分组，按照某个增量 gap 进行分组，分为若干组，每一组分别进行插入排序。
      • 再逐步将增量 gap 缩小
      • 再每一组进行插入排序，循环这个过程，直到增量为 1。

在这里插入图片描述
【算法步骤】先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

  1. 选择一个增量序列t1，t2，…，tk，其中ti > tj，tk = 1；
  2. 按增量序列个数k，对序列进行k 趟排序；
  3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。
    • 仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
  • 快速排序
    • 快速排序比较有趣，选择数组的一个数作为基准数，一趟排序，将数组分割成为两部分
      • 一部分均小于/等于基准数
      • 另一部分大于/等于基准数。
    • 然后分别对基准数的左右两部分继续排序，直到数组有序。这体现了分而治之的思想，其中还应用到挖坑填数的策略。

在这里插入图片描述
【算法步骤】快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

  1. 从数列中挑出一个元素，称为 “基准”（pivot）；
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
  3. 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  4. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
  • 归并排序
    • 前面的快速排序，体现了分治的思想，但是不够典型
    • 而归并排序则是非常典型的分治策略。归并的总体思想是先将数组分割，再分割 …
    • 分割到一个元素，然后再两两归并排序，做到局部有序，不断地归并，直到数组又被全部合起来。

在这里插入图片描述
算法步骤

  1. 把长度为n的输入序列分成两个长度为n/2的子序列；
  2. 对这两个子序列分别采用归并排序；
  3. 将两个排序好的子序列合并成一个最终的排序序列。
  • 桶排序
    • 桶排序，是指用多个桶存储元素，每个桶有一个存储范围
    • 先将元素按照范围放到各个桶中，每个桶中是一个子数组，然后再对每个子数组进行排序，最后合并子数组，成为最终有序的数组。
    • 这其实和计数排序很相似，只不过计数排序每个桶只有一个元素，而且桶存储的值为该元素出现的次数。

在这里插入图片描述
算法步骤

  1. 设置一个定量的数组当作空桶；
  2. 遍历输入数据，并且把数据一个一个放到对应的桶里去；
  3. 对每个不是空的桶进行排序；
  4. 从不是空的桶里把排好序的数据拼接起来。
  • 堆排序
    • 堆排序，就是利用大顶堆或者小顶堆来设计的排序算法，是一种选择排序。
    • 堆是一种完全二叉树：
      • 大顶堆：每个节点的数值都大于或者等于其左右孩子节点的数值。
      • 小顶堆：每个节点的数值都小于或者等于其左右孩子节点的数值。

在这里插入图片描述
算法步骤：

  1. 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
  2. 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
  3. 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。
  4. 不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
  • 计数排序
    • 计数排序，不是基于比较，而是基于计数
    • 比较适合元素数值相近且为整数的情况

在这里插入图片描述
算法步骤

  1. 找出待排序的数组中最大和最小的元素；
  2. 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
  3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
  4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
  • 基数排序
    • 基数排序比较特殊，特殊在它只能用在整数（自然数）排序，而且不是基于比较的，
    • 其原理是将整数按照位分成不同的数字，按照每个数各位值逐步排序。
    • 何为高位，比如 81，1 就是低位， 8 就是高位。
    • 分为高位优先和低位优先，先比较高位就是高位优先，先比较低位就是低位优先。

在这里插入图片描述

算法步骤：

  1. 取得数组中的最大数，并取得位数；
  2. arr为原始数组，从最低位开始取每个位组成radix数组；
  3. 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

三、算法复杂度

常见排序算法复杂度
在这里插入图片描述
在这里插入图片描述

相关概念

  • 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
  • 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
  • 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
  • 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数

四、代码实现

  • 冒泡排序（Bubble Sort）
function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len - 1; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        // 相邻元素两两对比
                var temp = arr[j+1];        // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

在这里插入图片描述

  • 选择排序（Selection Sort）
function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                minIndex = j;                 // 将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}

在这里插入图片描述

  • 插入排序（Insertion Sort）
function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while (preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
    return arr;
}

在这里插入图片描述

  • 希尔排序（Shell Sort）
function shellSort(arr) {
    var len = arr.length;
    for (var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
        // 注意：这里和动图演示的不一样，动图是分组执行，实际操作是多个分组交替执行
        for (var i = gap; i < len; i++) {
            var j = i;
            var current = arr[i];
            while (j - gap >= 0 && current < arr[j - gap]) {
                 arr[j] = arr[j - gap];
                 j = j - gap;
            }
            arr[j] = current;
        }
    }
    return arr;
}

在这里插入图片描述

  • 归并排序（Merge Sort）
function mergeSort(arr) {
    var len = arr.length;
    if (len < 2) {
        return arr;
    }
    var middle = Math.floor(len / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}
 
function merge(left, right) {
    var result = [];
 
    while (left.length>0 && right.length>0) {
        if (left[0] <= right[0]) {
            result.push(left.shift());
        } else {
            result.push(right.shift());
        }
    }
 
    while (left.length)
        result.push(left.shift());
 
    while (right.length)
        result.push(right.shift());
 
    return result;
}

在这里插入图片描述

  • 快速排序（Quick Sort）
function quickSort(arr, left, right) {
    var len = arr.length,
        partitionIndex,
        left = typeof left != 'number' ? 0 : left,
        right = typeof right != 'number' ? len - 1 : right;
 
    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}
 
function partition(arr, left ,right) {     // 分区操作
    var pivot = left,                      // 设定基准值（pivot）
        index = pivot + 1;
    for (var i = index; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }       
    }
    swap(arr, pivot, index - 1);
    return index-1;
}
 
function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

在这里插入图片描述

  • 堆排序（Heap Sort）
var len;    // 因为声明的多个函数都需要数据长度，所以把len设置成为全局变量
 
function buildMaxHeap(arr) {   // 建立大顶堆
    len = arr.length;
    for (var i = Math.floor(len/2); i >= 0; i--) {
        heapify(arr, i);
    }
}
 
function heapify(arr, i) {     // 堆调整
    var left = 2 * i + 1,
        right = 2 * i + 2,
        largest = i;
 
    if (left < len && arr[left] > arr[largest]) {
        largest = left;
    }
 
    if (right < len && arr[right] > arr[largest]) {
        largest = right;
    }
 
    if (largest != i) {
        swap(arr, i, largest);
        heapify(arr, largest);
    }
}
 
function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
 
function heapSort(arr) {
    buildMaxHeap(arr);
 
    for (var i = arr.length - 1; i > 0; i--) {
        swap(arr, 0, i);
        len--;
        heapify(arr, 0);
    }
    return arr;
}

在这里插入图片描述

  • 计数排序（Counting Sort）
function countingSort(arr, maxValue) {
    var bucket = new Array(maxValue + 1),
        sortedIndex = 0;
        arrLen = arr.length,
        bucketLen = maxValue + 1;
 
    for (var i = 0; i < arrLen; i++) {
        if (!bucket[arr[i]]) {
            bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }
 
    for (var j = 0; j < bucketLen; j++) {
        while(bucket[j] > 0) {
            arr[sortedIndex++] = j;
            bucket[j]--;
        }
    }
 
    return arr;
}

在这里插入图片描述

  • 桶排序（Bucket Sort）
function bucketSort(arr, bucketSize) {
    if (arr.length === 0) {
      return arr;
    }
 
    var i;
    var minValue = arr[0];
    var maxValue = arr[0];
    for (i = 1; i < arr.length; i++) {
      if (arr[i] < minValue) {
          minValue = arr[i];                // 输入数据的最小值
      } else if (arr[i] > maxValue) {
          maxValue = arr[i];                // 输入数据的最大值
      }
    }
 
    // 桶的初始化
    var DEFAULT_BUCKET_SIZE = 5;            // 设置桶的默认数量为5
    bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
    var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;  
    var buckets = new Array(bucketCount);
    for (i = 0; i < buckets.length; i++) {
        buckets[i] = [];
    }
 
    // 利用映射函数将数据分配到各个桶中
    for (i = 0; i < arr.length; i++) {
        buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
    }
 
    arr.length = 0;
    for (i = 0; i < buckets.length; i++) {
        insertionSort(buckets[i]);                      // 对每个桶进行排序，这里使用了插入排序
        for (var j = 0; j < buckets[i].length; j++) {
            arr.push(buckets[i][j]);                     
        }
    }
 
    return arr;
}

在这里插入图片描述

  • 基数排序（Radix Sort）
var counter = [];
function radixSort(arr, maxDigit) {
    var mod = 10;
    var dev = 1;
    for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        for(var j = 0; j < arr.length; j++) {
            var bucket = parseInt((arr[j] % mod) / dev);
            if(counter[bucket]==null) {
                counter[bucket] = [];
            }
            counter[bucket].push(arr[j]);
        }
        var pos = 0;
        for(var j = 0; j < counter.length; j++) {
            var value = null;
            if(counter[j]!=null) {
                while ((value = counter[j].shift()) != null) {
                      arr[pos++] = value;
                }
          }
        }
    }
    return arr;
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/388087.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

电视剧《狂飙》太过诡异，主演各个悄无声息，龙套演员却身价倍增

电视剧《狂飙》太过诡异，主演各个悄无声息，龙套演员却身价倍增

说起电视剧《狂飙》&#xff0c;相信很多人都有过观看&#xff0c;这部以反腐为题材的大剧&#xff0c;尺度之大近年来绝无仅有。不过观众在被剧情震撼的同时&#xff0c;也发现了一些诡异的事情&#xff0c;比如说主角和配角的反差&#xff0c;让人感觉很不适应。 在电视剧《狂…
阅读更多...
51单片机入门————数码管显示

51单片机入门————数码管显示

我们在马路上看到的红绿灯&#xff0c;就是由数码管来实现的&#xff0c;就是其中可能加入了一些延时和转换数码管是通过控制138译码器与74HC245来控制数码管的亮灭与数字的显示电路原理图我们先讨论一个数码管数码管有共阳极和共阴极&#xff0c;我们现在使用的STC89C52是共阴…
阅读更多...
DataX入门

DataX入门

目录 1. DataX介绍 2. DataX支持的常用数据源类型 3. 设计理念 4. DataX框架设计 4.1. Reader 4.2. Writer 4.3. Framework 5. DataX的运行流程 6. DataX与Sqoop对比 7. 部署 8. 配置详解 9. 案例 同步MySql到HDFS 9.1. 整体结构 9.2. mySqlReader 9.2.1. …
阅读更多...
C语言函数：字符串函数及模拟实现strncpy()、strncat()、strncmp()

C语言函数：字符串函数及模拟实现strncpy()、strncat()、strncmp()

C语言函数&#xff1a;字符串函数及模拟实现strncpy()、strncat()、strncmp() 在了解strncpy、strncat()、前&#xff0c;需要先了解strcpy()、strncat()&#xff1a; C语言函数&#xff1a;字符串函数及模拟实现strlen() 、strcpy()、 strcat()_srhqwe的博客-CSDN博客 strncp…
阅读更多...
包装类详解（装箱，拆箱）

包装类详解（装箱，拆箱）

Object 引用可以指向任意类型的对象&#xff0c;但有例外出现了&#xff0c;8 种基本数据类型不是对象&#xff0c;那岂不是刚才的泛型机制要失效了&#xff1f;&#xff08;泛型详解._阿瞒有我良计15的博客-CSDN博客&#xff09; 实际上也确实如此&#xff0c;为了解决这个问题…
阅读更多...
数据结构与算法-二叉树-序列化与反序列化

数据结构与算法-二叉树-序列化与反序列化

可能性探究:我们可以想到的是只有一棵树按照某个序是唯一确定要给结构的情况才可能被序列化和反序列化&#xff0c;比如我们对于以下的二叉树可以找到它的先序、中序、后序如下&#xff1a; 根据它的先序和后序我们找不到任何其他可能的树&#xff0c;所以可以根据先序和后序去…
阅读更多...
NLP预训练模型

NLP预训练模型

Models Corpus RoBERTa: A Robustly Optimized BERT Pretraining Approach 与BERT主要区别在于&#xff1a; large mini-batches 保持总训练tokens数一致&#xff0c;使用更大的学习率、更大的batch size&#xff0c;adam β20.98\beta_20.98β2​0.98&#xff1b;dynamic ma…
阅读更多...
aws eks 集群初始化过程中pause容器的启动逻辑

aws eks 集群初始化过程中pause容器的启动逻辑

eks集群默认策略在磁盘使用量达到threshold时会清除镜像&#xff0c;其中pause镜像也可能会被清除 https://aws.amazon.com/cn/premiumsupport/knowledge-center/eks-worker-nodes-image-cache/ pause容器能够为pod创建初始的名称空间&#xff0c;pod的内的容器共享其中的网络空…
阅读更多...
库函数qsort 的模拟实现

库函数qsort 的模拟实现

在之前了解了库函数qsort的使用之后 我们来模拟实现一下上篇有介绍 qsort的底层实现是快速排序 由于害怕没有人了解过快速排序 我就用大家熟知的冒泡排序进行模拟实现 先来展示完整代码 以下代码为升序排序 如果降序将冒泡排序中的大于号改为小于号就可以了#define _CRT_SECURE…
阅读更多...
malloc实现原理探究

malloc实现原理探究

2021年末面试蔚来汽车&#xff0c;面试官考察了malloc/free的实现机制。当时看过相关的文章&#xff0c;有一点印象&#xff0c;稍微说了一点东西&#xff0c;不过自己感到不满意。今天尝试研究malloc的实现细节&#xff0c;看了几篇博文&#xff0c;发现众说纷纭&#xff0c;且…
阅读更多...
MySql启动错误(Mac系统 安装 mysql-8.0.32-macos13-arm64 后每次点击启动 无法启动) --- 已解决

MySql启动错误(Mac系统 安装 mysql-8.0.32-macos13-arm64 后每次点击启动 无法启动) --- 已解决

MySql启动的时候: 立即变红! 查看日志如下: 2023-03-04T14:18:01.089671Z 0 [System] [MY-010910] [Server] /usr/local/mysql/bin/mysqld: Shutdown complete (mysqld 8.0.32) MySQL Community Server - GPL. 2023-03-04T14:18:10.304169Z 0 [System] [MY-010116] [Server]…
阅读更多...
【EDA工具使用】——VCS和Verdi的联合仿真的简单使用

【EDA工具使用】——VCS和Verdi的联合仿真的简单使用

目录 1.芯片开发所需的工具环境 2.编译仿真工具 3.三步式混合编译仿真&#xff08;最常用&#xff09;​编辑 4.两步式混合编译仿真​编辑 5.VCS的使用 ​6.verdi的使用 1.产生fsdb文件的两种方法​编辑 1.芯片开发所需的工具环境 2.编译仿真工具 3.三步式混合编译仿真…
阅读更多...
按位与为零的三元组[掩码+异或的作用]

按位与为零的三元组[掩码+异或的作用]

掩码异或的作用前言一、按位与为零的三元组二、统计分组1、map统计分组2、异或掩码总结参考资料前言 当a b 0时&#xff0c;我们能够很清楚的知道b是个什么值&#xff0c;b 0 - a -a&#xff0c;如果当a & b 0时&#xff0c;我们能够很清楚的知道b是什么值吗&#xf…
阅读更多...
Python GUI界面编程-初识

Python GUI界面编程-初识

图形用户界面(Graphical User Interface&#xff0c;简称 GUI&#xff0c;又称图形用户接口)是指采用图形方式显示的计算机操作用户界面。与早期计算机使用的命令行界面相比&#xff0c;图形界面对于用户来说在视觉上更易于接受。然而这界面若要通过在显示屏的特定位置&#xf…
阅读更多...
HiveSQL一天一个小技巧：如何精准计算非连续日期累计值【闪电快车面试题】

HiveSQL一天一个小技巧：如何精准计算非连续日期累计值【闪电快车面试题】

0 需 求稀疏字段累计求和问题1 问题分析根据图片中数据变换的形式&#xff0c;可以看出是根据字段term补齐数据中缺失的日期&#xff0c;term为连续日期的个数&#xff0c;当为12时&#xff0c;表明由2018-12-21到2019-01-02连续日期个数为12&#xff0c;当补齐日期后&#xff…
阅读更多...
sklearn中的逻辑回归

sklearn中的逻辑回归

目录 一.名为“回归”的分类器 二.逻辑回归的优点 三.sklearn中的逻辑回归 四.linear_model.LogisticRegression 五.penalty & C(正则化) 六.逻辑回归中的特征工程 1.业务选择 2.PCA和SVD一般不用 3.统计方法可以使用&#xff0c;但不是非常必要 4.高效的嵌入法e…
阅读更多...
【vulhub漏洞复现】CVE-2013-4547 Nginx 文件名逻辑漏洞

【vulhub漏洞复现】CVE-2013-4547 Nginx 文件名逻辑漏洞

一、漏洞详情影响版本 Nginx 0.8.41 ~ 1.4.3 / 1.5.0 ~ 1.5.7通过%00截断绕过后缀名的限制&#xff0c;使上传的php内容文件被解析执行。当Nginx得到一个用户请求时&#xff0c;首先对url进行解析&#xff0c;进行正则匹配&#xff0c;如果匹配到以.php后缀结尾的文件名&#x…
阅读更多...
2022秋-2023-中科大-数字图像分析-期末考试试卷回忆版

2022秋-2023-中科大-数字图像分析-期末考试试卷回忆版

今天晚上刚考完&#xff0c;心累&#xff0c;在这里继续授人以渔(仅供参考&#xff0c;切勿对着复习不看ppt&#xff0c;ppt一定要过两遍)。 注意:往年的经验贴&#xff0c;到此为止&#xff0c;全部作废&#xff0c;一个没考。千万不要只对着复习&#xff0c;SIFT没考&#x…
阅读更多...
JavaScript（JS）

JavaScript（JS）

一、三种引入方式&#xff1a; 1、内部js 通过script标签嵌入到html里面 <script>alert(hello);</script> 2、外部js 写成一个单独的.js文件&#xff0c;让html引入进来 <script src"app.js"></script> 3、行内js 直接写到html内部 &…
阅读更多...
Python爬虫——使用socket模块进行图片下载

Python爬虫——使用socket模块进行图片下载

Python爬虫——使用socket模块进行图片下载什么是socket爬虫的工作流程socket爬取图片为什么能用socket能下载图片socket下载图片和request下载图片的区别使用socket下载一张图片使用socket下载多张图片方法1方法2什么是socket Socket 是一种通信机制&#xff0c;用于实现网络…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023