java基础进阶之数组排序-可能有你不知道的哦！！

1、使用Arrays类的sort方法

1.1、默认升序

        java中Arrays类提供了sort方法来进行快速排序，默认是升序的。

Arrays.sort(数组名)

private static void ArrSort1(int[] arr) {Arrays.sort(arr);System.out.println("快速排序-默认升序:"+Arrays.toString(arr));}

1.2、降序        

如果需要降序，写法如下：

//数组类型不能是基本数据类型

 Arrays.sort(数组名，Collections.reverseOrder())

private static void ArrSort2(int[] arr) {//数组类型不能是基本数据类型Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);Arrays.sort(arrayInteger, Collections.reverseOrder());System.out.println("快速排序-降序:"+Arrays.toString(arrayInteger));}

1.3、区间排序        

如果需要区间排序，写法如下：

//formIndex起始位置，toIndex结束位置

Arrays.sort(数组名,int formIndex, int toIndex)

private static void ArrSort3(int[] arr) {Arrays.sort(arr,1, 3);System.out.println("快速排序-区间排序:"+Arrays.toString(arr));}

1.4、重载排序

//数组类型不能是基本数据类型

Arrays.sort(数组名, new Comparator<数据类型对应的类>() {
    @Override
    public int compare(数据类型对应的类 o1, 数据类型对应的类 o2) {
        return 重载方式;
    }
});

private static void ArrSort4(int[] arr) {Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);Arrays.sort(arrayInteger, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;}});System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));}private static void ArrSort5(int[] arr) {Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);//lambda表达式Arrays.sort(arrayInteger, (o1, o2) -> o2 - o1);System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));}

2、冒泡排序

        冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

        它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

        这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

2.1、原理

冒泡排序的原理如下：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2.2、示例图

2.3、时间复杂度

2.4、稳定性

        冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

2.5、示例

   private static void ArrSortM(int[] arr) {for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {// 升序：如果左边的数大于右边的数，则交换，保证右边的数字最大// 降序：如果左边的数小于右边的数，则交换，保证右边的数字最小if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}System.out.println("冒泡排序:"+Arrays.toString(arr));}private static void ArrSortM1(int[] arr) {// 初始时 swapped 为 true，否则排序过程无法启动boolean swapped = true;for (int i = 0; i < arr.length - 1; i++) {// 如果没有发生过交换，说明剩余部分已经有序，排序完成if (!swapped) break;// 设置 swapped 为 false，如果发生交换，则将其置为 trueswapped = false;for (int j = 0; j < arr.length - 1 - i; j++) {if (arr[j] > arr[j + 1]) {// 如果左边的数大于右边的数，则交换，保证右边的数字最大int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;// 表示发生了交换swapped = true;}}}System.out.println("冒泡排序1:"+Arrays.toString(arr));}private static void ArrSortM2(int[] arr) {for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {// 不添加参数的写法// 升序：如果左边的数大于右边的数，则交换，保证右边的数字最大// 降序：如果左边的数小于右边的数，则交换，保证右边的数字最小if (arr[j] > arr[j + 1]) {arr[j + 1] = arr[j + 1] + arr[j];arr[j] = arr[j + 1] - arr[j];arr[j + 1] = arr[j + 1] - arr[j];}}}System.out.println("冒泡排序2:"+Arrays.toString(arr));}private static void ArrSortM3(int[] arr) {boolean swapped = true;// 最后一个没有经过排序的元素的下标int indexOfLastUnsortedElement = arr.length - 1;// 上次发生交换的位置int swappedIndex = -1;while (swapped) {swapped = false;for (int i = 0; i < indexOfLastUnsortedElement; i++) {if (arr[i] > arr[i + 1]) {// 如果左边的数大于右边的数，则交换，保证右边的数字最大int temp = arr[i];arr[i] = arr[i + 1];arr[i + 1] = temp;// 表示发生了交换swapped = true;// 更新交换的位置swappedIndex = i;}}// 最后一个没有经过排序的元素的下标就是最后一次发生交换的位置indexOfLastUnsortedElement = swappedIndex;}System.out.println("冒泡排序3:"+Arrays.toString(arr));}

3、选择排序

3.1、原理

选择排序：通过不断选择数组中最小的元素，并将其放置在已排序部分的末尾，逐渐构建有序数组。

 3.2、示例图

 

3.3、时间复杂度

        选择排序的交换操作介于 0 和 (n - 1)次之间。选择排序的比较操作为 n (n - 1） / 2 次之间。选择排序的赋值操作介于 0 和 3 (n - 1） 次之间。比较次数O(n^2），比较次数与关键字的初始状态无关，总的比较次数N=(n-1）+(n-2）+...+1=n*(n-1）/2。交换次数O(n），最好情况是，已经有序，交换0次；最坏情况交换n-1次，逆序交换n/2次。交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。

3.4、稳定性

        选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果一个元素比当前元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了，所以选择排序是一个不稳定的排序算法。

3.5、二元选择排序

        二元选择排序，每轮选择时记录最小值和最大值，可以把选择排序的效率提升一点，由于每一轮遍历可以排好两个数字，所以最外层的遍历只需遍历一半即可。

        经过优化之后，选择排序的效率提升了一点。但可惜的是，这样的优化无法改变时间复杂度，我们知道时间复杂度与常量系数无关，仍然是 O(n^2)。

3.6、示例

    private static void ArrSortX(int[] arr) {for (int i = 0; i < arr.length - 1; i++) {int minIndex = i;for (int j = i + 1; j < arr.length; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}System.out.println("选择排序:"+ Arrays.toString(arr));}private static void ArrSortX1(int[] arr) {int minIndex, maxIndex;// i 只需要遍历一半for (int i = 0; i < arr.length / 2; i++) {minIndex = i;maxIndex = i;for (int j = i + 1; j < arr.length - i; j++) {if (arr[minIndex] > arr[j]) {// 记录最小值的下标minIndex = j;}if (arr[maxIndex] < arr[j]) {// 记录最大值的下标maxIndex = j;}}// 将最小元素交换至首位int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;// 如果最大值的下标刚好是 i，由于 arr[i] 和 arr[minIndex] 已经交换了，所以这里要更新 maxIndex 的值。if (maxIndex == i) maxIndex = minIndex;// 将最大元素交换至末尾int lastIndex = arr.length - 1 - i;temp = arr[lastIndex];arr[lastIndex] = arr[maxIndex];arr[maxIndex] = temp;}System.out.println("选择排序1:"+ Arrays.toString(arr));}

4、插入排序

4.1、原理

        插入排序的思想非常简单，生活中有一个非常常见的场景：在打扑克牌时，我们一边抓牌一边给扑克牌排序，每次摸一张牌，就将它插入手上已有的牌中合适的位置，逐渐完成整个排序。

4.2、示例图

4.3、时间复杂度

        在插入排序中，当待排序数组是有序时，是最优的情况，只需当前数跟前一个数比较一下就可以了，这时一共需要比较N- 1次，时间复杂度为O(N)  

        最坏的情况是待排序数组是逆序的，此时需要比较次数最多，总次数记为：1+2+3+…+N-1，所以，插入排序最坏情况下的时间复杂度为0(N*N)

        平均来说，A[1..j-1]中的一半元素小于A[j]，一半元素大于A[j]。插入排序在平均情况运行时间与最坏情况运行时间一样，是输入规模的二次函数。

4.4、稳定性

        如果待排序的序列中存在两个或两个以上具有相同关键词的数据，排序后这些数据的相对次序保持不变，即它们的位置保持不变，通俗地讲，就是两个相同的数的相对顺序不会发生改变，则该算法是稳定的；如果排序后，数据的相对次序发生了变化，则该算法是不稳定的。关键词相同的数据元素将保持原有位置不变，所以该算法是稳定的。

4.5、示例

    private static void ArrSortC(int[] arr) {for (int i = 1; i < arr.length; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j--;}arr[j + 1] = key;}}

5、快速排序

        通过选择一个基准元素，将数组分成两部分，一部分小于基准元素，一部分大于基准元素，然后递归地对两部分进行排序。示例代码如下：

    private static void ArrSortK(int[] arr, int low, int high) {if (low < high) {int pivotIndex = partition(arr, low, high);ArrSortK(arr, low, pivotIndex - 1);ArrSortK(arr, pivotIndex + 1, high);}System.out.println("快速排序:"+Arrays.toString(arr));}private static int partition(int[] arr, int low, int high) {int pivot = arr[high];int i = low - 1;for (int j = low; j < high; j++) {if (arr[j] < pivot) {i++;int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}int temp = arr[i + 1];arr[i + 1] = arr[high];arr[high] = temp;return i + 1;}

6、归并排序

        通过将数组分成两部分，分别对两部分进行排序，然后将两个有序的部分合并成一个有序数组。示例代码如下：

   private static void ArrSortG(int[] arr, int low, int high) {if (low < high) {int mid = (low + high) / 2;ArrSortG(arr, low, mid);ArrSortG(arr, mid + 1, high);merge(arr, low, mid, high);}System.out.println("归并排序:"+Arrays.toString(arr));}private static void merge(int[] array, int low, int mid, int high) {int[] temp = new int[high - low + 1];int i = low;int j = mid + 1;int k = 0;while (i <= mid && j <= high) {if (array[i] <= array[j]) {temp[k++] = array[i++];} else {temp[k++] = array[j++];}}while (i <= mid) {temp[k++] = array[i++];}while (j <= high) {temp[k++] = array[j++];}for (int m = 0; m < temp.length; m++) {array[low + m] = temp[m];}}

 整体代码

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;public class TestArray2 {public static void main(String[] args) {int[] arr = {3, 2, 1, 5, 4};System.out.println("arr:"+Arrays.toString(arr));//输出方式//extracted(arr);//方法一：快速排序ArrSort1(arr);
//        ArrSort2(arr);
//        ArrSort3(arr);
//        ArrSort4(arr);
//        ArrSort5(arr);//方法二：冒泡方法
//        ArrSortM(arr);
//        ArrSortM1(arr);
//        ArrSortM2(arr);
//        ArrSortM3(arr);//方法三：选择排序
//        ArrSortX(arr);
//        ArrSortX1(arr);//方法四：插入排序
//        ArrSortC(arr);//方法五：快速排序
//        ArrSortK(arr,0,arr.length-1);//方法六：归并排序
//        ArrSortG(arr,0,arr.length-1);}private static void ArrSortG(int[] arr, int low, int high) {if (low < high) {int mid = (low + high) / 2;ArrSortG(arr, low, mid);ArrSortG(arr, mid + 1, high);merge(arr, low, mid, high);}System.out.println("归并排序:"+Arrays.toString(arr));}private static void merge(int[] array, int low, int mid, int high) {int[] temp = new int[high - low + 1];int i = low;int j = mid + 1;int k = 0;while (i <= mid && j <= high) {if (array[i] <= array[j]) {temp[k++] = array[i++];} else {temp[k++] = array[j++];}}while (i <= mid) {temp[k++] = array[i++];}while (j <= high) {temp[k++] = array[j++];}for (int m = 0; m < temp.length; m++) {array[low + m] = temp[m];}}private static void ArrSortK(int[] arr, int low, int high) {if (low < high) {int pivotIndex = partition(arr, low, high);ArrSortK(arr, low, pivotIndex - 1);ArrSortK(arr, pivotIndex + 1, high);}System.out.println("快速排序:"+Arrays.toString(arr));}private static int partition(int[] arr, int low, int high) {int pivot = arr[high];int i = low - 1;for (int j = low; j < high; j++) {if (arr[j] < pivot) {i++;int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}int temp = arr[i + 1];arr[i + 1] = arr[high];arr[high] = temp;return i + 1;}private static void ArrSortC(int[] arr) {for (int i = 1; i < arr.length; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j--;}arr[j + 1] = key;}}private static void ArrSortX(int[] arr) {for (int i = 0; i < arr.length - 1; i++) {int minIndex = i;for (int j = i + 1; j < arr.length; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}System.out.println("选择排序:"+ Arrays.toString(arr));}private static void ArrSortX1(int[] arr) {int minIndex, maxIndex;// i 只需要遍历一半for (int i = 0; i < arr.length / 2; i++) {minIndex = i;maxIndex = i;for (int j = i + 1; j < arr.length - i; j++) {if (arr[minIndex] > arr[j]) {// 记录最小值的下标minIndex = j;}if (arr[maxIndex] < arr[j]) {// 记录最大值的下标maxIndex = j;}}// 将最小元素交换至首位int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;// 如果最大值的下标刚好是 i，由于 arr[i] 和 arr[minIndex] 已经交换了，所以这里要更新 maxIndex 的值。if (maxIndex == i) maxIndex = minIndex;// 将最大元素交换至末尾int lastIndex = arr.length - 1 - i;temp = arr[lastIndex];arr[lastIndex] = arr[maxIndex];arr[maxIndex] = temp;}System.out.println("选择排序1:"+ Arrays.toString(arr));}private static void ArrSortM(int[] arr) {for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {// 升序：如果左边的数大于右边的数，则交换，保证右边的数字最大// 降序：如果左边的数小于右边的数，则交换，保证右边的数字最小if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}System.out.println("冒泡排序:"+Arrays.toString(arr));}private static void ArrSortM1(int[] arr) {// 初始时 swapped 为 true，否则排序过程无法启动boolean swapped = true;for (int i = 0; i < arr.length - 1; i++) {// 如果没有发生过交换，说明剩余部分已经有序，排序完成if (!swapped) break;// 设置 swapped 为 false，如果发生交换，则将其置为 trueswapped = false;for (int j = 0; j < arr.length - 1 - i; j++) {if (arr[j] > arr[j + 1]) {// 如果左边的数大于右边的数，则交换，保证右边的数字最大int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;// 表示发生了交换swapped = true;}}}System.out.println("冒泡排序1:"+Arrays.toString(arr));}private static void ArrSortM2(int[] arr) {for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {// 不添加参数的写法// 升序：如果左边的数大于右边的数，则交换，保证右边的数字最大// 降序：如果左边的数小于右边的数，则交换，保证右边的数字最小if (arr[j] > arr[j + 1]) {arr[j + 1] = arr[j + 1] + arr[j];arr[j] = arr[j + 1] - arr[j];arr[j + 1] = arr[j + 1] - arr[j];}}}System.out.println("冒泡排序2:"+Arrays.toString(arr));}private static void ArrSortM3(int[] arr) {boolean swapped = true;// 最后一个没有经过排序的元素的下标int indexOfLastUnsortedElement = arr.length - 1;// 上次发生交换的位置int swappedIndex = -1;while (swapped) {swapped = false;for (int i = 0; i < indexOfLastUnsortedElement; i++) {if (arr[i] > arr[i + 1]) {// 如果左边的数大于右边的数，则交换，保证右边的数字最大int temp = arr[i];arr[i] = arr[i + 1];arr[i + 1] = temp;// 表示发生了交换swapped = true;// 更新交换的位置swappedIndex = i;}}// 最后一个没有经过排序的元素的下标就是最后一次发生交换的位置indexOfLastUnsortedElement = swappedIndex;}System.out.println("冒泡排序3:"+Arrays.toString(arr));}private static void ArrSort1(int[] arr) {Arrays.sort(arr);System.out.println("快速排序-默认升序:"+Arrays.toString(arr));}private static void ArrSort2(int[] arr) {//数组类型不能是基本数据类型Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);Arrays.sort(arrayInteger, Collections.reverseOrder());System.out.println("快速排序-降序:"+Arrays.toString(arrayInteger));}private static void ArrSort3(int[] arr) {Arrays.sort(arr,1, 3);System.out.println("快速排序-区间排序:"+Arrays.toString(arr));}private static void ArrSort4(int[] arr) {Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);Arrays.sort(arrayInteger, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;}});System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));}private static void ArrSort5(int[] arr) {Integer[] arrayInteger = Arrays.stream(arr).boxed().toArray(Integer[]::new);//lambda表达式Arrays.sort(arrayInteger, (o1, o2) -> o2 - o1);System.out.println("快速排序-重载排序:"+Arrays.toString(arrayInteger));}private static void extracted(int[] arr) {System.out.println("原来的数组:"+ arr);//输出方式-forSystem.out.println("输出方式-for:");for (int i = 0; i < arr.length; i++) {System.out.println("for循环输出:"+ arr[i]);}System.out.println("======================");//输出方式-for eachSystem.out.println("输出方式-for each:");for (int i: arr){System.out.println("for each循环输出:"+i);}System.out.println("======================");//输出方式1-toStringSystem.out.println("输出方式-toString:");System.out.println("toString:"+Arrays.toString(arr));System.out.println("======================");}}

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

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

相关文章

【PyTorch】多项式回归

【PyTorch】多项式回归

文章目录 1. 模型与代码实现1.1. 模型1.2. 代码实现1.2.1. 完整代码1.2.2. 输出结果 2. Q&A2.1. 欠拟合与过拟合 1. 模型与代码实现 1.1. 模型 将多项式特征值预处理为线性模型的特征值。即 y w 0 w 1 x w 2 x 2 ⋯ w n x n y w_0w_1xw_2x^2\dotsw_nx^n yw0​w1​…
阅读更多...
开关电源超强总结

开关电源超强总结

什么是Power Supply? 开关电源的元件构成 三种基本的非隔离开关电源 三种基本的隔离开关电源 反激变换器&#xff08;Flyback&#xff09;工作原理 &#xff08;电流连续模式&#xff09; 反激变换器&#xff08;Flyback&#xff09;工作原理 &#xff08;电流断续模式&#x…
阅读更多...
信息化系列——企业信息化建设（3）

信息化系列——企业信息化建设（3）

期待已久的对策&#xff0c;马上”出炉“&#xff0c;第一次看的朋友&#xff0c;建议现在主页看看&#xff08;1&#xff09;和&#xff08;2&#xff09;&#xff0c;那咱们就废话少说了&#xff0c;开始今天的正题。 企业信息化建设对策 1、增强企业信息化意识 企业管理者…
阅读更多...
【Python】Python读Excel文件生成xml文件

【Python】Python读Excel文件生成xml文件

目录 ​前言 正文 1.Python基础学习 2.Python读取Excel表格 2.1安装xlrd模块 2.2使用介绍 2.2.1常用单元格中的数据类型 2.2.2 导入模块 2.2.3打开Excel文件读取数据 2.2.4常用函数 2.2.5代码测试 2.2.6 Python操作Excel官方网址 3.Python创建xml文件 3.1 xml语法…
阅读更多...
PACS源码，医学影像传输系统源码，全院级应用，支持放射、超声、内窥镜、病理等影像科室，且具备多种图像处理及三维重建功能

PACS源码，医学影像传输系统源码，全院级应用，支持放射、超声、内窥镜、病理等影像科室，且具备多种图像处理及三维重建功能

​三维智能PACS系统源码&#xff0c;医学影像采集传输系统源码 PACS系统以大型关系型数据库作为数据和图像的存储管理工具&#xff0c;以医疗影像的采集、传输、存储和诊断为核心&#xff0c;集影像采集传输与存储管理、影像诊断查询与报告管理、综合信息管理等综合应用于一体的…
阅读更多...
接口测试：轻松掌握基础知识，快速提升测试技能！

接口测试：轻松掌握基础知识，快速提升测试技能！

1.client端和server端 开始接口测试之前&#xff0c;首先搞清楚client端与server端是什么&#xff0c;区别。 web前端&#xff0c;顾名思义&#xff0c;指用户可以直观操作和看到的界面&#xff0c;包括web页面的结构&#xff0c;web的外观视觉表现及web层面的交互实…
阅读更多...
顶级设计师力荐的界面设计软件，设计新选择

顶级设计师力荐的界面设计软件，设计新选择

即时设计 作为专业的在线协作UI设计软件&#xff0c;即时设计可以实现视觉效果、交互效果、体验效果一站成型&#xff0c;为你的目标用户创造流畅体验。 轻松绘制原型&#xff1a;借助社区设计资源和原型模板的即时设计&#xff0c;开始敏捷高效的工作。与产品经理分解用户需…
阅读更多...
E. Good Triples

E. Good Triples

首先 如果产生进位的话是一定不对的&#xff0c;因为进位会给一个1&#xff0c;但是损失了10 然后可以按位直接考虑&#xff0c;转换成一个隔板法组合数问题 // Problem: E. Good Triples // Contest: Codeforces - Codeforces Round 913 (Div. 3) // URL: https://codeforces…
阅读更多...
反序列化漏洞详解(二)

反序列化漏洞详解(二)

目录 pop链前置知识&#xff0c;魔术方法触发规则 pop构造链解释&#xff08;开始烧脑了&#xff09; 字符串逃逸基础 字符减少 字符串逃逸基础 字符增加 实例获取flag 字符串增多逃逸 字符串减少逃逸 延续反序列化漏洞(一)的内容 pop链前置知识&#xff0c;魔术方法触…
阅读更多...
软件测试之python+requests接口自动化测试框架实例教程

软件测试之python+requests接口自动化测试框架实例教程

前段时间由于公司测试方向的转型&#xff0c;由原来的web页面功能测试转变成接口测试&#xff0c;之前大多都是手工进行&#xff0c;利用postman和jmeter进行的接口测试&#xff0c;后来&#xff0c;组内有人讲原先web自动化的测试框架移驾成接口的自动化框架&#xff0c;使用的…
阅读更多...
HTTPS安全防窃听、防冒充、防篡改三大机制原理

HTTPS安全防窃听、防冒充、防篡改三大机制原理

前言 本文内容主要对以下两篇文章内容整理过滤&#xff0c;用最直观的角度了解到HTTPS的保护机制&#xff0c;当然啦&#xff0c;如果想要深入了解HTTPS&#xff0c;本文是远远不够的&#xff0c;可以针对以下第一个链接中的文章拓展板块进行学习&#xff0c;希望大家通过本文能…
阅读更多...
WAT、CP、FT的概念及周边名词解释

WAT、CP、FT的概念及周边名词解释

CP是把坏的Die挑出来&#xff0c;可以减少封装和测试的成本。可以更直接的知道Wafer 的良率。 FT是把坏的chip挑出来&#xff1b;检验封装的良率。 现在对于一般的wafer工艺&#xff0c;很多公司多把CP给省了&#xff0c;减少成本。 CP对整片Wafer的每个Die来测试&#xff0…
阅读更多...
光伏系统方案设计的注意点

光伏系统方案设计的注意点

随着太阳能技术的日益发展&#xff0c;光伏系统已经成为一种重要的可再生能源解决方案。然而&#xff0c;设计一个高效、可靠的光伏系统需要考虑到许多因素。本文将探讨光伏系统方案设计的注意点&#xff0c;包括系统规模、地理位置、组件选择、系统布局和运维策略。 系统规模 …
阅读更多...
onnx检测推理

onnx检测推理

起因&#xff1a;当我想把检测的onnx模型转换到特定的设备可以使用的模型时&#xff0c;报错do not support dimension size > 4&#xff0c;onnx中有些数据的维度是五维&#xff0c;如图。本文使用的是edgeyolo&#xff0c;它使用的是yolox的head&#xff0c;最后的输出加上…
阅读更多...
gmid方法设计五管OTA二级远放

gmid方法设计五管OTA二级远放

首先给出第一级是OTA&#xff0c;第二级是CS的二级运放电路图&#xff1a; gmid的设计方法可以根据GBW、Av、CL来进行电路设计&#xff0c;因此在设计电路之前需要以上的参数要求。 1、为了满足电路的相位裕度至少60&#xff0c;需要对GBW、主极点、零点进行分析。 首先给出其…
阅读更多...
应用程序无法找到xinput1_3.dll怎么办，xinput1_3.dll 丢失的解决方法

应用程序无法找到xinput1_3.dll怎么办，xinput1_3.dll 丢失的解决方法

当电脑系统或特定应用程序无法找到或访问到 xinput1_3.dll 文件时&#xff0c;便会导致错误消息的出现&#xff0c;例如“找不到 xinput1_3.dll”、“xinput1_3.dll 丢失”等。这篇文章将大家讨论关于 xinput1_3.dll 文件的内容、xinput1_3.dll丢失问题的解决方法&#xff0c;以…
阅读更多...
查收查引（通过文献检索开具论文收录或引用的检索证明）

查收查引（通过文献检索开具论文收录或引用的检索证明）

开具论文收录证明的 专业术语为 查收查引&#xff0c;是高校图书馆、情报机构或信息服务机构提供的一项有偿服务。 因检索需要一定的时间&#xff0c;提交委托时请预留足够的检索时间。 一般需要提供&#xff1a;论文题目、作者、期刊名称、发表年代、卷期、页码。 目录 一、查…
阅读更多...
MIT6.5840-2023-Lab1: MapReduce

MIT6.5840-2023-Lab1: MapReduce

前置知识 MapReduce&#xff1a;Master 将一个 Map 任务或 Reduce 任务分配给一个空闲的 worker。 Map阶段&#xff1a;被分配了 map 任务的 worker 程序读取相关的输入数据片段&#xff0c;生成并输出中间 k/v 对&#xff0c;并缓存在内存中。 Reduce阶段&#xff1a;所有 ma…
阅读更多...
QT 中基于 TCP 的网络通信 （备查）

QT 中基于 TCP 的网络通信 （备查）

基础 基于 TCP 的套接字通信需要用到两个类&#xff1a; 1&#xff09;QTcpServer&#xff1a;服务器类&#xff0c;用于监听客户端连接以及和客户端建立连接。 2&#xff09;QTcpSocket&#xff1a;通信的套接字类&#xff0c;客户端、服务器端都需要使用。 这两个套接字通信类…
阅读更多...
《当代家庭教育》期刊论文投稿发表简介

《当代家庭教育》期刊论文投稿发表简介

《当代家庭教育》杂志是家庭的参谋和助手&#xff0c;社会的桥梁和纽带&#xff0c;人生的伴侣和知音&#xff0c;事业的良师益友。 国家新闻出版总署批准的正规省级教育类G4期刊&#xff0c;知网、维普期刊网收录。安排基础教育相关稿件&#xff0c;适用于评职称时的论文发表…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023