精华内容
下载资源
问答
  • 年的排序
    千次阅读
    2020-08-03 19:32:38

    js 年月日排序

    假定有一组这样的数据,需要根据 creatTime 排序

    let ary = [
        { name: 'k1', creatTime: '20218-8-8'},
        { name: 'k2', creatTime: '2019-7-9'},
        { name: 'k3', creatTime: '2018-10-1'},
        { name: 'k4', creatTime: '2020-8-3'}
    ]
    

    准备一个排序函数:

    function sort(a, b){
        return new Date(a.creatTime).getTime() - new Date(b.creatTime).getTime()
    }
    

    然后调用这个排序函数:

    ary.sort(sort)
    // 因为sort函数是比较的字符串,如果想要比较数字的大小,就要通过函数来实现
    
    更多相关内容
  • 2019年排序法概念.pdf

    2021-12-21 12:33:03
    2019年排序法概念.pdf
  • 国家统计局2019最新的省市区地区数据mysql 带字母排序排序 422 阿尔山市 152202000000 420 3 A 460 鞍山市 210300000000 446 2 A 789 安达市 231281000000 780 3 A 989 安庆市 340800000000 922 2 A 1375 ...
  • 【解析版】2021中考试题:句子的排序
  • 针对模糊互补矩阵,讨论了模糊一致矩阵的一些性质,给出了模糊互补矩阵排序向量的一种求解算法。
  • 连通图的排序 (2009)

    2021-04-27 07:43:33
    利用图的移接变换与谱半径大小的关系,研究了树及其合成图的排序(按其谱半径从大到小)问题。首先,依据树的直径对n阶树的集合进行了分类,得到了树的一个排序。其次,研究了连通图与树的合成图的分类与排序问题,得到了一...
  • Hoare在1962提出。快速排序是对冒泡排序的一种改进,采用了一种分治的策略。 2. 基本思想 通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法...
  • 根据藏文文字结构特点和相关语法规则,以及藏文音节的排序与汉文、英文字符的排序相比相对复杂的特征,提出了一种识别藏文音节基本辅音字母的算法,从而将二维的藏文音节展成一维的藏文字母串,实现了藏文音节的正确排序...
  • 快速排序是C.R.A.Hoare于1962提出的一种划分交换排序。它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod)。 1.分治法的基本思想 分治法的基本思想是:将原问题分解为若干个规模更小但结构与原...
  • c++归并排序详解

    2021-01-20 06:33:11
    1945由约翰·冯·诺伊曼首次提出。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用,且各层分治递归可以同时进行。 归并排序的核心思想是将两个有序的数列合并成一个大的有序的序列。通过递归,...
  • 为了更直接地定义点对间的序关系,引入了排序问题的范数学习模型。该模型利用样本空间中的范数类描述样本间的不同序关系。借鉴范数学习的思想,得到了有效处理此类排序学习问题的贪婪学习算法。实验结果表明,此类算法...
  • 中文核心期刊评价排序表2019
  • 使用标签进行推荐时,需要将其排序,而现有标签云中的标签排序都是按标签被标记次数或字典顺序进行降序排列的,这些排列方式未考虑用户个性化的需求和标签的时效性。提出了一种个性化标签云中的标签排序算法,通过用户...
  • 算法设计与分析基础 实验报告 应用数学学院 二零一六六月 实验一 插入排序算法 一实验性质 设计 二实验学时 14学时 三实验目的 1掌握插入排序的方法和原理 2掌握java语言实现该算法的一般流程 四实验内容 1数组的...
  • 快速排序是冒泡排序经改进之后的一种新的排序方法。拥有速度快,原地排序等特点,本文主要探讨了对原始的快速排序的一些改进的想法,提高其效率。
  • C语言奇偶排序算法 奇偶排序,或奇偶换位排序,或砖排序,是一种相对简单的排序算法,最初发明用于有本地互连的并行计算。这是与冒泡排序特点类似的一种比较排序。...该算法由Habermann在1972最初发表并展现了在并行
  • 提出了一种改进的行和归一化排序方法(INRAM),从保序性、置换不变性、相容性和累积优势度等方面对该方法的合理性进行了研究,并且利用互补判断矩阵和互反判断矩阵之间的转换公式,给出了相应的求解互补判断矩阵...
  • 为探索具有最优渐近时间复杂度的步长序列及其选择方法,以不同步长序列对一些规模较大的待排序列进行试验,研究了Shell排序的时间复杂度与步长序列的关系。
  • 基数排序的发明可以追溯到1887赫尔曼·何乐礼在打孔卡片制表机(Tabulation Machine)上的贡献。它是这样实现的: 将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零. 然后, 从最低位开始, 依次...
  • 讨论了终端区飞机动态排序问题,并利用进化算法建立了终端区航班排序的数学模型。根据飞机尾流间隔要求,利用生物进化理论,找到更合理的航班着陆队列,减小了航班的总延误成本。仿真结果表明,航班总延误成本的优化...
  • 教育资料
  • 网络可靠度二元决策图(BDD)分析过程包含边排序、BDD生成和可靠度评估3个步骤,其中BDD生成和可靠度评估的计算复杂度和BDD尺度线性相关,而BDD尺度取决于边排序.因此,边排序问题是研究网络可靠度BDD分析的核心.在...
  • 近两跟踪速度较快的算法,排序算法数据结构 最快的排序算法
  • 由于群体决策的相对熵模型和特征根法模型给出的是一个完全确定的方案排序结果,没有定量描述最终结果的不确定性,对同一个方案进行决策时可能会产生冲突;文章利用判断矩阵的信息求得专家权重,提出了可以定量描述不...
  • 针对零部件供应不能实现JIT的混流装配线排序问题,提出在SPS物料配送模式下,以提高零部件配送质量为目的,分析拣选环节筐车排列顺序对零件拣选错配和漏配的影响,从两方面探讨通过安排筐车排列顺序以最小化拣选错配和漏...
  • 分析了炮兵遂行火力任务的客观实际,通过引入灰色关联分析法,阐述了对炮兵火力打击目标的排序问题。
  • 基数排序的发明可以追溯到1887赫尔曼·何乐礼在打孔卡片制表机(Tabulation Machine)上的贡献。 原理:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次...
  • 八大排序算法 一、直接插入 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 二、希尔排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 三、简单选择 - 1.基本思路 - 2.代码实现 - 3.时间复杂度...

    八大排序算法

    一、直接插入

    1.基本思路

    在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。

    2.代码实现

    • 1.遍历数组,每次循环从第二个数字往前插入
    • 2.设定插入数和得到已经排好序列的最后一个数的位数。temp和j=i-1。
    • 3.从最后一个数开始向前循环,如果插入数小于当前数,就将当前数向后移动一位。
    public static void insertSort(int[] data) {
        int temp;
        for(int i = 1;i < data.length; i++){// 取第i个数,插入前边的有序的序列
            temp = data[i];
            int j;
            for(j = i - 1; j>=0; j--) {// 从第i-1的位置上开始比较
                if(data[j] > temp) {// 若前面的数大,则往后挪一位
                    data[j+1] = data[j];
                } else {
                    break;// 否则,说明要插入的数比较大
                }
            }
            data[j+1] = temp;// 找到这个位置,插入数据
        }
    }
    

    3.时间复杂度和空间复杂度

    直接插入排序的平均复杂度为O(n²),最坏时间复杂度:O(n²),空间复杂度:O(1),没有分配内存。

    二、希尔排序

    针对直接插入排序下的效率问题,有人对此进行了改进与升级,这就是现在的希尔排序。希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

    1.基本思路

    • 1.数的个数为length,i=length/2,将下标差值为i的数分为一组,构成有序序列。

    • 2.再取i=i/2 ,将下标差值为i的数分为一组,构成有序序列。

    • 3.重复第二步,直到k=1执行简单插入排序。

    思路:

    • 1.希尔排序(shell sort)这个排序方法又称为缩小增量排序,是1959年D·L·Shell提出来的。该方法的基本思想是:设待排序元素序列有n个元素,首先取一个整数increment(小于n)作为间隔将全部元素分为increment个子序列,所有距离为increment的元素放在同一个子序列中,在每一个子序列中分别实行直接插入排序。然后缩小间隔increment,重复上述子序列划分和排序工作。直到最后取increment=1,将所有元素放在同一个子序列中排序为止。
    • 2.由于开始时,increment的取值较大,每个子序列中的元素较少,排序速度较快,到排序后期increment取值逐渐变小,子序列中元素个数逐渐增多,但由于前面工作的基础,大多数元素已经基本有序,所以排序速度仍然很快。

    希尔排序举例:
    在这里插入图片描述

    2.代码实现

    • 1.遍历数组,每次循环从第二个数字往前插入
    • 2.设定插入数和得到已经排好序列的最后一个数的位数。temp和j=i-1。
    • 3.从最后一个数开始向前循环,如果插入数小于当前数,就将当前数向后移动一位。

    (1)首先确定每一组序列的下标的间隔,循环每次需要的间隔:int i = length/2; i >0 ; i /= 2

    (2)然后将每一组序列中元素进行插入排序,第二组第一个插入的数字是第一组第一个插入数字之后的那个数组,从i之后每个数字都要进行插入排序,就是插入的序列是各自不同的序列,不是一个一个子序列循环,而是在一个循环中for (int j=i;j<length;j++)完成所有子序列的插入排序。

    (3)直到i=0为止。

    public static void shellSort(int[] array) {
        int length = array.length;
        for (int i = length / 2; i > 0; i /= 2) {//序列的间隔,一直到间隔为一,这时候就只有一个子序列
            for (int j = i; j < length; j++) {//从i之后每个数字都要进行插入排序,就是插入的序列是各自不同的序列
                int temp = array[j];//里面就是直接插入算法
                int k;
                for (k = j - i; k >= 0; k -= i) {//实现各个数字插入排序到不同的序列中,直到间隔为1的时候,只有一个序列,就是完全的一个直接插入排序
                    if (temp < array[k]) {
                        array[k + i] = array[k];
                    } else {
                        break;
                    }
                }
                array[k + i] = temp;//把数字插入到位置上
            }
        }
        System.out.println(Arrays.toString(array));
    }
    

    3.时间复杂度和空间复杂度

    希尔排序的平均时间复杂度为O(n²),空间复杂度O(1) 。

    三、简单选择

    1.基本思路

    基本原理如下:对于给定的一组记录,经过第一轮比较后得到最小的记录,然后将该记录的位置与第一个记录的位置交换;接着对不包括第一个记录以外的其他记录进行第二次比较,得到最小记录并与第二个位置记录交换;重复该过程,直到进行比较的记录只剩下一个为止。

    2.代码实现

    • 1.确定要插入最小值的位置,从0开始到最后int i = 0; i <len ; i++
    • 2.将每次开始位置上的数字暂定为最小值min,从开始数字之后一个个和min比较,再把最小值存放到min
    • 3.将最小值所在位置上的数字和开始位置上的数字交换
    public static void selectSort(int[] array) {
        int len = array.length;
        for (int i = 0; i < len; i++) {//确定每次开始的位置
            int min = array[i];//设定开始数字为最小的值最小值
            int flag = i;
            for (int j = i + 1; j < len; j++) {//把最小值存放到min,从开始数字向后一个个和min比较,再把最小值存放到min
                if (min > array[j]) {
                    min = array[j];
                    flag = j;
                }
            }
            if (flag != i) {
                array[flag] = array[i];
                array[i] = min;
            }
        }
        System.out.println(Arrays.toString(array));
    }
    

    3.时间复杂度和空间复杂度

    简单选择排序的时间复杂度为O(n²)

    四、堆排序

    1.基本思路

    • 1.若array[0,…,n-1]表示一颗完全二叉树的顺序存储模式,则双亲节点指针和孩子结点指针之间的内在关系如下:
    任意一节点指针 i:
    父节点:i==0 ? null : (i-1)/2
    左孩子:2*i + 1
    右孩子:2*i + 2
    
    • 2.堆得定义
    n个关键字序列array[0,...,n-1],当且仅当满足下列要求:(0 <= i <= (n-1)/2)
    ① array[i] <= array[2*i + 1] 且 array[i] <= array[2*i + 2]; 称为小根堆;
    ② array[i] >= array[2*i + 1] 且 array[i] >= array[2*i + 2]; 称为大根堆;
    
    • 3.建立大顶堆

    n个节点的完全二叉树array[0,…,n-1],最后一个节点n-1是第(n-1-1)/2个节点的孩子。对第(n-1-1)/2个节点为根的子树调整,使该子树称为堆。

    对于大根堆,调整方法为:若【根节点的关键字】小于【左右子女中关键字较大者】,则交换。

    之后向前依次对各节点((n-2)/2 - 1)~ 0为根的子树进行调整,看该节点值是否大于其左右子节点的值,若不是,将左右子节点中较大值与之交换,交换后可能会破坏下一级堆,于是继续采用上述方法构建下一级的堆,直到以该节点为根的子树构成堆为止。

    反复利用上述调整堆的方法建堆,直到根节点。

    • 4.堆排序(大顶堆)
    ①将存放在array[0,...,n-1]中的n个元素建成初始堆;
    ②将堆顶元素与堆底元素进行交换,则序列的最大值即已放到正确的位置;
    ③将数组中array[0,...,n-1]前n-1个元素再次形成大根堆,再重复第②③步,直到堆中仅剩下一个元素为止。
    

    2.代码实现

    
    /**
        *  大顶堆排序
        * @param array
        */
    public static void maxHeapSort(int[] array) {
        int i;
        int len = array.length;
        // 构建大顶堆
        for (i = len / 2 - 1; i >= 0; i--) {
            adjustMaxHeap(array, i, len);
        }
        // 堆顶是最大值,交换堆顶和最后一个数,再重新调整最大堆,下一次循环   i--
        for (i = len - 1; i >= 0; i--) {
            int temp = array[0];
            array[0] = array[i];
            array[i] = temp;
            adjustMaxHeap(array, 0, i);
        }
        System.out.println(Arrays.toString(array));
    }
    
    private static void adjustMaxHeap(int[] a, int pos, int len) {
        int temp;
        int child;
        for (temp = a[pos]; 2 * pos + 1 < len; pos = child) {
            // 数组从0开始,r(i)>=r(2i) r(i)>=r(2i+1)  对应 pos => 2 * pos + 1 和 2 * pos +2
            child = 2 * pos + 1;
            // 有右孩子,且右孩子数值更大
            if (child + 1 < len && a[child] < a[child + 1]) {
                child++;
            }
            // 最大的孩子大于根节点
            if (a[child] > temp) {
                a[pos] = a[child];
            } else {
                break;
            }
        }
        a[pos] = temp;
    }
    

    3.时间复杂度和空间复杂度

    时间复杂度:建堆:o(n),每次调整o(log n),故最好、最坏、平均情况下:o(n*logn);

    五、冒泡排序

    1.基本思路

    一次冒泡将序列中从头到尾所有元素两两比较,将最大的放在最后面。

    将剩余序列中所有元素再次两两比较,将最大的放在最后面。

    重复第二步,直到只剩下一个数。

    2.代码实现

    /**
     * @author fupeng
     * 冒泡排序优化第二版
     * 第一版优化增加flag标记,没有数字交换直接return,最优时间复杂度O(n)
     * 第二版优化,增加tempPosition记录内循环最后一次交换的位置,来缩减内循环的次数
     */
    public static void bubbleSort(int[] array) {
        int len = array.length - 1;
        // 开辟一个临时空间, 存放交换的中间值
        int temp;
        // 记录最后一次交换的位置
        int tempPosition = 0;
        // 要遍历的次数
        for (int i = 0; i < array.length - 1; i++) {
            int flag = 1; // 设置一个标志位
            // 依次比较相邻两个数的大小,遍历一次后,会将前面没有排好序的最大值放到后面位置
            for (int j = 0; j < len; j++) {
                // 比较相邻的元素,如果前面的数大于后面的数,交换
                if (array[j] > array[j + 1]) {
                    temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                    // 发生交换,标志位置0
                    flag = 0;
                    // 记录交换的位置
                    tempPosition = j;
                }
            }
            // 把最后一次交换的位置给len,来缩减内循环的次数
            len = tempPosition;
            // 如果没有交换过元素,则已经有序
            if (flag == 1) {
                System.out.println(Arrays.toString(array));
                return;
            }
        }
        System.out.println(Arrays.toString(array));
    }
    

    3.时间复杂度和空间复杂度

    冒泡排序的最好时间复杂度为O(n),最坏时间复杂度为O(n²),平均时间复杂度为O(n²),空间复杂度为O(1),它是一种稳定的排序算法。

    六、快速排序

    1.基本思路

    快速排序使用分治策略来把一个序列(list)分为两个子序列(sub-lists)。步骤为:

    • 1.从数列中挑出一个元素,称为"基准"(pivot)。
    • 2.重新排序数列,所有比基准值小的元素摆放在基准前面,所有比基准值大的元素摆在基准后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
    • 3.递归地(recursively)把小于基准值元素的子数列和大于基准值元素的子数列排序。

    递归到最底部时,数列的大小是零或一,也就是已经排序好了。这个算法一定会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。

    2.代码实现

    public static void quickSort(int[] array) {
        sort(array, 0, array.length - 1);
        System.out.println(Arrays.toString(array));
    }
    
    private static void sort(int[] a, int low, int high) {
        int i = low;
        int j = high;
        if (a.length <= 1) {
            return;
        }
        if (i >= j) {
            return;
        }
        int index = a[i];
        while (i < j) {
            while (i < j && a[j] >= index)
                j--;
            if (a[j] < index)
                a[i++] = a[j];
            while (i < j && a[i] <= index)
                i++;
            if (a[i] > index)
                a[j--] = a[i];
        }
        a[i] = index;
        sort(a, low, i - 1);
        sort(a, i + 1, high);
    }
    

    3.时间复杂度和空间复杂度

    虽然 快排的时间复杂度达到了 O(n²),但是在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好。

    七、归并排序

    1.基本思路

    归并排序(MERGE-SORT)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之)。

    • 1.分而治之
      在这里插入图片描述

    可以看到这种结构很像一棵完全二叉树,本文的归并排序我们采用递归去实现(也可采用迭代的方式去实现)。分阶段可以理解为就是递归拆分子序列的过程,递归深度为log2n。

    • 2.合并相邻有序子序列
      再来看看治阶段,我们需要将两个已经有序的子序列合并成一个有序序列,比如上图中的最后一次合并,要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列,合并为最终序列[1,2,3,4,5,6,7,8],来看下实现步骤。

    在这里插入图片描述
    在这里插入图片描述

    2.代码实现

    public static void mergeSort(int[] array) {
        int[] temp = new int[array.length];// 在排序前,先建好一个长度等于原数组长度的临时数组,避免递归中频繁开辟空间
        mergeSort(array, 0, array.length-1, temp);
        System.out.println(Arrays.toString(array));
    }
    
    private static void mergeSort(int[] arr, int left, int right, int []temp) {
        if(left < right) {
            int mid = (left+right) / 2;
            mergeSort(arr, left, mid, temp);// 左边归并排序,使得左子序列有序
            mergeSort(arr, mid+1, right, temp);// 右边归并排序,使得右子序列有序
            merge(arr, left, mid, right, temp);// 将两个有序子数组合并操作
        }
    }
    
    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;// 左序列指针
        int j = mid+1;// 右序列指针
        int t = 0;// 临时数组指针
        while (i <= mid && j <= right) {
            if(arr[i] <= arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        while(i <= mid) {// 将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j <= right) {// 将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        // 将temp中的元素全部拷贝到原数组中
        while(left <= right) {
            arr[left++] = temp[t++];
        }
    }
    

    3.时间复杂度和空间复杂度

    归并排序是稳定排序,它也是一种十分高效的排序,能利用完全二叉树特性的排序一般性能都不会太差。java中Arrays.sort()采用了一种名为TimSort的排序算法,就是归并排序的优化版本。从上文的图中可看出,每次合并操作的平均时间复杂度为O(n),而完全二叉树的深度为|log2n|。总的平均时间复杂度为O(nlogn)。而且,归并排序的最好,最坏,平均时间复杂度均为O(nlogn)。

    八、基数排序

    1.基本思路

    • 1.基数排序的思想就是先排好各位,然后排好各位的基础上排十位,以此类推,直到遍历最高位 次,排序结束(仔细理解最后一句话)
    • 2.基数排序不是比较排序,而是通过分配和收集的过程来实现排序
    • 3.初始化10个桶(固定的),桶下标为0-9
    • 4.通过得到待排序数字的个十百等位的数字,把这个数字对应的item放到对应的桶中
    • 5.基数排序有两种排序方式:LSD和MSD,最小位优先(从右边开始)和最大位优先(从左边开始)

    在这里插入图片描述

    2.代码实现

    public static void radixSort(int[] array) {
        ArrayList<ArrayList<Integer>> queue = new ArrayList<>();
        for (int i = 0; i <10 ; i++) {
            queue.add(new ArrayList<>());// 创建一个基数从0---9 每个数字上都是一个list
        }
        // 找到最大值,并判断最大值是几位数
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        int time = 0;
        while (max > 0) {
            max /= 10;
            time++;
        }
        for (int i = 0; i < time; i++) {// 循环每一个位数(个位、十位、百位)
            for (int j = 0; j < array.length; j++) {// 循环数组,取每一个值
                int x = array[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
                ArrayList<Integer> queue3 = queue.get(x);
    
                queue3.add(array[j]);
                queue.set(x, queue3);
            }
            int count = 0;
            for (int k = 0; k < 10; k++) {
                while (queue.get(k).size() > 0) {
                    ArrayList<Integer> queue4 = queue.get(k);
                    array[count] = queue4.get(0);
                    queue4.remove(0);
                    count++;
                }
            }
        }
    }
    

    3.时间复杂度和空间复杂度

    归并排序是稳定排序,它也是一种十分高效的排序,能利用完全二叉树特性的排序一般性能都不会太差。java中Arrays.sort()采用了一种名为TimSort的排序算法,就是归并排序的优化版本。从上文的图中可看出,每次合并操作的平均时间复杂度为O(n),而完全二叉树的深度为|log2n|。总的平均时间复杂度为O(nlogn)。而且,归并排序的最好,最坏,平均时间复杂度均为O(nlogn)。

    总结

    在这里插入图片描述

    引用:

    https://www.cnblogs.com/mensan/p/10570050.html

    https://www.cnblogs.com/jyroy/p/11248691.html

    https://www.cnblogs.com/chengxiao/p/6194356.html

    https://www.jianshu.com/p/8340dfaea3af

    展开全文
  • 针对学生在学习数据结构抽象的排序算法时难以理解的问题,采用目前应用最多的java 面向对象开发语言,并使用MYECLIPS 集成开发环境进行开发,实现了直接选择排序的可视化。形象、清晰、直观地展现了排序的动态过程,可以...
  • 该算法使用一种新的基于高效排序的全邻预测算法,经过排序以后形成预测误差集合,可以在很低失真度的情况下嵌入数据。实验的结果表明,该算法优于现有的可逆水印算法,并可以在具有较小失真度的情况下嵌入大量的数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 407,822
精华内容 163,128
关键字:

年的排序