排序算法

【C++】排序算法 冒泡排序、插入排序、选择排序、希尔排序、堆排序、归并排序、快速排序、计数排序、基数排序、桶排序、外排序 阅读详情

排序算法

八大排序

插入排序:直接插入排序、希尔排序

交换排序:冒泡排序、快速排序

选择排序:简单选择排序、堆排序

归并排序

基数排序


1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

将一个记录插入到已排序好的有序表中,从而得到一个新记录数增1的有序表。即:先将序列的第1个记录看成是一个有序的子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止。

要点:设立哨兵,作为临时存储和判断数组边界之用。

直接插入排序示例:

如果碰见一个和插入元素相等的,那么插入元素把想插入的元素放在相等元素的后面。所以,相等元素的前后顺序没有改变,从原无序序列出去的顺序就是排好序后的顺序,所以插入排序是稳定的。

算法的实现:

<?php

function insertSort($arr) {

    //区分 哪部分是已经排序好的

    //哪部分是没有排序的

    //找到其中一个需要排序的元素

    //这个元素 就是从第二个元素开始,到最后一个元素都是这个需要排序的元素

    //利用循环就可以标志出来

    //i循环控制 每次需要插入的元素,一旦需要插入的元素控制好了,

    //间接已经将数组分成了2部分,下标小于当前的(左边的),是排序好的序列

    $len=count($arr);

    for ($i=1; $i < $len; $i++) {

        //获得当前需要比较的元素值。

        $tmp = $arr[$i];

        //内层循环控制 比较 并 插入

        for ($j = $i - 1; $j >= 0; $j--) {

            //$arr[$i];//需要插入的元素; $arr[$j];//需要比较的元素

            if ($tmp < $arr[$j]) {

                //发现插入的元素要小,交换位置

                //将后边的元素与前面的元素互换

                $arr[$j + 1] = $arr[$j];

                //将前面的数设置为 当前需要交换的数

                $arr[$j] = $tmp;

            } else {

                //如果碰到不需要移动的元素

                //由于是已经排序好是数组,则前面的就不需要再次比较了。

                break;

            }

        }

    }

    //将这个元素 插入到已经排序好的序列内。

    //返回

    return $arr;

}

$arr = array(88, 1, 2, 5, 4, 3, 66, 0);

$res = insertSort($arr);

print_r($res);

效率:

时间复杂度:O(n^2).

其他的插入排序有二分插入排序,2-路插入排序。

 2. 插入排序—希尔排序(Shell`s Sort)

希尔排序是1959 年由D.L.Shell 提出来的,相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想:

插入排序的升级版(根据其特点:序列大部分已排好序时效率很高),将数据分为不同的组,先对每一组进行排序,然后对所有元素进行一次排序(即最后步长必须为1),步长的选择是递减的,比如5、3、1,现在一般使用D.E.Knuth分组方法(n很大是,用h(n+1)=3h(n)+1来分组,即1、4、13......)。

特点:平均时间复杂度O(n*logn),最坏时间复杂度O(n^s)(1<s<2),额外空间O(1),不稳定排序(相等元素在不同组里,交换后相对顺序可能改变)

希尔排序的示例:

算法实现:

我们简单处理增量序列:增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即:先将要排序的一组记录按某个增量d(n/2,n为要排序数的个数)分成若干组子序列,每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(d/2)对它进行分组,在每组中再进行直接插入排序。继续不断缩小增量直至为1,最后使用直接插入排序完成排序。

<?php

/**

 * 希尔排序

 */

function shell_sort(array $arr){

    // 将$arr按升序排列

    $len = count($arr);

    $f = 3;// 定义因子

    $h = 1;// 最小为1

    while ($h < $len/$f){

        $h = $f*$h + 1; // 1, 4, 13, 40, 121, 364, 1093, ...

    }

    while ($h >= 1){  // 将数组变为h有序

        for ($i = $h; $i < $len; $i++){  // 将a[i]插入到a[i-h], a[i-2*h], a[i-3*h]... 之中 (算法的关键

            for ($j = $i; $j >= $h;  $j -= $h){

                if ($arr[$j] < $arr[$j-$h]){

                    $temp = $arr[$j];

                    $arr[$j] = $arr[$j-$h];

                    $arr[$j-$h] = $temp;

                }

                //print_r($arr);echo '<br/>'; // 打开这行注释,可以看到每一步被替换的情形

            }

        }

        $h = intval($h/$f);

    }

    return $arr;

} 

$arr = array(14, 9, 1, 4, 6, -3, 2, 99, 13, 20, 17, 15, 3);

$shell = shell_sort($arr);

echo '<pre>';

print_r($shell);

希尔排序时效分析很难,关键码的比较次数与记录移动次数依赖于增量因子序列f的选取,特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法,有取奇数的,也有取质数的,但需要注意:增量因子中除1 外没有公因子,且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

3. 交换排序—冒泡排序(Bubble Sort)

基本思想:

在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

原理:对一组数据,比较相邻数据的大小,将值小数据在前面,值大的数据放在后面。   (以下都是升序排列,即从小到大排列)

  举例说明: $arr = array(6, 3, 8, 2, 9, 1);

$arr 有6个数据,按照两两比较大小如下,注意  比较轮数 和 每轮比较次数

  第一轮排序:

    第一次比较  6和3比较 结果:3    6   8   2   9   1     

    第二次比较  6和3比较 结果:3    6   8   2   9   1

    第三次比较  8和2比较 结果:3    6   2   8   9   1

    第四次比较  8和9比较 结果:3    6   2   8   9   1

    第五次比较  9和1比较 结果:3    6   2   8   1   9

  第一轮比较总结:1.排序第1轮、比较5次,没有获得从小到大的排序   2.因为每次比较都是大数往后靠,所以比较完成后,可以确定大数排在最后(9 已经冒泡冒出来了,下轮比较可以不用比较了 )

  第二轮排序:

    第一次比较  3和6比较 结果:3    6   2   8   1   9     

    第二次比较  6和2比较 结果:3    2   6   8   1   9

    第三次比较  6和8比较 结果:3    2   6   8   1   9

    第四次比较  8和1比较 结果:3    2   6   1   8   9

  第二轮比较总结:1.排序第2轮、比较4次,没有获得从小到大的排序   2.冒泡出了 8,下轮不用比较8 了

  第三轮排序:

    第一次比较  3和2比较 结果:2    3   6   1   8   9     

    第二次比较  3和6比较 结果:2    3   6   1   8   9

    第三次比较  6和1比较 结果:2    3   1   6   8   9

  第三轮比较总结:1.排序第3轮、比较3次,没有获得从小到大的排序   2.冒泡出了 6,下轮不用比较6 了

  第四轮排序:

    第一次比较  2和3比较 结果:2    3   1   6   8   9     

    第二次比较  3和1比较 结果:2    1   3   6   8   9

  第四轮比较总结:1.排序第4轮、比较2次,没有获得从小到大的排序   2.冒泡出了 3,下轮不用比较3 了

  第五轮排序:

    第一次比较  2和1比较 结果:1   2   3   6   8   9     

  第五轮比较总结:1.排序第5轮、比较1次,没有获得从小到大的排序   2.冒泡出了 2,由于还剩一个1,不用再比较了,至此通过5轮排序,完成整个排序。

  通过以上五轮排序,若干次比较,我们有理由推断出一个结论:

  对于一个长度为N的数组,我们需要排序 N-1 轮,每 i 轮 要比较 N-i 次。对此我们可以用双重循环语句,外层循环控制循环轮次,内层循环控制每轮的比较次数。

算法的实现:

<?php

function order($arr){

    $count = count($arr);

    $temp = 0;

    //外层控制排序轮次

    for($i=0; $i<$count-1; $i++){

        //内层控制每轮比较次数

        for($j=0; $j< $count-1-$i; $j++){

              if($arr[$j] > $arr[$j+1]){

                  $temp        = $arr[$j];

                  $arr[$j]     = $arr[$j+1];

                  $arr[$j+1]   = $temp;

             }

        }

    }

   return $arr;

     }

特点:平均时间复杂度O(n^2),最坏时间复杂度O(n^2),额外空间O(1),稳定排序(因为比较和交换都是两相邻元素,相等时不交换),n较小时较好

4. 交换排序—快速排序(Quick Sort)

基本思想:

1)选择一个基准元素,通常选择第一个元素或者最后一个元素,

2)通过一趟排序将待排序的记录分割成独立的两部分,其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3)此时基准元素在其排好序后的正确位置

4)然后分别对这两部分记录用同样的方法继续进行排序,直到整个序列有序。

快速排序的示例:

(a)一趟排序的过程:

(b)排序的全过程

算法的实现:

 递归实现:

<?php

    //快速排序

    //待排序数组

    $arr=array(6,3,8,6,4,2,9,5,1);

    //函数实现快速排序

    function quick_sort($arr)

    {

        //判断参数是否是一个数组

        if(!is_array($arr)) return false;

        //递归出口:数组长度为1,直接返回数组

        $length=count($arr);

        if($length<=1) return $arr;

        //数组元素有多个,则定义两个空数组

        $left=$right=array();

        //使用for循环进行遍历,把第一个元素当做比较的对象

        for($i=1;$i<$length;$i++)

        {

            //判断当前元素的大小

            if($arr[$i]<$arr[0]){

                $left[]=$arr[$i];

            }else{

                $right[]=$arr[$i];

            }

        }

        //递归调用

        $left=quick_sort($left);

        $right=quick_sort($right);

        //将所有的结果合并

        return array_merge($left,array($arr[0]),$right);

        }

        //调用

        echo "<pre>";

        print_r(quick_sort($arr));

5. 选择排序—简单选择排序(Simple Selection Sort)

基本思想:

在要排序的一组数中,选出最小(或者最大)的一个数与第1个位置的数交换;然后在剩下的数当中再找最小(或者最大)的与第2个位置的数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后一个数)比较为止。

简单选择排序的示例:

操作方法:

第一趟,从n 个记录中找出关键码最小的记录与第一个记录交换;

第二趟,从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换;

以此类推.....

第i 趟,则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换,

直到整个序列按关键码有序。

function select_sort($arr) {
//实现思路 双重循环完成,外层控制轮数,当前的最小值。内层 控制的比较次数
    //$i 当前最小值的位置, 需要参与比较的元素
    for($i=0, $len=count($arr); $i<$len-1; $i++) {
        //先假设最小的值的位置
        $p = $i;
        //$j 当前都需要和哪些元素比较,$i 后边的。
        for($j=$i+1; $j<$len; $j++) {
            //$arr[$p] 是 当前已知的最小值
            if($arr[$p] > $arr[$j]) {
     //比较,发现更小的,记录下最小值的位置;并且在下次比较时,
 // 应该采用已知的最小值进行比较。
                $p = $j;
            }
        }
        //已经确定了当前的最小值的位置,保存到$p中。
 //如果发现 最小值的位置与当前假设的位置$i不同,则位置互换即可
        if($p != $i) {
            $tmp = $arr[$p];
            $arr[$p] = $arr[$i];
            $arr[$i] = $tmp;
        }
    }
    //返回最终结果
    return $arr;
}

6. 选择排序—堆排序(Heap Sort)

堆排序是一种树形选择排序,是对直接选择排序的有效改进。

基本思想:

堆的定义如下:具有n个元素的序列(k1,k2,...,kn),当且仅当满足

 

时称之为堆。由堆的定义可以看出,堆顶元素(即第一个元素)必为最小项(小顶堆)。
若以一维数组存储一个堆,则堆对应一棵完全二叉树,且所有非叶结点的值均不大于(或不小于)其子女的值,根结点(堆顶元素)的值是最小(或最大)的。如:

(a)大顶堆序列:(96, 83,27,38,11,09)

  (b)  小顶堆序列:(12,36,24,85,47,30,53,91)

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树(一维数组存储二叉树),调整它们的存储序,使之成为一个堆,将堆顶元素输出,得到n 个元素中最小(或最大)的元素,这时堆的根节点的数最小(或者最大)。然后对前面(n-1)个元素重新调整使之成为堆,输出堆顶元素,得到n 个元素中次小(或次大)的元素。依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。称这个过程为堆排序。

因此,实现堆排序需解决两个问题:
1. 如何将n 个待排序的数建成堆;
2. 输出堆顶元素后,怎样调整剩余n-1 个元素,使其成为一个新堆。

首先讨论第二个问题:输出堆顶元素后,对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法:

1)设有m 个元素的堆,输出堆顶元素后,剩下m-1 个元素。将堆底元素送入堆顶((最后一个元素与堆顶进行交换),堆被破坏,其原因仅是根结点不满足堆的性质。

2)将根结点与左、右子树中较小元素的进行交换。

3)若与左子树交换:如果左子树堆被破坏,即左子树的根结点不满足堆的性质,则重复方法 (2).

4)若与右子树交换,如果右子树堆被破坏,即右子树的根结点不满足堆的性质。则重复方法 (2).

5)继续对不满足堆性质的子树进行上述交换操作,直到叶子结点,堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图:

再讨论对n 个元素初始建堆的过程。
建堆方法:对初始序列建堆的过程,就是一个反复进行筛选的过程。

1)n 个结点的完全二叉树,则最后一个结点是第个结点的子树。

2)筛选从第个结点为根的子树开始,该子树成为堆。

3)之后向前依次对各结点为根的子树进行筛选,使之成为堆,直到根结点。

如图建堆初始过程:无序序列:(49,38,65,97,76,13,27,49)

算法的实现:

从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。

<?php

//堆排序(对简单选择排序的改进)

function swap(array &$arr,$a,$b){

    $temp = $arr[$a];

    $arr[$a] = $arr[$b];

    $arr[$b] = $temp;

}

//调整 $arr[$start]的关键字,使$arr[$start]、$arr[$start+1]、、、$arr[$end]成为一个大根堆(根节点最大的完全二叉树)

//注意这里节点 s 的左右孩子是 2*s + 1 和 2*s+2 (数组开始下标为 0 时)

function HeapAdjust(array &$arr,$start,$end){

    $temp = $arr[$start];

    //沿关键字较大的孩子节点向下筛选

    //左右孩子计算(我这里数组开始下标识 0)

    //左孩子2 * $start + 1,右孩子2 * $start + 2

    for($j = 2 * $start + 1;$j <= $end;$j = 2 * $j + 1){

        if($j != $end && $arr[$j] < $arr[$j + 1]){

            $j ++; //转化为右孩子

        }

        if($temp >= $arr[$j]){

            break;  //已经满足大根堆

        }

        //将根节点设置为子节点的较大值

        $arr[$start] = $arr[$j];

        //继续往下

        $start = $j;

    }

    $arr[$start] = $temp;

}

 

function HeapSort(array &$arr){

    $count = count($arr);

    //先将数组构造成大根堆(由于是完全二叉树,所以这里用floor($count/2)-1,下标小于或等于这数的节点都是有孩子的节点)

    for($i = floor($count / 2) - 1;$i >= 0;$i --){

        HeapAdjust($arr,$i,$count);

    }

    for($i = $count - 1;$i >= 0;$i --){

        //将堆顶元素与最后一个元素交换,获取到最大元素(交换后的最后一个元素),将最大元素放到数组末尾

        swap($arr,0,$i);  

        //经过交换,将最后一个元素(最大元素)脱离大根堆,并将未经排序的新树($arr[0...$i-1])重新调整为大根堆

        HeapAdjust($arr,0,$i - 1);

    }

}

$arr = array(9,1,5,8,3,7,4,6,2);

HeapSort($arr);

var_dump($arr);

7. 归并排序(Merge Sort)

 

基本思想:

归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

利用归并(合并)的思想实现的排序方法。它的原理是假设初始序列含有 n 个元素,则可以看成是 n 个有序的子序列,每个子序列的长度为 1,然后两两归并,得到 ⌈ n / 2⌉ (⌈ x ⌉ 表示不小于 x 的最小整数)个长度为 2 或 1 的有序序列;再两两归并,······,如此重复,直至得到一个长度为 n 的有序序列为止,这种排序方法就成为 2 路归并排序。

归并排序示例:

合并方法:

/**

* mergeSort 归并排序

* 是开始递归函数的一个驱动函数

* @param &$arr array 待排序的数组

*/

function mergeSort(&$arr) {

    $len = count($arr);//求得数组长度

    mSort($arr, 0, $len-1);

}

/**

* 实际实现归并排序的程序

* @param &$arr array 需要排序的数组

* @param $left int 子序列的左下标值

* @param $right int 子序列的右下标值

*/

function mSort(&$arr, $left, $right) {

    if($left < $right) {

        //说明子序列内存在多余1个的元素,那么需要拆分,分别排序,合并

        //计算拆分的位置,长度/2 去整

        $center = floor(($left+$right) / 2);

        //递归调用对左边进行再次排序:

        mSort($arr, $left, $center);

        //递归调用对右边进行再次排序

        mSort($arr, $center+1, $right);

        //合并排序结果

        mergeArray($arr, $left, $center, $right);

    }

}

 /**

* 将两个有序数组合并成一个有序数组

* @param &$arr, 待排序的所有元素

* @param $left, 排序子数组A的开始下标

* @param $center, 排序子数组A与排序子数组B的中间下标,也就是数组A的结束下标

* @param $right, 排序子数组B的结束下标(开始为$center+1)

*/

function mergeArray(&$arr, $left, $center, $right) {

    //设置两个起始位置标记

    $a_i = $left;

    $b_i = $center+1;

    while($a_i<=$center && $b_i<=$right) {

        //当数组A和数组B都没有越界时

        if($arr[$a_i] < $arr[$b_i]) {

            $temp[] = $arr[$a_i++];

        } else {

            $temp[] = $arr[$b_i++];

        }

    }

    //判断 数组A内的元素是否都用完了,没有的话将其全部插入到C数组内:

    while($a_i <= $center) {

        $temp[] = $arr[$a_i++];

    }

    //判断 数组B内的元素是否都用完了,没有的话将其全部插入到C数组内:

    while($b_i <= $right) {

        $temp[] = $arr[$b_i++];

    }

    //将$arrC内排序好的部分,写入到$arr内:

    for($i=0, $len=count($temp); $i<$len; $i++) {

        $arr[$left+$i] = $temp[$i];

    }

} 

//do some test:

$arr = array(4, 7, 6, 3, 9, 5, 8);

mergeSort($arr);

print_r($arr);

8. 桶排序/基数排序(Radix Sort)

基本思想

基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或bin sort,顾名思义,它是透过键值的部份资讯,将要排序的元素分配至某些“桶”中,藉以达到排序的作用,基数排序法是属于稳定性的排序,其时间复杂度为O (nlog(r)m),其中r为所采取的基数,而m为堆数,在某些时候,基数排序法的效率高于其它的稳定性排序法。

基本解法:

PS:在这里我们介绍的基数排序我们采用 LSD(最低位优先),当然还有 MSD(最高位优先),大家自己去百度一下他们之间的异同吧。

假如现在我们有以下这么一些数:

2 343 342 1 128 43 4249 814 687 654 3

我们使用基数排序将他们从小到大排序。

第一步、首先根据个位数的数值,在走访数值(从前到后走访,后面步骤相同)时将它们分配至编号0到9的桶子中:

0 :

1 : 1

2 : 2 342

3 : 343 43 3

4 : 814 654

5 :

6 :

7 : 687

8 : 128

9 : 4249

第二步、接下来将这些桶子中的数值重新串接起来,成为以下的数列:

1 2 342 343 43 3 814 654 687 128 4249

第三步、根据十位数的数值,在走访数值(从前到后走访,后面步骤相同)时将它们分配至编号0到9的桶子中:

0 : 1 2 3

1 : 814

2 : 128

3 :

4 : 342 343 43 4249

5 : 654

6 :

7 :

8 : 687

9 :

第四步、接下来将这些桶子中的数值重新串接起来,成为以下的数列:

1 2 3 814 128 342 343 43 4249 654 687

第五步、根据百位数的数值,在走访数值(从前到后走访,后面步骤相同)时将它们分配至编号0到9的桶子中:

0 : 1 2 3 43

1 : 128

2 : 4249

3 : 342 343

4 :

5 :

6 : 654 687

7 :

8 : 814

9 :

第六步、接下来将这些桶子中的数值重新串接起来,成为以下的数列:

1 2 3 43 128 4249 342 343 654 687 814

后面的步骤大家应该都会走了吧。其实到了第六步的时候就剩 4249 没有排好序了。

从上面的步骤来看,很多的步骤都是相同的,因此肯定是个循环了,我们只需要控制个位、十位、百位、、、、就好了。

//交换函数function swap(array &$arr,$a,$b){

    $temp = $arr[$a];

    $arr[$a] = $arr[$b];

    $arr[$b] = $temp;

}

//获取数组中的最大数//就像上面的例子一样,我们最终是否停止算法不过就是看数组中的最大值:4249,它的位数就是循环的次数function getMax(array $arr){

    $max = 0;

    $length = count($arr);

    for($i = 0;$i < $length;$i ++){

        if($max < $arr[$i]){

            $max = $arr[$i];

        }

    }

    return $max;

}

//获取最大数的位数,最大值的位数就是我们分配桶的次数function getLoopTimes($maxNum){

    $count = 1;

    $temp = floor($maxNum / 10);

    while($temp != 0){

        $count ++;

        $temp = floor($temp / 10);

    }

    return $count;

}

/**

 * @param array $arr 待排序数组

 * @param $loop 第几次循环标识

 * 该函数只是完成某一位(个位或十位)上的桶排序

 */function R_Sort(array &$arr,$loop){

    $tempArr = array();

    $count = count($arr);

    for($i = 0;$i < 10;$i ++){

        $tempArr[$i] = array();

    }

    //求桶的index的除数

    //如798个位桶index=(798/1)%10=8

    //十位桶index=(798/10)%10=9

    //百位桶index=(798/100)%10=7

    //$tempNum为上式中的1、10、100

    $tempNum = (int)pow(10, $loop - 1);

    for($i = 0;$i < $count;$i ++){

        //求出某位上的数字

        $row_index = ($arr[$i] / $tempNum) % 10;

        //入桶

        array_push($tempArr[$row_index],$arr[$i]);

    }

    //还原回原数组中

    $k = 0;

    for($i = 0;$i < 10;$i ++){

        //出桶

        while(count($tempArr[$i]) > 0){

            $arr[$k ++] = array_shift($tempArr[$i]);

        }

    }

}

//最终调用的主函数function RadixSort(array &$arr){

    $max = getMax($arr);

    $loop = getLoopTimes($max);

    //对每一位进行桶分配(1 表示个位,$loop 表示最高位)

    for($i = 1;$i <= $loop;$i ++){

        R_Sort($arr,$i);

    }

}

$arr = array(2, 343, 342, 1, 128, 43, 4249, 814, 687, 654, 3);

RadixSort($arr);

var_dump($arr);

排序算法:稳定的排序算法 元素,并围绕主元对列表进行分区,将较小的元素放入低数组中,将所有较大的元素放入高数组中。然后,我们对他们的第十位的值进行排序。因此,我们可以对任意大小的列表进行排序,而无需在冒泡排序中使用任何额外的空间。我们可以说,子问题可以被视为对数组的一部分进行排序,从任何索引 s(start) 开始,到任何索引 e(end) 结束。正如我们上面所讨论的,最大堆是一个完全二叉树,其中每个内部节点中的值都大于或等于该节点的子节点中的值。此外,每次迭代后,已排序子数组的大小都会增加,而未排序子数组的大小会减少。 阅读详情

相关推荐

八种排序算法

偶尔有看到排序算法,想起来大学里老师也有讲授过冒泡排序、快速排序等,不过现在已经没什么概念,一查发现排序算法有八种,有的甚至连名字都没听过,感概平时看的少。既然已经看到了,就干脆了解下基础概念,避免在后续学习途中,出现一看就懵逼的情况。   冒泡排序 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到...

dobat的博客 3349

sql排序用法

sql排序用法 select关键字 *星号表示全搜索 where关键字 SELECT * FROM PW_Student WHERE StudentSex = '女' 排序 写法 ORDER BY [column_name | expression] [ASC | DESC ]关键字 升序 ASC(默认) 降序 DESC SELECT * FROM PW_Student ORDER BY StudentSex desc 按多列对结果集进行排序 SELECT * FROM PW_Studen

xiaoChenPengYou的博客 2万+

排序算法总结及C++实现

文章目录1 引入 认识时间复杂度2 补充 对数器3 排序算法分析3.1 基于比较的排序3.1.1 冒泡排序3.1.2 选择排序3.1.3 插入排序3.1.4 归并排序补充题目 小和问题补充题目 逆序数3.1.5 快速排序3.1.6 堆排序3.2 非基于比较的排序3.2.1 计数排序3.2.2 桶排序3.2.3 基数排序4 排序总结4.1 稳定性4.2 工程中的综合排序算法4.3 有关排序...

李滚滚的博客 2224

SPL 排序优化技巧

【摘要】 排序计算是一个非常消耗资源的操作,特别是对于大数据排序,如果内存无法装下数据,常规的做法就需要借助外存,不过因此也会增加对数据的读写操作,而读写操作通常又会比排序操作更消耗资源。 让我们一起去乾学院看个究竟吧:SPL 排序优化技巧 本文介绍的SPL排序优化技巧,除了提供常规的排序算法外,还根据不同场景下的数据特性提供了排序的替代算法...

Raqsoft 684

排序算法 - 面试中的排序算法总结

排序算法总结 查找和排序算法是算法的入门知识,其经典思想可以用于很多算法当中。因为其实现代码较短,应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗,只要熟悉了思想,灵活运用也不是难事。 一般在面试中最常考的是快速排序和归并排序,并且经常有面试官要求现场写出这两种排序的代码。对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。面试官对

从零开始 2983

测绘无人船避坑指南:云卓H12Pro遥控器接海康摄像头,从网络设置到RTSP流延迟优化全流程

本文详细解析了测绘无人船视频子系统的优化方案,重点介绍海康威视摄像头与云卓H12Pro遥控器的深度适配流程。从网络设置到RTSP流延迟优化,提供了一套经过实测的低延迟(<200ms)解决方案,适用于复杂水域环境下的测绘任务。

weixin_30415113的博客 629

SQL中常用的四个排序函数,你用过几个?

ROW_NUMBER()是排序,当存在相同成绩的学生时,ROW_NUMBER()会依次进行排序,他们序号不相同,而Rank()则不一样。如果出现相同的,他们的排名是一样的。今天就给大家介绍四个你不怎么常用排序函数,他们就是SQL Server排序中经常用到的ROW_NUMBER(),RANK(),DENSE_RANK(),NTILE()这四个好兄弟。RANK()是1-1-3-4-5,而ROW_NUMBER()则还是1-2-3-4-5,这就是RANK()和ROW_NUMBER()的区别了。

伤心的辣条 9930

Charles 抓包工具下载安装及基础使用

本篇内容主讲关于Charles抓包工具,从下载安装以及配置信息,证书的下载安装以及PC端设置代理配置和移动端设备配置代理,阐述关于Charles抓包工具面板的基础使用以及如何进行抓包和设置断点,对于软件测试以及对抓包感兴趣的读者可以翻阅!感谢大家的支持!!!

灵魂学者的博客 2960

SQL ORDER BY 子句【排序】升降序

ORDER BY 语句一般是对指定的列进行排序,默认按照升序对记录进行排序。 如果想要降序利用DESC关键字对记录进行降序。 1.以字母顺序显示公司名称 SELECT Company, OrderNumber FROM Orders ORDER BY Company 实例 2 以字母顺序显示公司名称(Company),并以数字顺序显示顺序号(OrderNumber): S...

tong_0xue的博客 4万+

最小路径和——动态规划求解(Java实现)

最小路径和——动态规划求解(Java实现) 题目: 给定一个包含非负整数的 m x n 网格,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。 说明:每次只能向下或者向右移动一步。 示例: 输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 7 解释: 因为路径 1→3→1→1→1 的总和最小。 这题和机器人走路的思路类似,就是状态方程有所不同,...

weixin_43395911的博客 896

【深度解析】信息素养提升实践活动(附:历年获奖作品分析)

全国师生信息素养提升实践活动是由教育部教育技术与资源发展中心(中央电化教育馆)主办,面向全国师生的一项信息化交流展示活动。

m0_74417957的博客 2631

SQL之排序

排序 正序 (从小排到大,按升序排列)(asc不用写,默认使用这个) order by 字段 asc 倒序 (从大排到小,按降序排列) order by 字段 desc SQL-order by 两个字段同时排序 ORDER BY 后可加2个字段,用英文逗号隔开,先按f1排序,再按f2排序。 --f1用升序, f2降序,sql该这样写 ORDER BY f1, f2 DE...

命中的缘分的博客 1万+

cartographer运行错误集合

播放bag的时候错误 Check failed: sensor_to_tracking->translation().norm() < 1e-5 The IMU frame must be colocated with the tracking frame. Transforming linear acceleration into the tracking frame will otherwise be imprecise tracking frame不是imu的link 修改lua文件中的.

Studying…… 2037

九大排序算法再总结

如果要转载,需要注明出处: http://blog.youkuaiyun.com/xiazdong 本文是 http://blog.youkuaiyun.com/xiazdong/article/details/7304239 的补充,当年看了《大话数据结构》总结的,但是现在看了《算法导论》,发现以前对排序的理解还不深入,所以打算对各个排序的思想再整理一遍。 本文首先介绍了基于比较模型的排序算法,

xiazdong 31万+

国科大学习资料--高级软件工程-复习题概念解释答案

国科大学习资料–高级软件工程(罗铁坚 魏峻 刘丹)-复习题概念解释答案 1. 敏捷开发方法与Scrum方法 a.敏捷是一种强调轻量的过程方法论,它强调拥抱变化而不是与之对抗,通过有效的沟通发挥群体的智慧。敏捷方法采用迭代/增量开发的过程模型。敏捷宣言是:个体和交互高于流程和工具;工作的软件高于详尽的文档;客户合作高于合同谈判;响应变化高于遵循计划。 虽然右边的也有价值,但是认为左边的更有价值。 b.Scrum(Schwaber和Beedle)是管理两个披萨规模(4-9人)的软件开发团队的方法,它高频率的短会

无名何许人的博客 1444

CODESYS数据处理合集(高低字节/ 字/浮点数/位)

VAR_INPUT//字节0//字节1END_VARVAREND_VAR。

RXXW_Dor的博客 358

「排序算法」十大经典排序算法

文章目录十大经典排序算法一、冒泡排序二、选择排序三、插入排序四、希尔排序五、归并排序六、快速排序七、堆排序八、计数排序九、桶排序十、基数排序 引用网站:菜鸟教程十大经典排序 十大经典排序算法 排序算法图片总结(图片来源于网络) 一、冒泡排序 冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢

秋天,黄叶坠地,凉风有信。 6437

YOLOv5 实现 10 种热力图可视化方式教程 | GradCAM XGradCAM ScoreCAM LayerCAM HiResCAM EigenCAM....

基于梯度计算类激活图,是最经典的热力图生成方法之一。Grad-CAM的改进版,通过引入梯度加权的方式,提高了热力图的定位精度。基于类别的得分计算类激活图,对噪声具有更强的鲁棒性。基于特定层的特征图计算类激活图,可以灵活选择不同的层进行分析。通过上采样将低分辨率的特征图恢复到原始图像大小,提高了热力图的分辨率。基于特征图的特征向量进行PCA降维,得到更简洁的热力图。对Grad-CAM的进一步改进,通过加权平均的方式,提高了热力图的质量。基于积分梯度的方法,可以解释模型对输入的每个特征的贡献。

weixin_39818775的博客 2376

稳定排序算法有哪些

稳定排序算法有哪些 相信您已经掌握了很多种排序算法,比如冒泡排序、插入排序、希尔排序、选择排序等。这些排序算法中,有些是 “稳定” 的,有些是 “不稳定” 的。 给定的待排序序列中,经常会包含相同的元素,例如: 3 1 2 4 2 此序列中包含两个元素 2,为了区分它们,我们分别称它们为 “红 2” 和 “绿 2”。 评价一个排序算法是否稳定,是指该算法完成排序的同时,是否会改变序列中相同元素的相对位置。例如,上面序列中红 2 和绿 2 的相对位置是:红 2 位于绿 2 的左侧,或者说绿 2 位于红 2

ccc369639963的博客 1万+

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

【排序算法】排序算法总结

排序算法总结,将排序算法的分类、稳定性和特点进行一个总结,并附有跳转到对应详解的链接,方便大家学习

weixin_52811588的博客 991

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

排序算法详解

排序算法是计算机科学中最基础也最重要的算法之一。它将一组数据(例如数字列表、字符串集合)按照特定的顺序(升序或降序)重新排列。高效的排序算法对于优化其他算法(如搜索和合并算法)的效率至关重要。

m0_54069809的博客 1174

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

十大经典排序算法

十种常见的排序算法可分为以下两大类: 比较类排序:通过比较来决定元素间的相对位置,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序。 非比较类排序:不通过比较来决定元素间的相对位置,它可以突破基于比较排序的时间下限,以线性时间运行,因此也称为线性时间非比较类排序。 时间复杂度: 从序列的初始状态到经过排序算法的变换移位等操作变到最终排序好的结果状态的过程所花费的时间度量。

qq_40896594的博客 3673

什么是排序算法?常见的排序算法有哪些?

计数排序适用于数据范围较小且已知的情况,其时间复杂度为线性时间,非常适合处理小范围内的数据排序。基数排序适用于整数排序,特别是当数据范围较大但数据量适中时。它通过多次应用计数排序来实现多轮排序,从而克服了传统排序算法在处理大范围数据时的效率问题。

破损的天堂鸟博客 1230

排序算法总结

1.排序算法分类 基础的排序算法包含冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序及快速排序。 根据实现类型可分为插入排序类、选择排序类、交换排序类及归并排序类。 2.排序算法的综合分析 各算法的排序方式、平均情况、最好最坏情况、所需的辅助空间及稳定性如下: 事实上,排序算法没有十全十美,本来想写一套模拟测试的数据来验证孰优孰略。但是突然发现可比性不高,需要根据

黄俊彬 2543

十大排序算法

算法稳定性:单次比较后,两个值相等的邻近元素的位置在排序后,相对位置没有改变。

一名想做出点成就的后端~ 1429
上一篇: 算法
下一篇: jquery的each循环与javascript的for循环性能比较
php_elephant
博客等级 码龄9年 12粉丝 9原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值