详解常见排序

news2024/11/23 23:50:59

目录

​编辑

插入排序

希尔排序(缩小增量排序)

选择排序

冒泡排序

堆排序

快速排序

hoare版

 挖坑法

前后指针法

非递归版

归并排序

递归版

非递归版

计数排序


声明:以下排序代码由Java实现!!!

插入排序

步骤:

1.我们可以认为数组的第一个元素已经被排好序,因此只需考虑对后面的元素进行插入排序;

2.取下一个位置的元素val,让它和它之前的元素进行比较,顺序为从右向左;

3.如果该元素大于val,则将该元素移动到该元素所处位置的下一个位置;

4.重复步骤3,知道找到已排好序的序列中小于等于val的元素;

5.将值val放到该位置的下一个位置,如果已排好序的所有元素的值都大于val,则将val存放到数组下标为0的位置;

6.重复2~5步骤。

动画演示:

代码如下:

public static void insertSort(int[] array){
    for(int i=1;i<array.length;i++){
        int tmp=array[i];
        int j=i-1;
        for(;j>=0;j--){
            if(array[j]>tmp)
                array[j+1]=array[j];
            else
                break;
        }
        array[j+1]=tmp;
    }
}
折半插入排序 

在该值为val的元素找合适的位置时,是在已排好序的序列中进行找的,因此该过程可以使用二分查找(折半查找)来进行优化。

代码如下:

public static void bsInsertSort(int[] array){
    for(int i=0;i<array.length;i++){
        int tmp=array[i];
        int left=0,right=i;
        while(left<right){
            int mid=(left+right)>>1;
            if(tmp>=array[mid])
                left=mid+1;
            else
                right=mid;
        }
        for(int j=i;j>left;j--)
            array[j]=array[j-1];
        array[left]=tmp;
    }
}

时间复杂度:最好情况下为O(N),此时待排数组为升序,或者说非常接近升序;

                     最坏情况下为O(N^N),此时待排数组为降序,或者说非常接近降序。

空间复杂度:O(1)

稳定性:稳定

希尔排序(缩小增量排序)

思想:

先选定一个小于N的整数gap作为第一增量,然后将所有距离为gap的元素划分在同一组,对每组的元素进行直接插入排序,然后再选取一个比第一增量小的整数作为第二增量gap,然后将所有距离为gap的元素划分在同一组,对每组的元素进行直接插入排序,以此类推.........,直到增量减小为1时,此时就相当于整个数组被划分为一组,进行一次直接插入排序即可。

增量gap大于1时,称为“预排序”,使得待排数组接近有序;增量gap为1时,称为直接插入排序。

动画演示

代码如下:

public static void shellSort(int[] array){
    int gap=array.length;
    while(gap>1){
        gap=gap/3+1;
        shell(array,gap);
    }
}

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

平均时间复杂度:O(N^1.3)

空间复杂度:O(1)

选择排序

每一次从待排序列中选出最小(或者最大)的一个元素,存放在待排序列的起始位置,同时将待排序列原来起始位置的值放到待排序列中最小元素的位置,直到待排数据全部排完序。

动画演示

代码如下:

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;
        swap(array,i,minIndex);
    }
}

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

实际上,我们可以每一趟同时选择出待排序列中的最小值和最大值,然后将最小值放待排序列起始位置,将最大值放到待排序列的末尾,直到待排数据全部排完序,这样的话比前一种方法快一倍。

代码如下:

public static void DoubleSelectSort(int[] array){
    int left=0,right=array.length-1;
    while(left<right){
        int minIndex=left,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);
        if(maxIndex==left)
            maxIndex=minIndex;
        swap(array,right,maxIndex);
        left++;
        right--;
    }
}

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

时间复杂度:O(N^2)

空间复杂度:O(1)

冒泡排序

进行N趟,每一趟中,如果前一个位置的元素大于后一个位置的元素,则交换两个位置的元素。

动画演示

代码如下:

public static void bubbleSort(int[] array){
    for(int i=0;i<array.length;i++){
        boolean flag=false;
        for(int j=0;j<array.length-1-i;j++){
            if(array[j]>array[j+1]) {
                swap(array, j, j + 1);
                flag=true;
            }
        }
        if(!flag)
            break;
    }
}

时间复杂度:O(N^2)

空间复杂度:O(1)

堆排序

排升序建大根堆,排降序建小根堆。

以排升序为例,先对数组建立大根堆,然后将堆顶元素和堆最后一个元素交换,然后从堆顶进行向下调整,不过此时堆的大小要 -1,因为已经把最大的元素找出来并放在数组的末尾了,不断重复上述操作,直到将整个数组的元素排完序。

动画演示:

代码如下:

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--;
    }
}

private static void createBigHeap(int[] array){
    for(int parent=array.length-1-1;parent>=0;parent--)
        shiftDown(array,parent,array.length);
}

private static void shiftDown(int[] array,int parent,int end){
    int child=2*parent+1;
    while(child<end){
        if(child+1<end && array[child+1]>array[child])
            child++;
        if(array[parent]<array[child]){
            swap(array,parent,child);
            parent=child;
            child=2*parent+1;
        }
        else
            break;
    }
}

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

时间复杂度:O(N*logN)

空间复杂度:O(1)

快速排序
hoare版

步骤:

1.选定一个值Key,下标记为Keyi,通常是最左边的元素或者最右边的元素;

2.定义两个指针begin和end,being从左往右走,end从右往左走;

3.若选定的Key值是最左边的元素,需要end先走,若选定的Key值是最右边的元素,需要begin先走;

4.在走的过程中,当end遇到小于Key的数,才停下;然后begin开始走,直到遇到大于Key的数,然后交换位于begin和end位置的值,然后end再走,规则如上,直到begin和end相遇,此时再将位于Keyi位置的Key值和begin和end相遇点的值进行交换;

5.此时,Key左边的值都是小于等于Key的数,Key右边的值都是大于等于Key的数;

6.然后再对Key左边的数以及Key右边的数分别进行如上操作,直到待排序列只有一个元素为止。

动画演示:

代码如下: 

因为该方法包含大量的递归,当数据量较大时会发生栈溢出,因此做一些优化,包括【三数取中】和【当待排区间长度小于某个常数时,不再递归进行快排,而是使用直接插入排序】

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;
    if(end-start<=7){
        insertSortRange(array,start,end);
        return;
    }
    int pivot=partitionHoare(array,start,end);
    quick(array,start,pivot-1);
    quick(array,pivot+1,end);
}

private static void insertSortRange(int[] array,int begin,int end) {
    for (int i = begin+1; i <= end; i++) {
        int tmp = array[i];
        int j = i-1;
        for (; j >= begin ; j--) {
            if(array[j] > tmp) {
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}

private static int midOfThree(int[] array, int left, int right) {
    int mid = (left+right) / 2;
    if(array[left] < array[right]) {
        if(array[mid] < array[left]) {
            return left;
        }else if(array[mid] > array[right]) {
            return right;
        }else {
            return mid;
        }
    }else {
        if(array[mid] > array[left]) {
            return left;
        }else if(array[mid] < array[right]) {
            return right;
        }else {
            return mid;
        }
    }
}

private static int partitionHoare(int[] array,int left,int right){
    int key=array[left];
    int keyi=left;
    while(left<right){
        while(left<right && array[right]>=key)
            right--;
        while(left<right && array[left]<=key)
            left++;
        swap(array,left,right);
    }
    swap(array,keyi,left);
    return left;
}

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

时间复杂度:O(N*logN)

空间复杂度:O(1) 

 挖坑法

步骤:

1.选定一个Key值,通常是位于最左边或者是最右边,在该位置形成一个坑;

2.定义两个指针left和right,left从左向右走,right从左向左走;

3.如果Key值位于数组最左边,需要right先走;如果Key值位于数组组右边,需要left先走;

4.在走的过程中,当end遇到小于Key的数,才停下,然后将right位置的值填放到坑位置,此时right位置处形成一个坑;然后begin开始走,直到遇到大于Key的数,然后将left位置的值填放到坑位置,此时left位置处形成一个坑;然后right再走,规则如上,直到left和right相遇,此时再将位于Key值填放到坑位置处;

5.此时,Key左边的值都是小于等于Key的数,Key右边的值都是大于等于Key的数;

6.然后再对Key左边的数以及Key右边的数分别进行如上操作,直到待排序列只有一个元素为止。

动画演示:

代码如下: 

因为该方法包含大量的递归,当数据量较大时会发生栈溢出,因此做一些优化,包括【三数取中】和【当待排区间长度小于某个常数时,不再递归进行快排,而是使用直接插入排序】

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;
    if(end-start<=7){
        insertSortRange(array,start,end);
        return;
    }
    int pivot=partitionHole(array,start,end);
    quick(array,start,pivot-1);
    quick(array,pivot+1,end);
}

private static void insertSortRange(int[] array,int begin,int end) {
    for (int i = begin+1; i <= end; i++) {
        int tmp = array[i];
        int j = i-1;
        for (; j >= begin ; j--) {
            if(array[j] > tmp) {
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}

private static int midOfThree(int[] array, int left, int right) {
    int mid = (left+right) / 2;
    if(array[left] < array[right]) {
        if(array[mid] < array[left]) {
            return left;
        }else if(array[mid] > array[right]) {
            return right;
        }else {
            return mid;
        }
    }else {
        if(array[mid] > array[left]) {
            return left;
        }else if(array[mid] < array[right]) {
            return right;
        }else {
            return mid;
        }
    }
}


private static int partitionHole(int[] array,int left,int right){
    int key=array[left];
    while(left<right){
        while(left<right && array[right]>=key)
            right--;
        array[left]=array[right];
        while(left<right && array[left]<=key)
            left++;
        array[right]=array[left];
    }
    array[left]=key;
    return left;
}

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

时间复杂度:O(N*logN)

空间复杂度:O(1) 

前后指针法

步骤:

1.选定数组最左边的值为基准值;

2.定义两个指针prev和cur,开始时prev在最左边,cur在prev的下一个位置;

3.让cur向右走,如果cur位置的值大于基准值,只需cur继续向右移动,直到遇到比基准值小的值;

4.如果cur位置的值小于基准值,先让prev向右移动一个位置,然后交换prev位置的值和cur位置的值,直到cur走到数组末尾。

代码如下:

因为该方法包含大量的递归,当数据量较大时会发生栈溢出,因此做一些优化,包括【三数取中】和【当待排区间长度小于某个常数时,不再递归进行快排,而是使用直接插入排序】

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;
    if(end-start<=7){
        insertSortRange(array,start,end);
        return;
    }
    int pivot=partitionDouble(array,start,end);
    quick(array,start,pivot-1);
    quick(array,pivot+1,end);
}

private static void insertSortRange(int[] array,int begin,int end) {
    for (int i = begin+1; i <= end; i++) {
        int tmp = array[i];
        int j = i-1;
        for (; j >= begin ; j--) {
            if(array[j] > tmp) {
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}

private static int midOfThree(int[] array, int left, int right) {
    int mid = (left+right) / 2;
    if(array[left] < array[right]) {
        if(array[mid] < array[left]) {
            return left;
        }else if(array[mid] > array[right]) {
            return right;
        }else {
            return mid;
        }
    }else {
        if(array[mid] > array[left]) {
            return left;
        }else if(array[mid] < array[right]) {
            return right;
        }else {
            return mid;
        }
    }
}


private static int partitionDouble(int[] array,int left,int right){
    int prev=left,cur=prev+1;
    while(cur<array.length){
        if(array[cur]<array[left] && array[++prev]!=array[cur])
            swap(array,prev,cur);
        cur++;
    }
    swap(array,prev,left);
    return prev;
}

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

时间复杂度:O(N*logN)

空间复杂度:O(1) 

非递归版

代码如下:

public static void quickSortNor(int[] array) {
    Stack<Integer> stack = new Stack<>();
    int left = 0;
    int right = array.length-1;
    int piovt = partitionHole(array,left,right);
    if(piovt - 1 > left) {
        stack.push(left);
        stack.push(piovt-1);
    }
    if(piovt + 1 < right) {
        stack.push(piovt+1);
        stack.push(right);
    }
    while (!stack.isEmpty()) {
        right = stack.pop();
        left = stack.pop();
        piovt = partitionHole(array,left,right);
        if(piovt - 1 > left) {
            stack.push(left);
            stack.push(piovt-1);
        }
        if(piovt + 1 < right) {
            stack.push(piovt+1);
            stack.push(right);
        }
    }
}
归并排序
递归版

使用递归不断将区间二分,直到区间只有一个元素为止,然后将两个区间进行排序合并,直到将所有区间合并完。

代码如下:

public static void mergeSort(int[] array){
    int[] dst=new int[array.length];
    dst= Arrays.copyOf(array,array.length);
    merge(array,dst,0,array.length-1);
    for(int i=0;i<array.length;i++)
        array[i]=dst[i];
}

private static void merge(int[] src,int[] dst,int start,int end){
    if(start>=end) return;
    int mid=(start+end)>>1;
    merge(dst,src,start,mid);
    merge(dst,src,mid+1,end);

    int i=start,j=mid+1,k=start;
    while(i<=mid || j<=end){
        if(j>end || (i<=mid && src[i]<src[j]))
            dst[k++]=src[i++];
        else
            dst[k++]=src[j++];
    }
}

时间复杂度:O(N*logN)

空间复杂度:O(N) 

非递归版

将整个区间划分为长度为1,2,4,8,..........最大为N的小区间,然后对相邻的长度为1,2,4,8,..........最大为N的小区间分别进行排序合并,最终就排好序了。

代码如下:

public static void mergeSortNor(int[] array){
    int[] src=array;
    int[] dst=new int[array.length];
    for(int step=1;step<array.length;step+=step){
        for(int start=0;start<array.length;start+=step*2){
            int mid=Math.min(start+step-1,array.length-1);
            int end=Math.min(start+2*step-1,array.length-1);
            int i=start,j=mid+1,k=start;
            while(i<=mid || j<=end){
                if(j>end || (i<=mid && src[i]<src[j]))
                    dst[k++]=src[i++];
                else
                    dst[k++]=src[j++];
            }
        }
        int[] tmp=src;
        src=dst;
        dst=tmp;
    }
    for(int i=0;i<array.length;i++)
        array[i]=src[i];
}

时间复杂度:O(N*logN)

空间复杂度:O(N) 

计数排序

先求出序列中的最大值maxVal和最小值minVal,然后开辟一个长度为maxVal-minVal+1的数组,值全都初始化为0,然后遍历整个数组,将下标为每个位置的值减去minVal处的值++,然后再重复将每个位置的值表示的次数次,将对应的值【下标+minVal】存放到原数组中。

动画演示:

代码如下: 

public static void countSort(int[] array) {
    int minVal = array[0];
    int maxVal = array[0];
    for (int i = 1; i < array.length; i++) {
        if(array[i] < minVal) {
            minVal = array[i];
        }
        if(array[i] > maxVal) {
            maxVal = array[i];
        }
    }
    int[] count = new int[maxVal-minVal+1];
    
    for (int i = 0; i < array.length; i++) {
        count[array[i]-minVal]++;
    }
    
    int index = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i] > 0) {
            array[index] = i+minVal;
            index++;
            count[i]--;
        }
    }
}

时间复杂度:O(N)

空间复杂度:O(N) 

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

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

相关文章

【研赛D题成品论文】24华为杯数学建模研赛D题成品论文(第一问)+可运行代码丨免费分享

2024华为杯研究生数学建模竞赛D题精品成品论文已出&#xff01; D题 大数据驱动的地理综合问题 一、问题分析 问题一&#xff1a;目标&#xff1a;利用1990-2020年的数据&#xff0c;针对降水量和土地利用的时空演化特征进行描述。数据&#xff1a;两个核心变量&#xff0c;一…

电商效果图渲染神器:轻松高效出图

在这个电商行业飞速发展的今天&#xff0c;离不开商品图的效果。而电商效果图同样离不开渲染&#xff0c;而大量的渲染需求有需要大量的机器&#xff0c;还要追求更快的渲染速度和更稳定的性能。毕竟&#xff0c;谁不想快点完成项目又省心呢&#xff1f; 而云渲染服务是个很好…

C++之STL—deque容器

双端数组 区别于 vector (单端数组)&#xff0c; 构造函数 注意&#xff1a;读取数据时&#xff0c;const修饰保证函数内只能读取&#xff0c;不能修改数据 void print(const deque<int>& deq) {for (deque<int>::const iterator it deq.begin(); it ! deq.e…

使用 Nuxt Kit 的构建器 API 来扩展配置

title: 使用 Nuxt Kit 的构建器 API 来扩展配置 date: 2024/9/24 updated: 2024/9/24 author: cmdragon excerpt: 摘要:本文详细介绍了如何使用 Nuxt Kit 的构建器 API 来扩展和定制 Nuxt 3 项目的 webpack 和 Vite 构建配置,包括扩展Webpack和Vite配置、添加自定义插件、…

正向科技|格雷母线定位系统的设备接线安装示范

格雷母线安装规范又来了&#xff0c;这次是设备接线步骤 格雷母线是格雷母线定位系统的核心部件&#xff0c;沿着移动机车轨道方向上铺设&#xff0c;格雷母线以相互靠近的扁平状电缆与天线箱电磁偶合来进行信号传递&#xff0c;从而检测得到天线箱在格雷母线长度方向上的位置。…

OpenLayers 开源的Web GIS引擎 - 添加地图控件地图控件

中心点按钮、地图放大缩小滑块、全图和比例尺控件 直接上代码&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.…

python爬虫案例——腾讯网新闻标题(异步加载网站数据抓取,post请求)(6)

文章目录 前言1、任务目标2、抓取流程2.1 分析网页2.2 编写代码2.3 思路分析前言 本篇案例主要讲解异步加载网站如何分析网页接口,以及如何观察post请求URL的参数,网站数据并不难抓取,主要是将要抓取的数据接口分析清楚,才能根据需求编写想要的代码。 1、任务目标 目标网…

基于深度学习的树叶识别系统的设计与实现(pyqt5 python3.9 yolov8 10000张数据集)

&#x1f497;博主介绍&#x1f497;&#xff1a;✌在职Java研发工程师、专注于程序设计、源码分享、技术交流、专注于Java技术领域和毕业设计✌ 温馨提示&#xff1a;文末有 CSDN 平台官方提供的老师 Wechat / QQ 名片 :) Java精品实战案例《700套》 2025最新毕业设计选题推荐…

vector的模拟实现以及oj题

前言 上篇博客介绍了voctor的大部分的重要接口&#xff0c;本篇博客将模拟实现部分接口的效果。 vector的模拟实现 vector的模拟实现分为两个文件进行实现&#xff1a;vector.h、test.cpp vector.h 该部分为文件的主要部分&#xff0c;分别实现了vector的以下功能&#xf…

VSCode扩展连接虚拟机MySQL数据库

在虚拟机安装MySQL vscode通过ssh远程登录Ubuntu 在vscode终端运行以下命令。 sudo apt-get install mysql-server-5.7 用以下命令确认MySQL是否安装完成。 sudo mysql MySQL安装成功。 在VSCode安装SQL扩展 扩展名&#xff1a;MySQL Shell for VS Code。 安装完成后&am…

oracle各种版本在各种系统上安装配置需求快速参考

Oracle Database (RDBMS) on Unix AIX,HP-UX,Linux,Solaris and MS Windows Operating Systems Installation and Configuration Requirements Quick Reference (12.1/12.2/18c/19c) (Doc ID 1587357.1)

(14)关于docker如何通过防火墙做策略限制

关于docker如何通过防火墙做策略限制 1、iptables相关问题 在Iptables防火墙中包含四种常见的表&#xff0c;分别是filter、nat、mangle、raw。 filter&#xff1a;负责过滤数据包。 filter表可以管理INPUT、OUTPUT、FORWARD链。 nat&#xff1a;用于网络地址转换。 nat表…

边缘计算网关在工业中的应用

在工业4.0和智能制造的浪潮中&#xff0c;边缘计算网关扮演着至关重要的角色。AIoTedge边缘计算网关&#xff0c;作为工业互联网的关键组件&#xff0c;通过其强大的数据处理能力和智能分析功能&#xff0c;正在改变工业生产的面貌。 边缘计算网关的定义与角色 边缘计算网关是…

apache paimon简介(官翻)

介绍 如下架构所示: 读/写操作: Paimon 支持多样化的数据读写方式,并支持 OLAP 查询。 读取: 支持从历史快照(批处理模式)中消费数据,从最新偏移量(流处理模式)中读取数据,或以混合方式读取增量快照。写入: 支持从数据库变更日志(CDC)进行流式同步,从离线数据中…

sicp每日一题[2.24-2.27]

2.24-2.26没什么代码量&#xff0c;所以跟 2.27 一起发吧。 Exercise 2.24 Suppose we evaluate the expression (list 1 (list 2 (list 3 4))). Give the result printed by the interpreter, the corresponding box-and-pointer structure, and the interpretation of this a…

Vue3:自定义customRef

目录 一.性质 1.自定义性 2.工厂函数参数 3.track 和 trigger 函数 二.作用 1.防抖/节流 2.异步更新 3.条件性更新 4.精细控制依赖追踪 5.优化性能 三.使用 1.ts组件 2.vue.组件 四.代码 1.ts代码 2.vue代码 五.效果 在 Vue 3 中&#xff0c;customRef 是一个…

YOLOv10改进,YOLOv10主干网络替换为VanillaNet( CVPR 2023 华为提出的全新轻量化架构),大幅度涨点

摘要 基础模型的核心理念是“更多即不同”,这一理念在计算机视觉和自然语言处理领域取得了惊人的成功。然而,变压器模型的优化挑战和固有复杂性呼唤一种向简化转变的范式。在本研究中,引入了 VanillaNet,一种拥抱设计优雅的神经网络架构。通过避免高深度、快捷方式和复杂操…

java开发jmeter采样器

目录 1.前言 2.新建一个springboot工程 2.1 引入相关依赖 2.2 编写核心代码 2.2.1 取样器代码 2.2.2 取样器界面 2.2.3 sdk接口封装 3.源码打包 3.1 将sdk源码和采样器源码打成jar包 3.2 拷贝引用包 4.配置jmeter脚本 4.1 选择自定义采样器 4.2 界面里面配置参数 1.…

“一屏显江山”,激光显示重构「屏中世界」

【潮汐商业评论/原创】 2024年国庆期间&#xff0c;曾感动过无数国人的舞蹈诗剧《只此青绿》改编的同名电影即将上映&#xff0c;而这一次观众们不必走进电影院&#xff0c;在家里打开官方合作的海信激光电视也能享受到同等的视听效果&#xff0c;这是激光电视在观影场景领域的…

【卡片 / A】

题目 代码 #include <bits/stdc.h> using namespace std; int cnt[10]; bool consume(int x) {int need[10] {0};while (x){int k x % 10;need[k];x / 10;}for (int i 0; i < 10; i){if (cnt[i] < need[i])return false;}for (int i 0; i < 10; i){cnt[i] …