【数据结构-JAVA】排序

news2025/6/5 19:22:36

排序在现实生活中的应用可谓相当广泛，比如电商平台中，选购商品时，使用价格排序或是综合排序、高考填报志愿的时候，会参考全国大学排名的情况。

下面介绍一些计算机中与排序相关的概念：

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持 不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳 定的；否则称为不稳定的。

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

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

  1. 插入排序

1.1 直接插入排序

1.1.1 插入排序的基本思想

把待排序的记录按其关键码值的大小与已经排好序的序列逐个比较大小，插入到合适的位置，使整个序列重新有序。实际中我们玩扑克牌时，就用了插入排序的思想。

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…array[0]的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

1.1.2 直接插入法的代码实现

 public class Test {
   public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int j = i - 1;
            int temp =arr[i];
            for (; j >= 0 ; j--) {
                if(arr[j] > temp){
                    arr[j+1] = arr[j];
                }else{
                    break;
                }
            }
            arr[j + 1] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {4,2,5,3,134,74,36,7,8,76,32,17,38,54,38,87,54};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

输出：

[2, 3, 4, 5, 7, 8, 17, 32, 36, 38, 38, 54, 54, 74, 76, 87, 134]

1.1.3 直接插入法的特性总结

直接插入排序的特性总结： 1. 元素集合越接近有序，直接插入排序算法的时间效率越高 2. 时间复杂度：O(N^2) 3. 空间复杂度：O(1) 4. 稳定性：稳定 ，它是一种稳定的排序算法

1.2 希尔排序

1.2.1 希尔排序的基本思想

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先想好间隔的设定方法，比如gap一开始为数组的长度，那么每个记录自成一组，无需排序，往后的间隔依次除以2(可以自己设定)，把待排序文件中所有记录分成gap个组， 并对每一组内的记录进行直接插入排序。然后重复上述分组和排序的工作。当gap =1时，所有记录在统一组内最后插入排序。

1.2.2 希尔排序的代码实现

    //希尔排序：对直接插入法的优化
    public static void shellSort(int[] arr){
        int gap = arr.length;
        while(gap >= 1){
            gap /= 2;
            shell(arr,gap);
        }

    }

    private static void shell(int[] arr, int gap) {
        for (int i = gap; i < arr.length; i++) {
            int j = i - gap;
            int temp = arr[i];
            for (; j >= 0 ; j-=gap) {
                if(arr[j] > temp){
                    arr[j + gap] = arr[j];
                }else{
                    break;
                }
            }
            arr[j + gap] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {5,23,2,51,4,5,642,14,56,82,1,73,59,42,77};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

输出：

[1, 2, 4, 5, 5, 14, 23, 42, 51, 56, 59, 73, 77, 82, 642]

1.2.3 希尔排序的特性总结

希尔排序的特性总结： 1. 希尔排序是对直接插入排序的优化。 2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很 快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。 3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算。Knuth进行了大量的试验统计 ，当n很大时，关键码平均比较次数以及对象平均移动次数大约在范围内。所以对于希尔排序的时间复杂度，我们暂时就按照来计算。 4. 稳定性：不稳定

2. 选择排序

2.1 直接选择排序

2.1.1 直接先择排序的基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置。此时，就有1个元素有序，那么继续从剩下待排序元素中找到最小（或最大）的一个元素，放到有序数组后面，直到全部待排序的数据元 素排完 。

写代码时，如果是在原本数组进行操作，那么只能让序列的最小值与相应位置进行交换了。

2.1.2 直接选择排序的代码实现

    //选择排序
    //从一边查找最小元素
    public static void selectSort(int[] arr){
        //i下标是排序的位置
        //j则是遍历剩下数组元素，找到最小下标
        for (int i = 0; i < arr.length; i++) {
            int j = i + 1;
            int minIndex = i;
            for (; j < arr.length; j++) {
                if(arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            swap(arr,i,minIndex);
        }
    }

    public static void main(String[] args) {
        int[] arr = {3,7,54,24,33,22,18,33,28,13,64,8,26};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

输出：

[3, 7, 8, 13, 18, 22, 24, 26, 28, 33, 33, 54, 64]

为了让选择排序更高效，能不能在序列中查找最小值的同时，查找最大值，让最小值与最大值与各自相应位置进行交换？

    //从序列同时查找最大最小元素并与相应位置上的元素进行交换
    public static void selectSort(int[] arr){
        int left = 0;
        int right = arr.length - 1;

        while(left < right){
            int minIndex = left;
            int maxIndex = left;
            for (int j = left + 1; j <= right; j++) {
                if(arr[j] < arr[minIndex]){
                    minIndex = j;
                }
                if(arr[j] > arr[maxIndex]){
                    maxIndex = j;
                }
            }
            swap(arr,minIndex,left);
            if(left == maxIndex){
                maxIndex = minIndex;
            }
            swap(arr,maxIndex,right);
            left++;
            right--;
        }
    }

    public static void main(String[] args) {
        int[] arr = {4,3,22,56,77,23,53,7,13,75,224,6,27,69,49,88};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

输出：

[3, 4, 6, 7, 13, 22, 23, 27, 49, 53, 56, 69, 75, 77, 88, 224]

2.1.3 直接排序的特定

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用 2. 时间复杂度：O(N^2) 3. 空间复杂度：O(1) 4. 稳定性：不稳定

2.2 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆 来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

2.2.1 堆排序的代码实现

   //堆排序，从小到大 -> 建立大堆 ； 从大到小 -> 建立小堆
    public static void heapSort(int[] arr){
        if(arr == null){
            return;
        }
        createHugeHeap(arr);
        int end = arr.length - 1 ;
        while(end > 0){
            swap(arr,0,end);
            shiftDown(arr,0,end);
            end--;
        }

    }

    //向下调整：
    private static void shiftDown(int[] arr,int parent,int len){
        int child = 2 * parent + 1;
        while(child < len){
            if(child + 1 < len && arr[child] < arr[child + 1]){
                child++;
            }
            if(arr[child] > arr[parent]){
                swap(arr,child,parent);
                parent = child;
                child = 2 * parent + 1;
            }else{
                break;
            }
        }
    }

    private static void createHugeHeap(int[] arr){
        for (int parent = (arr.length - 1 - 1)/2; parent >= 0 ; parent--) {
            shiftDown(arr,parent,arr.length );
        }
    }

    public static void main(String[] args) {
        int[] arr = {76,35,62,5,62,43,55,13,27,28,33,2,79,1};
        Sort.heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

输出：

[1, 2, 5, 13, 27, 28, 33, 35, 43, 55, 62, 62, 76, 79]

2.2.2堆排序的特性

【堆排序的特性总结】 1. 堆排序使用堆来选数，效率就高了很多。 2. 时间复杂度：O(N*logN) 3. 空间复杂度：O(1) 4. 稳定性：不稳定

3. 交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特 点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

3.1 快速排序

3.1.1 快速排序的基本思想

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元 素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有 元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

3.1.2 快速排序的代码实习

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

    }

    private static void quick(int[] arr, int start, int end) {
        if(start >= end){
            return;
        }

        //int pivot = partition(arr,start,end);
        int pivot = partition1(arr,start,end);
        quick(arr,start,pivot - 1);
        quick(arr,pivot + 1,end);
    }

填坑法

    //填坑法
    private static int partition(int[] arr,int left,int right){
        int temp = arr[left];
        while(left < right){

            //这里的等号不能省略，否则会陷入死循环
            //而有了等号，left < right 这个条件就不能省略
            while(left < right && arr[right] >= temp){
                right--;
            }
            swap(arr,right,left);
            while(left < right && arr[left] <= temp){
                left++;
            }
            swap(arr,left,right);
        }
        arr[left] = temp;
        return left;
    }

Hoare法

    //Hoare 法
    private static int partition1(int[] arr,int left,int right){
        int temp = arr[left];
        int i = left;
        while(left < right){
            while(left < right && arr[right] >= temp){
                right--;
            }
            while(left < right && arr[left] <= temp){
                left++;
            }
            swap(arr,left,right);
        }

        swap(arr,left,i);
        return left;
    }

上述的快速排序有一个问题，那就是如果数组已经是有序或是逆序的情况下，再次快排，每次都没有左树或是右数，比较费空间和时间，时间复杂度会达到O(N²)，而且空间复杂度达到O(N)，而只有每次划分都很平均的情况下，时间复杂度会达到O(NlogN)，而且空间复杂度达到O(logN)。所以这里可以采用三数取中法来对快速排序进行优化。

三数取中法优化快排

    //三数取中法：优化快排
    private static int midThree(int[] arr,int head ,int tail ,int mid){
        if(arr[head] > arr[tail]){
            if(arr[mid] > arr[head]){
                return head;
            }else if(arr[tail] > arr[mid]){
                return tail;
            }else{
                return mid;
            }
        }else{
            if(arr[mid] > arr[tail]){
                return tail;
            }else if(arr[mid] < arr[head]){
                return head;
            }else{
                return mid;
            }
        }
    }

//上述quick 方法修改如下：
    private static void quick(int[] arr, int start, int end) {
        if(start >= end){
            return;
        }
        int mid = (start + end)/2;
        int midIndex = midThree(arr,start,end,mid);
        swap(arr,mid,start);

        //int pivot = partition(arr,start,end);
        int pivot = partition1(arr,start,end);
        quick(arr,start,pivot - 1);
        quick(arr,pivot + 1,end);
    }

    public static void main(String[] args) {
        int[] arr = {9,8,7,6,5,4,3,2,1,0};
        Sort.quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }

快排的非递归实现

public static void quickSortNor(int[] arr){
        int left = 0;
        int right = arr.length - 1;
        int pivot = partition(arr,left,right);
        Deque<Integer> stack = new LinkedList<>();
        if(pivot - 1 > left){
            stack.push(pivot - 1);
            stack.push(left);
        }
        if(right > pivot + 1){
            stack.push(right);
            stack.push(pivot + 1);
        }
        
        while(!stack.isEmpty()){
            left = stack.pop();
            right = stack.pop();
            pivot = partition(arr,left,right);
            if(pivot - 1 > left){
                stack.push(pivot - 1);
                stack.push(left);
            }
            if(right > pivot + 1){
                stack.push(right);
                stack.push(pivot + 1);
            }
        }
}

3.1.3 快速排序的特点

1. 快速排序整体的综合性能和使用场景都是比较好的，所以才叫快速排序 2. 时间复杂度：O(N*logN)

3. 空间复杂度：O(logN) 4. 稳定性：不稳定

3.2 冒泡排序

3.2.1 冒泡排序的代码实现

    //改进之后的冒泡排序：
    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if(arr[j] > arr[j + 1]){
                    swap(arr,j,j+1);
                    flag = true;
                }
            }
            if(flag == false){
                return;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {2,35,7,245,65,24,26,12,15,2,52,74,55,29,39,6};
        Sort.bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

输出：

[2, 2, 6, 7, 12, 15, 24, 26, 29, 35, 39, 52, 55, 65, 74, 245]

3.2.2 冒泡排序的特点

【冒泡排序的特性总结】 1. 冒泡排序是一种非常容易理解的排序 2. 时间复杂度：O(N^2) 3. 空间复杂度：O(1) 4. 稳定性：稳定

4. 归并排序

4.1 归并排序的基本思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使 子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

4.2 归并排序的代码实现

递归实现归并排序

public static void mergeSort(int[] arr){
        divide(arr,0,arr.length - 1);
}

private static void divide(int[] arr,int left,int right){
        if(left >= right){
            return;
        }

        int mid = (left + right)/2;
        divide(arr,left,mid);
        divide(arr,mid+1,right);
        merge(arr,left,right,mid);
}

    private static void merge(int[] arr, int start, int end, int mid) {
        int s1 = start;
        int s2 = mid + 1;
        int[] temp = new int[end - start + 1];
        int k = 0;
        while(s1 <= mid && s2 <= end){
            if(arr[s1] < arr[s2]){
                temp[k++] = arr[s1++];
            }else{
                temp[k++] = arr[s2++];
            }
        }
        while(s1 <= mid){
            temp[k++] = arr[s1++];
        }
        while(s2 <= end){
            temp[k++] = arr[s2++];
        }
        for (int i = 0; i < temp.length; i++) {
            arr[start + i] = temp[i];
        }
    }

非递归实现归并排序

    public static void mergeSort(int[] arr){
        int gap = 1;
        while(gap < arr.length){
            for (int i = 0; i < arr.length; i += 2 * gap) {
                int left = i;
                int mid = left + gap - 1;
                if(mid >= arr.length){
                    mid = arr.length - 1;
                }
                int right = mid + gap;
                if(right >= arr.length){
                    right = arr.length - 1;
                }
                merge(arr,left,right,mid);
            }
            gap *= 2;
        }
    }

4.3 归并排序的特点

1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。 2. 时间复杂度：O(N*logN) 3. 空间复杂度：O(N) 4. 稳定性：稳定

5. 其他排序

5.1 计数排序

5.1.1 计数排序的基本思想

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤： 1. 统计相同元素出现次数 2. 根据统计的结果将序列回收到原来的序列中

5.1.2 计数排序的代码实现

    public static void countSort(int[] arr){
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
            if(arr[i] < min){
                min = arr[i];
            }
        }

        int[] count = new int[max - min + 1];

        for (int i = 0; i < arr.length; i++) {
            count[arr[i] - min]++;
        }

        int k = 0;
        for (int i = 0; i < count.length; i++) {
            while(count[i] > 0){
                arr[k] = i + min;
                k++;
                count[i]--;
            }
        }
    }

5.1.3 计数排序的特点

【计数排序的特性总结】

1. 计数排序在数据范围集中时，效率很高，是一种不需要比较大小的排序方式，但是适用范围及场景有限。

2. 时间复杂度：O(MAX(N,范围))

3. 空间复杂度：O(范围)

4. 稳定性：稳定

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

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

相关文章

超详细的JAVA高级进阶基础知识03

超详细的JAVA高级进阶基础知识03

目录 3. 面向对象高级 - 常用的API 3.1 Object 类 3.1.1 Object 类介绍 3.1.2 Object类的常用方法&#xff1a; 3.1.3 Objects 概述 3.2 Math 类 3.3 System 类 3.3.1 System 类概述 3.3.2 常用方法 3.4 BigDecimal 类 3.4.1 BigDecimal 类概述 3.4.2 BigDecimal 类…
阅读更多...
windows 编译 open3d 下

windows 编译 open3d 下

1.安装cmake 快速通道&#xff1a;链接&#xff1a;https://pan.baidu.com/s/1gZYAlGRRj4UVGgaTBaZXjg?pwd1klo 提取码&#xff1a;1klo --来自百度网盘超级会员V4的分享警告不用管编译中成功就是61开始配置 cmake 那时候选的路径glew.libglfw3.libjsoncpp.libOpen3D.libpng.l…
阅读更多...
jdk和Android sdk 和 ndk 和 apache-ant环境变量配置

jdk和Android sdk 和 ndk 和 apache-ant环境变量配置

ANDROID_HOMEG:\android-sdk-windowsCLASSPATH.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar;%JAVA_HOME%\jre\lib\rt.jar;%JAVA_HOME%\lib\dt.jar;%ANT_HOME%\libJAVA_HOMEC:\Program Files (x86)\Java\jdk1.8.0_361NDK_HOMEG:\android-ndk-r25cant下载https://www.likecs.com…
阅读更多...
win环境安装部署Jenkins

win环境安装部署Jenkins

win环境安装部署Jenkins&#xff0c;2022年11月&#xff1a;从2022年 6 月 28 日发布的 Jenkins 2.357 和2022年9 月发布的 LTS 版本开始&#xff0c;Jenkins 需要 Java 11 才能使用&#xff0c;放弃 Java 8&#xff0c;如果用JDK1.8&#xff0c;那么Jenkins版本需要是2.357版本…
阅读更多...
ChatGPT逐鹿：谷歌“翻车”，微软抢跑，国内概念股狂飙

ChatGPT逐鹿：谷歌“翻车”，微软抢跑，国内概念股狂飙

2023年开年才一个月&#xff0c;微软、谷歌两大巨头在AI战场就上演了“神仙打架”。 1月里两家公司围绕OpenAI和ChatGPT发布的密集消息余温尚在&#xff0c;2月7日&#xff0c;谷歌就官宣了自家的ChatGPT竞品Bard&#xff0c;并发布演示Demo。2月8日&#xff0c;微软直接上线了…
阅读更多...
室内三维地图怎么做的？室内地图怎么做好看？

室内三维地图怎么做的？室内地图怎么做好看？

室内导航、定位中须采用基于建筑平面图生产的室内地图&#xff0c;现有的生产室内地图的方法都是依靠人工去根据建筑平面图使用矢量绘图工具去绘制矢量化的室内地图示意图&#xff0c;然后再去标明具体的区域名称功能或者标注位置点。因此制作室内地图往往都比较耗时&#xff0…
阅读更多...
blender基础操作

blender基础操作

shiftc&#xff1a;游标回到世界中心 shifta: 添加物体 gx或y或z&#xff1a;沿x轴或y轴或z轴移动 gx加数字&#xff1a;往x轴方向移动几格 rx加度数&#xff1a;绕x轴旋转多少度 分割界面&#xff1a;右键单击间隙&#xff0c;选择verticle tab: 来回切换编辑界面和物体界面&…
阅读更多...
下班前几分钟，逮到一个腾讯10年老测试开发，聊过之后大彻大悟...

下班前几分钟，逮到一个腾讯10年老测试开发，聊过之后大彻大悟...

优秀的人真的是比比皆是&#xff0c;不比不知道&#xff0c;一比吓一跳 老话说的好&#xff0c;这人呐&#xff0c;一单在某个领域鲜有敌手了&#xff0c;就会闲得蛋疼。就在昨天下班的前几分钟认识了一个在阿里工作了 10 年的测试开发&#xff0c;因为本人天赋比较高&#xff…
阅读更多...
Nacos 配置管理最佳实践

Nacos 配置管理最佳实践

作者&#xff1a;翼严 Nacos 简介 Nacos 是一个更易于构建云原生应用的微服务基础平台&#xff0c;核心包含动态服务发现&#xff0c;配置管理&#xff0c;服务管理平台。 配置管理是 Nacos 的核心功能&#xff0c;它提供了运行期不重启应用的情况下动态修改配置值的功能。 …
阅读更多...
修改Vue项目运行的IP和端口

修改Vue项目运行的IP和端口

前言 我们在使用VsCode启动Vue项目的时候&#xff0c;我发现&#xff1a;默认的端口号好像和tomcat一样&#xff0c;默认都是8080&#xff0c;如果8080被占用了&#xff0c;就会使用8081,8082这样的方式以此类推。 那么&#xff0c;我们是否可以像后端一样&#xff0c;通过修改…
阅读更多...
MySQL数据库04——索引

MySQL数据库04——索引

索引基础 使用索引的主要原因之一就是提供唯一的字段值。唯一索引强制表中任意两条记录的索引值互不相同。创建唯一索引需要使用UNIQUE关键字。下面通过例题说明创建和使用惟一索引的方法。 创建和使用唯一索引 首先&#xff0c;在MySQL 中创建例题中将要使用的testuni表&…
阅读更多...
独立图片服务器有什么突出之处

独立图片服务器有什么突出之处

服务器是网络中非常重要的设施&#xff0c;承载着不同流量的访问&#xff0c;这就要求服务器具有快速的吞吐量、高稳定性和高可靠性。独立图片服务器作为独立服务器的衍生品&#xff0c;在数据利用方面的应用可以为企业在数据处理和分析方面带来一场革命。本文就将介绍独立图片…
阅读更多...
windows 重启redis的方法

windows 重启redis的方法

目录打开本地的文件夹选中文件的路径输入cmd在cmd命令窗口中输入以下的指令指令的内容以及对应的命令含义前言&#xff1a;最近在本地搭建redis环境&#xff0c;突然发现本地的redis启动失败了&#xff0c;使用reids的启动命令也不行&#xff0c;于是找了不少的方法&#xff0c…
阅读更多...
windows下Spark环境搭建

windows下Spark环境搭建

一、下载 我的是hadoop3.0.0,下载Hadoop3.0&#xff1a;下载链接 自己选择一个盘&#xff0c;我这里是 D:\software 1、配置Hadoop_HOME环境变量 新建系统变量 2、在Path环境变量&#xff0c;添加 %HADOOP_HOME%\bin3、修改配置文件&#xff1a;在hadoop-3.0.0\etc\hadoop…
阅读更多...
原创 | arXiv上成功发表的预印本有什么特征？这样写，你的论文也能中！

原创 | arXiv上成功发表的预印本有什么特征？这样写，你的论文也能中！

作者&#xff1a;林嘉亮审校&#xff1a;陈之炎本文约4400字&#xff0c;建议阅读8分钟本文介绍了专注于科学和工程领域的印刷本平台——arXiv的特征。“预印本&#xff08;preprint&#xff09;是一份完整的科学论文手稿&#xff08;通常也会同时提交给需要同行评审的期刊&…
阅读更多...
Linux centos系统安装argoverse-api问题解决

Linux centos系统安装argoverse-api问题解决

1、遇到带有sklearn关键字的报错 将setup.py中的sklearn改为scikit-learn 2、遇到CMake 3.1 or higher is required. You are running version 2.8.12.2....... 在python包管理器发现版本正常 于是使用centos命令手动安装 1、移除老版本cmake版本并安装依赖包 yum remove c…
阅读更多...
[Unity 打包WebGL用本地服务器Tomcat测试]

[Unity 打包WebGL用本地服务器Tomcat测试]

打包WebGLUnity-WebGL-环境部署、打包1、 步骤流程图&#xff1a;不要忘记把场景加上去发布时不要勾选Development Build&#xff0c;勾选后文件非常大&#xff0c;然后点击上图左下角的 Player Settings设置一下分辨率、做一个 UI 自适应。strip engine code&#xff1a;官方文…
阅读更多...
从降本增效到电机控制知识树

从降本增效到电机控制知识树

回顾永磁同步电机控制应用场景&#xff0c;电机控制算法的发展大体归结于四个字&#xff0c;降本增效。以下内容围绕这四个字&#xff0c;增效、降本两个方面梳理该领域相关知识&#xff0c;串联永磁同步电机控制技术体系。 1、 增效 增效即提高控制性能&#xff0c;具体落脚…
阅读更多...
[Nginx]Ngnix基础

[Nginx]Ngnix基础

文章目录一、基础1.1 what can nginx do1.1.1 基本HTTP服务1.1.2 高级HTTP服务1.1.3 Nginx常用的功能模块1.1.4 Nginx的核心组成1.2 why nginx?1.3 安装(略&#xff09;1.4 nginx的目录结构1.5 nginx.conf的几个关键配置keepalive_timeoutkeepalive_requestsserver块和locatio…
阅读更多...
Python自动化测试实战篇（4）selenium+unttest+ddt实现自动化用例测试，模拟用户登陆点击交互测试，Assert捕获断言多种断言

Python自动化测试实战篇（4）selenium+unttest+ddt实现自动化用例测试，模拟用户登陆点击交互测试，Assert捕获断言多种断言

这些是之前的文章&#xff0c;里面有一些基础的知识点在前面由于前面已经有写过&#xff0c;所以这一篇就不再详细对之前的内容进行描述 Python自动化测试实战篇&#xff08;1&#xff09;读取xlsx中账户密码&#xff0c;unittest框架实现通过requests接口post登录网站请求&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023