六大排序(插入排序、希尔排序、冒泡排序、选择排序、堆排序、快速排序)未完

news2024/11/11 17:15:05

文章目录

  • 排序
    • 一、 排序的概念
      • 1.排序:
      • 2.稳定性:
      • 3.内部排序:
      • 4.外部排序:
    • 二、插入排序
      • 1.直接插入排序
      • 2.希尔排序
    • 三、选择排序
      • 1.直接选择排序
          • 方法一
          • 方法二
          • 直接插入排序和直接排序的区别
      • 2.堆排序
    • 四、交换排序
      • 1.冒泡排序
      • 2.快速排序
          • 1.挖坑法
          • 2.Hoare法
          • 3.前后指针法
          • 4.快速排序的优化
            • 方法一、三数取中法选基准值
            • 方法二、递归到最小区间时、用插入排序
          • 5.快速排序非递归实现

排序


一、 排序的概念

1.排序:

  • 一组数据按递增/递减排序

2.稳定性:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 待排序的序列中,存在多个相同的关键字,拍完序后,相对次序保持不变,就是稳定的

3.内部排序:

  • 数据元素全部放在内存中的排序

4.外部排序:

  • 数据元素太多不能同时放在内存中,根据排序过程的要求不能在内外存之间移动数据的排序

二、插入排序

1.直接插入排序

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

和整理扑克牌类似,将乱序的牌,按值的大小,插入整理好的顺序当中

从头开始,比最后一个小的话依次向前挪,直到大于之前牌时,进行插入

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.如果只有一个值,则这个值有序,所以插入排序, i 从下标1开始,把后面的无序值插入到前面的有序当中

2.j = i-1,是i的前一个数,先用tmp将 i位置的值(要插入的值)先存起来,比较tmp和j位置的值

3.如果tmp的值比 j位置的值小,说明要向前插入到有序的值中,把 j位置的值后移,移动到 j+1的位置,覆盖掉 i 的值

4.j 下标向前移动一位,再次和 tmp 比较

5.如果tmp的值比 j 位置的值大,说明找到了要插入的位置就在当前j位置之后,把tmp存的值,放到 j+1的位置

6.如果tmp中存的值比有序的值都小,j位置的值依次向后移动一位,j不停减1,直到排到第一位的数移动到第二位,j的下标从0移动到-1,循环结束,最后将tmp中存的值,存放到 j+1的位置,也就是0下标

    public void insertSort(int[] array) {

        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];//tmp存储i的值
            int j = i - 1;
            for (; j >= 0; j--) {
                if (tmp < array[j]) {
                    array[j + 1] = array[j];
                } else {
                    // array[j+1] = tmp;
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }

插入就是为了维护前面的有序

  • 元素越接近有序,直接插入排序算法的时间效率越高

  • 时间复杂度O( N 2 )

  • 空间复杂度O ( 1 )

  • 稳定性:稳定

    如果一个排序是稳定的,可以改变实现为不稳定的

    如果是不稳定的排序,则没有办法改变

2.希尔排序

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

希尔排序shellSort 叫缩小增量排序,是对直接插入排序的优化,先分组,对每组插入排序,让整体逐渐有序

利用了插入排序元素越有序越快的特点

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 先确定一个整数,把待排序数分成多个组,每个组中的数距离相同,
  • 对每一组进行排序,然后再次分组排序,减少分组数,组数多,每组数据就少
  • 找到分组数=1时,基本有序了,只需要再排一次插入排序即可

一开始组数多,每组数据少,可以保证效率

随着组数的减少,每组数据变多,数据越来越有序,同样保证了效率

到达1分组之前,前面的排序都是预排序

    public static void shellSort2(int[] array) {

        int gap = array.length;
        while (gap > 1) { //gap>1时缩小增量
            gap /= 2;//直接在循环内进行最后一次排序
            shell(array, gap);
        }

    }
    /**
     *
     * 希尔排序
     * 时间复杂度O(N^1.3---N^1.5)
     * @param array
     */

    public static void shellSort1(int[] array) {

        int gap = array.length;
        while (gap > 1) { //gap>1时缩小增量
            shell(array, gap);
            gap /= 2;//gap==1时不进入循环,再循环为再次排序
        }
        shell(array, gap);
        //组数为1时,进行插入排序
    }

    public static void shell(int[] arr, int gap) {
        //本质上还是插入排序,但是i和j的位置相差为组间距
        for (int i = gap ; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i-gap;
            for (; j >=0; j -= gap) {
                if (tmp<arr[j]){
                    arr[j+gap] = arr[j];
                }else {
                    break;
                }
            }
            arr[j+gap] = tmp;
        }
    }

  • 时间复杂度:O( N^1.3 ^) ---- O( N^1.5 ^)
  • 空间复杂的:O(1)
  • 稳定性:不稳定

三、选择排序

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 在待排序序列中,找到最小值(大)的下标,和排好序的末尾交换,放到待排序列的开头,直到全部待排序元素排完

1.直接选择排序

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

方法一

    /**
     * 选择排序
     *
     * @param array
     */
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {//找最小值
                if (array[j] < array[minIndex]) {
                    minIndex = j;//只要比minIndex小,放进去
                }
            }//循环走完后,minIndex存的就是当前未排序的最小值

            //将当前i的值和找到的最小值进行交换
            swap(array,i,minIndex);
        }
    }

    public static void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

1.遍历数组长度,i从0开始

2.每次循环,都由minIndex = i 来记录最小值的下标

3.j 从i+1开始遍历,只要比记录的最小值小,就让minIndex记录。找到未排序中的最小值,进行交换

4.如果遍历完后,未排序中没有比minIndex存的值小,i的值就是最小值,i++;

  • 效率低, 如果较为有序的序列,在交换时会破坏有序性
  • 时间复杂度:O ( N2 )
  • 空间复杂的:O ( 1 )
  • 稳定性:不稳定
方法二
  • 上面的方法,只是先选出最小的值,然后和i的位置交换,

  • 进行优化:在遍历时选出最大值和最小值,和收尾进行交换

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

   /**
     * 选择排序---选最大值和最小值
     *
     * @param array
     */
    public static void selectSort2(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            int minIndex = left;
            int maxIndex = left;
            //选出最大值和最小值
            for (int i = left + 1; i <= right; i++) {
                if (array[i] > array[maxIndex]) {
                    maxIndex = i;
                }
                if (array[i] < array[minIndex]) {
                    minIndex = i;
                }
            }
            //用最大值和最小值交换首位
            swap(array, left, minIndex);
            //把left和最小值交换
            //如果left恰好就是最大值,就有可能把最大值换到minIndex的位置
            if(left == maxIndex){
                maxIndex = minIndex;//最大值位置不是left了,而是换到了minIndex
            }
            swap(array, right, maxIndex);
            left++;
            right--;
        }
    }

1.在遍历的过程中,选出最大值的下标和最小值的下标

2.将left和最小值进行交换

3.如果left恰好为最大值,left和最小值交换完成后,最大值就在原来最小值的位置上,

4.maxIndex = minIndex,修正最大值的位置

4.将right和最大值进行交换

直接插入排序和直接排序的区别
  • 和插入排序不同的是,插入排序会持续对已排序的数进行比较,把合适的数放在合适的位置
  • 直接选择排序就是不断找到最小的值,依次放在排好序的末尾,不干预排好的序列

2.堆排序

  • 时间复杂度: O( N * log N)
  • 空间复杂的:O (1)
  • 升序:建大堆

  • 降序:建小堆

  • 外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

将一组数据从小到大排序 ——> 建立大根堆

为什么不用小根堆:小根堆只能保证,根比左右小,不能保证左右孩子的大小顺序,并且要求对数组本身进行排序

  • 大根堆,保证堆顶元素是最大值,最大值跟最后一个元素交换,将最大的放在最后,usedSize–;
  • 向下调整:调整0下标的树,维护大根堆,最大值继续交换到最后一个有效元素的位置
  • 从后往前,从大到小依次排列,保证在原来数组本身进行排序
    /**
     * 堆排序
     * 时间复杂度: N*logN
     * 空间复杂的:o(1)
     *
     * @param array
     */
    public static void heapSort(int[] array) {
        createBigHeap(array);//创建大根堆
        int end = array.length-1;
        while (end>0){
            swap(array,0,end);//堆顶元素和末尾互换
            shiftDown(array,0,end);//维护大根堆
            end--;
        }
    }
    /**
     * 创建大根堆
     *
     * @param array
     */
    public static void createBigHeap(int[] array) {
        //最后一个结点的下标 = array.length - 1
        //它的父亲结点的下标就为array.length - 1 - 1) / 2
        for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
            shiftDown(array, parent, array.length);
        }

    }

    /**
     * 向下调整
     *
     * @param array
     * @param parent
     * @param len
     *///向下调整,每棵树从父结点向下走

    public static void shiftDown(int[] array, int parent, int len) {
        int child = parent * 2 + 1;
        while (child < len) {
            //child < len:最起码要有一个左孩子
            if (child + 1 < len && array[child] < array[child + 1]) {
                child++;
            }//child + 1<len:保证一定有右孩子的情况下,和右孩子比较
            //拿到子节点的最大值
            if (array[child] > array[parent]) {
                swap(array, child, parent);
                parent = child;//交换完成后,让parent结点等于等于当前child结点
                child = 2 * parent + 1;
                //重新求子节点的位置,再次进入循环交换
            } else {
                break;
                //比父结点小,结束循环
            }
        }
    }

  • 时间复杂度: O( N * log 2N)
  • 空间复杂的:O (1)
  • 稳定性:不稳定

四、交换排序

  • 根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置
  • 将键值较大的记录向序列的尾部移动,键值较小的记录向序列的前部移动。

1.冒泡排序

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

    /**
     * 冒泡排序
     * 时间复杂度 n^2
     * 空间复杂度  1
     * @param array
     */
    public static void bubbleSort(int[]array){
        for (int i = 0; i < array.length-1; i++) {//趟数
            boolean flg =false;
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j]>array[j+1]){
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            if (flg == false){
                return;
            }
        }
    }


1.遍历 i 代表交换的趟数,遍历 j 进行两两交换

2.j < array.length-1-i 是对于趟数的优化,每走一趟,交换就少一次

3.boolean flg =false;当两两交换时,flg变为true

4.进一步优化:如果遍历完,没发生交换,flg还是false,直接返回,排序结束

  • 时间复杂度:O ( N2 )
  • 空间复杂度:O ( 1 )
  • 稳定性:稳定

2.快速排序

  • 时间复杂度:

    最好情况:O (N*log2N) :树的高度为log2N,每一层都是N

    最坏情况:O (N2):有序、逆序的情况下,没有左树,只有右树,单分支树,树的高度是N,每一层都是N

  • 空间复杂的:

    最好情况:O (log2N):满二叉树(均匀分割待排序的序列,效率最高)树高为 log2N

    最坏情况:O(N):单分支树,树高为N

  • 稳定性:不稳定

  • 二叉树结构的交换排序方法

  • 任取一个待排序元素作为基准值,把序列一分为二,左子序都比基准值小,右子序都比基准值大,左右两边再重复进行

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 左边找比基准值大的,右边找比基准值小的
1.挖坑法

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 基准值位置挖一个坑,后面找一个比基准值小的把坑埋上
  • 前面找一个比基准值大的,埋后面的坑
  • 当l==r时,把基准值填入剩下的坑中

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 左右两边重复进行上述步骤,直到排完为止
  • 左右两边都以同样的方法进行划分,运用递归来实现
    /**
     * 快速排序
     * 时间复杂度:N*log~2~N
     * 空间复杂度
     * 
     * @param array
     */

    public static void quickSort(int[] array) {
        quick(array, 0, array.length - 1);
    }

    private static void quick(int[] array, int start, int end) {
        if (start >= end) {
            return;//结束条件
            // start == end,说明只剩一个了,是有序的,返回
            //start > end ,说明此时的基准值在开头或者末尾
            //在开头:start不变,end=pivot-1,start > end ,end=-1 没有左树
            //在结尾:end不变,start = pivot+1,start > end,超出索引,没有右树
        }
        //不断递归quick
        int pivot = partition(array, start, end);// 进行排序,划分找到pivot
        //然后递归划分法左边,递归划分的右边
        quick(array, start, pivot - 1);
        quick(array, pivot + 1, end);
    }

    // ---挖坑法  划分,返回基准值
    private static int partition(int[] array, int left, int right) {
        int tmp = array[left];//挖一个坑,取left位置为基准值
        while (left < right) {
            //在右边找一个比基准值小的把坑填上
            while (left < right && array[right] >= tmp) {//防止越界
                right--;
            }
            array[left] = array[right];//找到比tmp小的数,填坑,

            //在左边找一个比tmp大的值,填到右边的坑
            while (left < right && array[left] <= tmp) {//防止越界
                left++;
            }
            array[right] = array[left];
        }//如果相遇了,退出循环
        array[left] = tmp;//填坑
        return left;
    }

  • 先划分序列,递归左边,然后再递归右边

  • 递归结束条件:

    start == end时,说明只剩一个了,是有序的,返回
    start > end 时 ,说明此时的基准值在开头或者末尾

    如果基准值在开头:start不变,end=pivot-1,start > end ,end=-1 没有左树
    如果基准值在结尾:end不变,start = pivot+1,start > end,超出索引,没有右树


2.Hoare法

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 不同的方法,找出基准值,排的序列是不一样的

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • i记录基准值一开始在left位置的下标
  • r找到比基准值小的停下来,l找到比基准值大的停下来,互相交换
  • l和r相遇的时候,把i 记录基准值的初始下标和相遇位置交换

以左边为基准,先找右边再找左边,相遇的位置就是以右边为基准的值,要比基准小,才能交换

    /**
     * Hoare法 划分排序找基准值
     * @param array
     * @param left
     * @param right
     * @return
     */
    private static int partition2(int[] array, int left, int right) {
        int tmp = array[left];
        int i  = left;//记录基准值一开始在left位置的下标
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            while (left < right && array[left] <= tmp) {
                left++;
            }
            swap(array,left,right);
        }
        swap(array,i,left);
        return left;
    }
3.前后指针法

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • prev记录了比key小的最后一个位置
  • cur去找比key值小的,找到后,放到prev的下一个位置
  • 最后找到基准值,并且基准值的左边都比它小,右边都比他大
    /**
     * 前后指针法,划分排序找基准值
     *
     * @param array
     * @param left
     * @param right
     * @return
     */
    private static int partition3(int[] array, int left, int right) {
        int prev = left; //prev从left位置开始,left为当前的基准值
        int cur = left + 1;//cur在prev的后一个
        while (cur <= right) {//遍历完当前数组段
            if (array[cur] < array[left] && array[++prev] != array[cur]) {
                //只要cur指向的值小于left位置的基准值
                //并且prev++后不等于cur的值
                swap(array, cur, prev);//将cur和prev位置的值交换
                //cur++;
            }
            //如果cur的值大于基准值,或者prev下一位的值等于cur,cur后移
            cur++;
        }
        //cur越界,循环结束,最后,交换基准值和prev位置的值
        //prev记录的就是比基准值小的最后一个数
        swap(array, prev, left);
        return prev;//prev为基准值
    }

4.快速排序的优化
  • 时间复杂度:

    最好情况:O (N*log2N) :树的高度为log2N,每一层都是N

    最坏情况:O (N2):有序、逆序的情况下,没有左树,只有右树,单分支树,树的高度是N,每一层都是N

  • 空间复杂的:

    最好情况:O (log2N):满二叉树(均匀分割待排序的序列,效率最高)树高为 log2N

    最坏情况:O(N):单分支树,树高为N

  • 稳定性:不稳定

  • 快速排序有可能发生栈溢出异常,需要进行优化

  • 所以要能均匀分割待排序的序列

递归的次数多了,会导致栈溢出,所以优化的方向就是减少递归的次数

方法一、三数取中法选基准值
方法二、递归到最小区间时、用插入排序
5.快速排序非递归实现

的值等于cur,cur后移
cur++;
}
//cur越界,循环结束,最后,交换基准值和prev位置的值
//prev记录的就是比基准值小的最后一个数
swap(array, prev, left);
return prev;//prev为基准值
}




#####  4.快速排序的优化

- 时间复杂度:

  > 最好情况:O (N*log~2~N)   :树的高度为log~2~N,每一层都是N
  >
  >  最坏情况:O (N^2^):有序、逆序的情况下,没有左树,只有右树,单分支树,树的高度是N,每一层都是N 
  >
  > 

- 空间复杂的:

  > 最好情况:O (log~2~N):满二叉树(均匀分割待排序的序列,效率最高)树高为 log~2~N
  >
  > 最坏情况:O(N):单分支树,树高为N

- 稳定性:不稳定

- 快速排序有可能发生栈溢出异常,需要进行优化
- 所以要能均匀分割待排序的序列

递归的次数多了,会导致栈溢出,所以优化的方向就是减少递归的次数



###### 方法一、三数取中法选基准值





###### 方法二、递归到最小区间时、用插入排序







##### 5.快速排序非递归实现



## 五、归并排序 

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

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

相关文章

机器视觉系统中的工业镜头的参数

光学倍率 β 焦距 f F值&#xff08;光圈&#xff09;Fno. 数值孔径 NA 工作距离 WD 视场&#xff08;视场角&#xff0c;视野&#xff09; 景深DOF 分辨率、分辨力 MTF 畸变

深入理解注意力机制(上)-起源

一、介绍 近几年自然语言处理有很大的进展&#xff0c;从 2018 年 Google 推出的 BERT&#xff0c;到后来的 GPT、ChatGPT 等&#xff0c;这些模型当时能取得这样的成果&#xff0c;除了庞大的数据量及损害资源外&#xff0c;最重要的是的就是背后的Transformer模型&#xff0c…

电子学会C/C++编程等级考试2022年03月(一级)真题解析

C/C++等级考试(1~8级)全部真题・点这里 第1题:双精度浮点数的输入输出 输入一个双精度浮点数,保留8位小数,输出这个浮点数。 时间限制:1000 内存限制:65536输入 只有一行,一个双精度浮点数。输出 一行,保留8位小数的浮点数。样例输入 3.1415926535798932样例输出 3.1…

莹莹API管理系统源码附带两套模板

这是一个API后台管理系统的源码&#xff0c;可以自定义添加接口&#xff0c;并自带两个模板。 环境要求 PHP版本要求高于5.6且低于8.0&#xff0c;已测试通过的版本为7.4。 需要安装PHPSG11加密扩展。 已测试&#xff1a;宝塔/主机亲测成功搭建&#xff01; 安装说明 &am…

算法——动态规划(新)

什么是动态规划&#xff1f; 动态规划算法的基本思想-求解步骤-基本要素和一些经典的动态规划问题【干货】-CSDN博客 一、三步问题 面试题 08.01. 三步问题 - 力扣&#xff08;LeetCode&#xff09; 思路 我们要知道&#xff0c;走楼梯&#xff0c;前三个阶梯步数已经知道&…

基于深度学习的恶意软件检测

恶意软件是指恶意软件犯罪者用来感染个人计算机或整个组织的网络的软件。 它利用目标系统漏洞&#xff0c;例如可以被劫持的合法软件&#xff08;例如浏览器或 Web 应用程序插件&#xff09;中的错误。 恶意软件渗透可能会造成灾难性的后果&#xff0c;包括数据被盗、勒索或网…

原理Redis-动态字符串SDS

动态字符串SDS Redis中保存的Key是字符串&#xff0c;value往往是字符串或者字符串的集合。可见字符串是Redis中最常用的一种数据结构。 不过Redis没有直接使用C语言中的字符串&#xff0c;因为C语言字符串存在很多问题&#xff1a; 获取字符串长度的需要通过运算非二进制安全…

【计算思维】蓝桥杯STEMA 科技素养考试真题及解析 4

1、下列哪个选项填到填到下图空缺处最合适 A、 B、 C、 D、 答案&#xff1a;D 2、按照如下图的规律摆放正方形&#xff0c;第 5 堆正方形的个数是 A、13 B、14 C、15 D、16 答案&#xff1a;D 3、从右面观察下面的立体图形&#xff0c;看到的是 A、 B、 C、 D、 答…

Jmeter做接口测试

1.Jmeter的安装以及环境变量的配置 Jmeter是基于java语法开发的接口测试以及性能测试的工具。 jdk&#xff1a;17 (最新的Jeknins&#xff0c;只能支持到17) jmeter&#xff1a;5.6 官网&#xff1a;http://jmeter.apache.org/download_jmeter.cgi 认识JMeter的目录&#xff1…

原理Redis-IntSet

IntSet IntSet是Redis中set集合的一种实现方式&#xff0c;基于整数数组来实现&#xff0c;并且具备长度可变、有序等特征。 结构如下&#xff1a; typedef struct intset {uint32_t encoding; /* 编码方式&#xff0c;支持存放16位、32位、64位整数*/uint32_t length; /* 元素…

基于Python+OpenCV+Tensorflow图像迁移的艺术图片生成系统

欢迎大家点赞、收藏、关注、评论啦 &#xff0c;由于篇幅有限&#xff0c;只展示了部分核心代码。 文章目录 一项目简介 二、功能三、系统![请添加图片描述](https://img-blog.csdnimg.cn/dbda87069fc14c24b71c1eb4224dff05.png)四. 总结 一项目简介 基于PythonOpenCVTensorfl…

边缘计算是如何为元宇宙提供动力的?

构建元宇宙虚拟世界并不简单&#xff0c;也并不便宜&#xff0c;但是还是有许多大型公司正在转移大量资源来开发他们的元宇宙业务&#xff0c;当然大部分企业注意力都围绕着 VR 耳机、AR 眼镜、触觉手套和其他沉浸式虚拟现实体验所需的可穿戴硬件。虽然这种沉浸式的体验是最终结…

2023.11.17 关于 Spring Boot 日志文件

目录 日志文件作用 常见的日志框架说明 门面模式 日志的使用 日志的级别 六种级别 日志级别的设置 日志的持久化 使用 Lombok 输出日志 实现原理 普通打印和日志的区别 日志文件作用 记录 错误日志 和 警告日志&#xff08;发现和定位问题&#xff09;记录 用户登录…

web自动化测试的智能革命:AI如何推动软件质量保证的未来

首先这个标题不是我取的&#xff0c;是我喂了关键字让AI给取的&#xff0c;果然非常的标题党&#xff0c;让人印象深刻&#xff0c;另外题图也是AI自动生成的。 先简单回顾一下web自动化测试的一些发展阶段 QTP时代 很多年前QTP横空出世的时候&#xff0c;没有人会怀疑这种工…

【项目管理】中途接手的项目应对实用指南

导读&#xff1a;作为项目经理中途接手项目往往不可避免&#xff0c;为了保证项目成功需要项目经理额外考虑更多的因素和处理相关问题&#xff0c;也往往带来很大的挑战性。本文提供可应对借鉴的思路&#xff0c;在一定程度上可以作为最佳实践。 目录 1、首先、了解项目项目背…

python趣味编程-5分钟实现一个俄罗斯方块游戏(含源码、步骤讲解)

Python俄罗斯方块游戏是一款基于GUI的标题匹配益智游戏,非常容易理解和使用。说到游戏玩法,一切都和真实的一样。 用户必须管理俄罗斯方块的随机序列。在这个Python 俄罗斯方块游戏项目中,我将教您如何使用 Python 制作俄罗斯方块游戏。 Python 代码中的俄罗斯方块游戏:项目…

Redux-状态管理组件

一、简介 react中的状态只属于某个组件。而Redux是一个全局管理js状态的架构&#xff0c;让组件通信更加容易。 之前是状态在所有组件间传递&#xff0c;而redux通过store来实现这个功能。 Redux特性&#xff1a; 1.Single source Of truth&#xff0c;通过store唯一维护状态…

nn.KLDivLoss,nn.CrossEntropyLoss,nn.MSELoss,Focal_Loss

KL loss&#xff1a;https://blog.csdn.net/qq_50001789/article/details/128974654 https://pytorch.org/docs/stable/nn.html 1. nn.L1Loss 1.1 公式 L1Loss: 计算预测 x和 目标y之间的平均绝对值误差MAE, 即L1损失&#xff1a; l o s s 1 n ∑ i 1 , . . . n ∣ x i…

SpringCloud 微服务全栈体系(十四)

第十一章 分布式搜索引擎 elasticsearch 四、RestAPI ES 官方提供了各种不同语言的客户端&#xff0c;用来操作 ES。这些客户端的本质就是组装 DSL 语句&#xff0c;通过 http 请求发送给 ES。官方文档地址&#xff1a;https://www.elastic.co/guide/en/elasticsearch/client/…

Amazon EC2的出现,是时代的选择了它,还是它选择了时代

目录 Amazon EC2简介 友商云服务器对比&#xff08;Amazon VS Tencent&#xff09; 友商云服务器对比&#xff08;Amazon VS Alibaba&#xff09; Amazon 云服务器的绝对优势 Amazon EC2功能 Amazon EC2 Linux 实例入门 启动实例 连接到的实例 清除的实例 终止的实例…