来总括下各样排序算法,时间复杂度为O(ca88亚洲城网站n^2)

排序算法是最基本最常用的算法,不一样的排序算法在不一样的面貌或选用中会有两样的突显,大家需要对各个排序算法谙习才能将它们采纳到骨子里当中,才能更好地表明它们的优势。今日,来总计下各个排序算法。

排序算法是最要旨最常用的算法,分裂的排序算法在分歧的场合或利用中会有例外的彰显,大家要求对各个排序算法熟习才能将它们利用到实际当中,才能更好地发挥它们的优势。前天,来统计下各类排序算法。

十大经典排序算法

下边这几个表格总括了各个排序算法的复杂度与稳定:

上边这一个表格总括了各个排序算法的复杂度与稳定:

来源:https://github.com/hustcc/JS-Sorting-Algorithm

各类排序算法复杂度比较.png

各样排序算法复杂度比较.png

排序算法是《数据结构与算法》中最中心的算法之一。

冒泡排序

冒泡排序可谓是最经典的排序算法了,它是基于相比较的排序算法,时间复杂度为O(n^2),其独到之处是兑现简单,n较时辰性能较好。

  • 算法原理
    隔壁的数量举行两两比较,小数放在面前,大数放在后边,那样一趟下来,最小的数就被排在了第四位,第二趟也是那样,如此类推,直到所有的多少排序达成

  • c++代码完毕

void bubble_sort(int arr[], int len)
{
for (int i = 0; i < len – 1; i++)
{
for (int j = len – 1; j > i; j–)
{
if (arr[j] < arr[j – 1])
{
int temp = arr[j];
arr[j] = arr[j – 1];
arr[j – 1] = temp;
}
}
}
}
“`

冒泡排序

排序算法可以分为内部排序和表面排序,内部排序是数码记录在内存中开展排序,而外部排序是因排序的数目很大,三回不能包容所有的排序记录,在排序进度中须求拜访外存。常见的里边排序算法有:插入排序、希尔(希尔)排序、接纳排序、冒泡排序、归并排序、飞快排序、堆排序、基数排序等。用一张图概括:

分选排序

  • 算法原理
    先在未排序体系中找到最小(大)元素,存放到排序种类的苗子地方,然后,再从剩余未排序元素中三番五次搜寻最小(大)元素,然后嵌入已排序连串的末尾。以此类推,直到所有因素均排序达成。

  • c++代码完成

    void select_sort(int arr[], int len)
    {
        for (int i = 0; i < len; i++)
        {
            int index = i;
            for (int j = i + 1; j < len; j++)
            {
                if (arr[j] < arr[index])
                    index = j;
            }
            if (index != i)
            {
                int temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp; 
            }
        }
    }
    

冒泡排序可谓是最经典的排序算法了,它是按照相比较的排序算法,时间复杂度为O(n^2),其亮点是贯彻简单,n较时辰性能较好。

ca88亚洲城网站 1

插入排序

  • 算法原理
    将数据分为两片段,有序部分与无序部分,一发轫有序部分含有第1个元素,依次将无序的元素插入到有序部分,直到所有因素有序。插入排序又分为直接插入排序、二分插入排序、链表插入等,那里只谈谈直接插入排序。它是稳定的排序算法,时间复杂度为O(n^2)

  • c++代码完结

    void insert_sort(int arr[], int len)
    {
        for (int i = 1; i < len; i ++)
        {
            int j = i - 1;
            int k = arr[i];
            while (j > -1 && k < arr[j] )
            {
                arr[j + 1] = arr[j];
                j --;
            }
            arr[j + 1] = k;
        }
    }
    

算法原理

关于时间复杂度:

迅猛排序

  • 算法原理
    火速排序是现阶段在实践中国和非洲常飞快的一种排序算法,它不是平稳的排序算法,平均时间复杂度为O(nlogn),最差境况下复杂度为O(n^2)。它的骨干考虑是:通过一趟排序将要排序的多少分割成独立的两有些,其中有的的持有数据都比其余一些的有所数据都要小,然后再按此办法对那两片段数据分别开展高效排序,整个排序进度可以递归举行,以此达到任何数据变成有序体系。
  • c++代码完毕

void quick_sort(int arr[], int left, int right)
{
if (left < right)
{
int i = left, j = right, target = arr[left];
while (i < j)
{
while (i < j && arr[j] > target)
j–;
if (i < j)
arr[i++] = arr[j];

        while (i < j && arr[i] < target)
            i++;
        if (i < j)
            arr[j] = arr[i];
    }
    arr[i] = target;
    quick_sort(arr, left, i - 1);
    quick_sort(arr, i + 1, right);
}

}
“`

相邻的数额开展两两比较,小数放在面前,大数放在后边,那样一趟下来,最小的数就被排在了第三位,第二趟也是那般,如此类推,直到所有的数目排序达成

平方阶 (O(n2)) 排序 各样简单排序:直接插入、直接拔取和冒泡排序。

归并排序

  • 算法原理
    归并排序具体做事原理如下(假使系列共有n个元素):

    • 将连串每相邻四个数字进行联合操作(merge),形成floor(n/2)个种类,排序后种种种类包涵多个要素
    • 将上述系列再次相会,形成floor(n/4)个连串,每个种类包涵多少个因素
    • 重新步骤2,直到所有因素排序达成

    归并排序是祥和的排序算法,其时间复杂度为O(nlogn),假诺是拔取链表的兑现的话,空间复杂度可以达到O(1),但倘诺是应用数组来存储数据以来,在统一的进度中,必要暂时空间来储存归并好的数额,所以空间复杂度为O(n)

  • c++代码已毕

    void merge(int arr[], int temp_arr[], int start_index, int mid_index, int end_index)
    {
        int i = start_index, j = mid_index + 1;
        int k = 0;
        while (i < mid_index + 1 && j < end_index + 1)
        {
            if (arr[i] > arr[j])
                temp_arr[k++] = arr[j++];
            else
                temp_arr[k++] = arr[i++];
        }
        while (i < mid_index + 1)
        {
            temp_arr[k++] = arr[i++];
        }
        while (j < end_index + 1)
            temp_arr[k++] = arr[j++];
    
        for (i = 0, j = start_index; j < end_index + 1; i ++, j ++)
            arr[j] = temp_arr[i];
    }
    
    void merge_sort(int arr[], int temp_arr[], int start_index, int end_index)
    {
        if (start_index < end_index)
        {
            int mid_index = (start_index + end_index) / 2;
            merge_sort(arr, temp_arr, start_index, mid_index);
            merge_sort(arr, temp_arr, mid_index + 1, end_index);
            merge(arr, temp_arr, start_index, mid_index, end_index);
        }
    }
    

c++代码完毕

线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和集合排序。

堆排序

void bubble_sort(int arr[], int len)

O(n1+§)) 排序,§ 是在乎 0 和 1 之间的常数。 希尔(希尔)排序。

二叉堆

二叉堆是一点一滴二叉树或者近似完全二叉树,满足四个特征

  • 父结点的键值总是凌驾或等于(小于或等于)任何一个子节点的键值
  • 各类结点的左子树和右子树都是一个二叉堆

当父结点的键值总是凌驾或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。一般二叉树简称为堆。

{

线性阶 (O(n)) 排序 基数排序,其它还有桶、箱排序。

堆的储存

诚如都是数组来存储堆,i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 12 * i + 2。如第0个结点左右子结点下标分别为1和2。存储结构如图所示:

堆结构.png

     for (int i = 0; i < len – 1; i++)

有关稳定:

堆排序原理

堆排序的时间复杂度为O(nlogn)

  • 算法原理(以最大堆为例)

  • 先将启幕数据R[1..n]建成一个最大堆,此堆为开首的无序区
  • 再将敬重字最大的记录R[1](即堆顶)和无序区的末尾一个记录R[n]交流,由此获得新的无序区R[1..n-1]和有序区R[n],且满足R[1..n-1].keys≤R[n].key
  • 鉴于沟通后新的根R[1]可能违反堆性质,故应将近日无序区R[1..n-1]调整为堆。
  • 重复2、3手续,直到无序区唯有一个元素停止。

  • c++代码落成

/**
 * 将数组arr构建大根堆
 * @param arr 待调整的数组
 * @param i   待调整的数组元素的下标
 * @param len 数组的长度
 */
void heap_adjust(int arr[], int i, int len)
{
    int child;
    int temp;

    for (; 2 * i + 1 < len; i = child)
    {
        child = 2 * i + 1;  // 子结点的位置 = 2 * 父结点的位置 + 1
        // 得到子结点中键值较大的结点
        if (child < len - 1 && arr[child + 1] > arr[child])
            child ++;
        // 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
        if (arr[i] < arr[child])
        {
            temp = arr[i];
            arr[i] = arr[child];
            arr[child] = temp;
        }
        else
            break;
    }
}

/**
 * 堆排序算法
 */
void heap_sort(int arr[], int len)
{
    int i;
    // 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
    for (int i = len / 2 - 1; i >= 0; i--)
    {
        heap_adjust(arr, i, len);
    }

    for (i = len - 1; i > 0; i--)
    {
        // 将第1个元素与当前最后一个元素交换,保证当前的最后一个位置的元素都是现在的这个序列中最大的
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        // 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
        heap_adjust(arr, 0, i);
    }
}

未完待续

     {

稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序。

         for (int j = len – 1; j > i; j–)

不是平静的排序算法:接纳排序、飞速排序、希尔排序、堆排序。

         {

名词解释:

             if (arr[j] < arr[j – 1])

n:数据规模

             {

k:“桶”的个数

                 int temp = arr[j];

In-place:占用常数内存,不占用额外内存

                 arr[j] = arr[j – 1];

Out-place:占用额外内存

                 arr[j – 1] = temp;

安宁:排序后 2 个非常键值的逐一和排序此前它们的一一相同

             }

冒泡排序

         }

冒泡排序(Bubble
Sort)也是一种不难直观的排序算法。它再度地访问过要排序的数列,五遍相比四个要素,即使他们的各类错误就把她们互换过来。走访数列的干活是再度地进行直到没有再须求交流,也就是说该数列已经排序完结。这些算法的名字由来是因为越小的因素会路过沟通逐渐“浮”到数列的顶端。

     }

用作最容易易行的排序算法之一,冒泡排序给本人的痛感就像是 Abandon
在单词书里冒出的感觉到一样,每回都在第一页首位,所以最熟稔。冒泡排序还有一种优化算法,就是立一个
flag,当在一趟连串遍历中元素没有生出互换,则阐明该系列已经平稳。但那种立异对于升级性能来说并不曾什么太大效益。

}

1. 算法步骤

慎选排序

相比相邻的因素。假若第二个比首个大,就交流他们八个。

算法原理

对每一对邻近元素作同样的做事,从上马率先对到最后的终极一对。那步做完后,最后的因素会是最大的数。

先在未排序连串中找到最小(大)元素,存放到排序序列的先导地方,然后,再从剩余未排序元素中三番五次寻找最小(大)元素,然后放到已排序连串的末段。以此类推,直到所有因素均排序完成。

针对富有的因素重复以上的手续,除了最终一个。

c++代码落成

源源不断每回对越来越少的要素重复上面的步骤,直到没有其他一对数字须求相比较。

 void select_sort(int arr[], int len)

2. 动图演示

 {

ca88亚洲城网站 2

     for (int i = 0; i < len; i++)

3. 如曾几何时候最快

     {

当输入的数据已经是正序时(都早就是正序了,我还要你冒泡排序有什么用啊)。

         int index = i;

4. 如何时候最慢

         for (int j = i + 1; j < len; j++)

当输入的多寡是反序时(写一个 for
循环反序输出数据不就行了,干嘛要用你冒泡排序呢,我是闲的吧)。

         {

5. Python 代码已毕

             if (arr[j] < arr[index])

defbubbleSort(arr):

                 index = j;

foriinrange(1, len(arr)):

         }

forjinrange(0, len(arr)-i):

         if (index != i)

ifarr[j] > arr[j+1]:

         {

arr[j], arr[j +1] = arr[j +1], arr[j]

             int temp = arr[i];

returnarr

             arr[i] = arr[index];

选择排序

             arr[index] = temp;

慎选排序是一种简易直观的排序算法,无论怎么数据进去都是 O(n²)
的大运复杂度。所以用到它的时候,数据规模越小越好。唯一的裨益恐怕就是不占用额外的内存空间了呢。

}

1. 算法步骤

}

率先在未排序连串中找到最小(大)元素,存放到排序系列的起第三地方

}

再从剩余未排序元素中继承查找最小(大)元素,然后嵌入已排序连串的最后。

插入排序

再一次第二步,直到所有因素均排序已毕。

算法原理

2. 动图演示

将数据分为两有的,有序部分与无序部分,一开端有序部分含有第1个元素,依次将无序的因素插入到有序部分,直到所有因素有序。插入排序又分为直接插入排序、二分插入排序、链表插入等,那里只谈谈直接插入排序。它是平安无事的排序算法,时间复杂度为O(n^2)

ca88亚洲城网站 3

c++代码完结

3. Python 代码完结

 void insert_sort(int arr[], int len)

defselectionSort(arr):

 {

foriinrange(len(arr) -1):

     for (int i = 1; i < len; i ++)

# 记录最小数的目录

     {

minIndex = i

         int j = i – 1;

forjinrange(i +1, len(arr)):

         int k = arr[i];

ifarr[j] < arr[minIndex]:

         while (j > -1 && k < arr[j] )

minIndex = j

         {

# i 不是微小数时,将 i 和微小数举办交流

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

ifi != minIndex:

             j –;

arr[i], arr[minIndex] = arr[minIndex], arr[i]

         }

returnarr

         arr[j + 1] = k;

插入排序

     }

插入排序的代码完成固然尚未冒泡排序和抉择排序那么粗略严酷,但它的法则应该是最简单精通的了,因为如果打过扑克牌的人都应该力所能及秒懂。插入排序是一种最简便易行直观的排序算法,它的干活原理是由此构建有序系列,对于未排序数据,在已排序系列中从后迈入扫描,找到相应岗位并插入。

 }

插入排序和冒泡排序一样,也有一种优化算法,叫做拆半插入。

很快排序

1. 算法步骤

算法原理

将首先待排序体系首个要素看做一个静止种类,把第四个元素到最终一个元素当成是未排序系列。

高效排序是现阶段在实践中国和亚洲常便捷的一种排序算法,它不是平静的排序算法,平均时间复杂度为O(nlogn),最差境况下复杂度为O(n^2)。它的基本思维是:通过一趟排序将要排序的数额分割成独立的两片段,其中一些的具有数据都比此外一些的具有数据都要小,然后再按此方法对那两有的数据分别展开急忙排序,整个排序进程可以递归进行,以此达到总体数据变成有序连串。

从头到尾依次扫描未排序序列,将围观到的每个元素插入有序系列的分外地方。(如若待插入的因素与平稳序列中的某个元素相等,则将待插入元素插入到相当元素的末尾。)

c++代码完毕

ca88亚洲城网站 4

void quick_sort(int arr[], int left, int right)

3. Python 代码完毕

{

definsertionSort(arr):

 if (left < right)

foriinrange(len(arr)):

 {

preIndex = i-1

     int i = left, j = right, target = arr[left];

current = arr[i]

     while (i < j)

whilepreIndex >=0andarr[preIndex] > current:

     {

arr[preIndex+1] = arr[preIndex]

         while (i < j && arr[j] > target)

preIndex-=1

             j–;

arr[preIndex+1] = current

         if (i < j)

returnarr

             arr[i++] = arr[j];

希尔排序

         while (i < j && arr[i] < target)

希尔(Hill)排序,也称递减增量排序算法,是插入排序的一种更便捷的考订版本。但希尔(希尔(Hill))排序是非稳定排序算法。

             i++;

希尔(Hill)排序是基于插入排序的以下两点性质而提议革新措施的:

         if (i < j)

插入排序在对大概已经排好序的数量操作时,效用高,即可以落成线性排序的效用;

             arr[j] = arr[i];

但插入排序一般的话是无效的,因为插入排序每回只可以将数据移动一位;

     }

希尔(希尔(Hill))排序的主干思维是:先将一切待排序的记录体系分割成为若干子连串分别开展直接插入排序,待一切体系中的记录“基本不变”时,再对整个记录进行逐一间接插入排序。

     arr[i] = target;

1. 算法步骤

     quick_sort(arr, left, i – 1);

拔取一个增量体系 t1,t2,……,tk,其中 ti > tj, tk = 1;

     quick_sort(arr, i + 1, right);

按增量连串个数 k,对队列进行 k 趟排序;

 }

每回排序,依据对应的增量 ti,将待排种类分割成几何长短为 m
的子种类,分别对各子表进行直接插入排序。仅增量因子为 1
时,整个体系作为一个表来处理,表长度即为整个体系的长短。

}

2. Python 代码完结

归并排序

defshellSort(arr):

算法原理

importmath

归并排序具体做事原理如下(假诺种类共有n个元素):

gap=1

将连串每相邻八个数字进行统一操作(merge),形成floor(n/2)个系列,排序后每个体系包括两个因素

while(gap < len(arr)/3):

将上述体系再度统一,形成floor(n/4)个连串,每个体系包罗多个要素

gap = gap*3+1

重复步骤2,直到所有因素排序已毕

whilegap >0:

归并排序是平静的排序算法,其时间复杂度为O(nlogn),倘诺是行使链表的落到实处的话,空间复杂度能够达到O(1),但借使是选拔数组来存储数据以来,在联合的经过中,需求暂时空间来储存归并好的数码,所以空间复杂度为O(n)

foriinrange(gap,len(arr)):

c++代码落成

temp = arr[i]

 void merge(int arr[], int temp_arr[], int start_index, int
mid_index, int end_index)

j = i-gap

 {

whilej >=0andarr[j] > temp:

     int i = start_index, j = mid_index + 1;

arr[j+gap]=arr[j]

     int k = 0;

j-=gap

     while (i < mid_index + 1 && j < end_index + 1)

arr[j+gap] = temp

     {

gap = math.floor(gap/3)

         if (arr[i] > arr[j])

returnarr

             temp_arr[k++] = arr[j++];

归并排序

         else

归并排序(Merge
sort)是创造在联合操作上的一种有效的排序算法。该算法是接纳分治法(Divide
and Conquer)的一个不胜非凡的使用。

             temp_arr[k++] = arr[i++];

用作一种典型的分而治之思想的算法应用,归并排序的兑现由两种办法:

     }

自上而下的递归(所有递归的章程都能够用迭代重写,所以就有了第 2
种艺术);

     while (i < mid_index + 1)

自下而上的迭代;

     {

在《数据结构与算法 JavaScript
描述》中,小编给出了自下而上的迭代方法。然则对于递归法,作者却以为:

         temp_arr[k++] = arr[i++];

However, it is not possible to do so in JavaScript, as the recursion
goes too deep for the language to handle.

     }

只是,在 JavaScript
中那种方法不太灵光,因为这几个算法的递归深度对它来讲太深了。

     while (j < end_index + 1)

说实话,我不太领会那句话。意思是 JavaScript
编译器内存太小,递归太深不难导致内存溢出吧?还望有大神可以指教。

         temp_arr[k++] = arr[j++];

和挑选排序一样,归并排序的习性不受输入数据的熏陶,但呈现比接纳排序好的多,因为一向都是
O(nlogn) 的小运复杂度。代价是内需非常的内存空间。

     for (i = 0, j = start_index; j < end_index + 1; i ++, j ++)

1. 算法步骤

         arr[j] = temp_arr[i];

报名空间,使其大小为五个曾经排序种类之和,该空间用来存放合并后的行列;

 }

设定三个指针,最初地点分别为三个已经排序种类的起第二地点;

 void merge_sort(int arr[], int temp_arr[], int start_index, int
end_index)

正如七个指针所针对的元素,选取绝对小的因素放入到联合空间,并活动指针到下一职位;

 {

再次步骤 3 直到某一指南针达到连串尾;

     if (start_index < end_index)

将另一连串剩下的有着因素间接复制到合并种类尾。

     {

2. 动图演示

         int mid_index = (start_index + end_index) / 2;

ca88亚洲城网站 5

         merge_sort(arr, temp_arr, start_index, mid_index);

3. Python 代码落成

         merge_sort(arr, temp_arr, mid_index + 1, end_index);

defmergeSort(arr):

         merge(arr, temp_arr, start_index, mid_index, end_index);

importmath

     }

if(len(arr)<2):

 }

returnarr

堆排序

middle = math.floor(len(arr)/2)

二叉堆

left, right = arr[0:middle], arr[middle:]

二叉堆是全然二叉树或者近似完全二叉树,满意四个特性

returnmerge(mergeSort(left), mergeSort(right))

父结点的键值总是凌驾或等于(小于或等于)任何一个子节点的键值

defmerge(left,right):

各类结点的左子树和右子树都是一个二叉堆

result = []

当父结点的键值总是凌驾或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。一般二叉树简称为堆。

whileleftandright:

堆的积存

ifleft[0] <= right[0]:

貌似都是数组来囤积堆,i结点的父结点下标就为(i – 1) /
2。它的左右子结点下标分别为2 * i + 1和2 * i +
2。如第0个结点左右子结点下标分别为1和2。存储结构如图所示:

result.append(left.pop(0));

堆结构.png

else:

堆排序原理

result.append(right.pop(0));

堆排序的命宫复杂度为O(nlogn)

whileleft:

算法原理(以最大堆为例)

result.append(left.pop(0));

先将开头数据R[1..n]建成一个最大堆,此堆为初阶的无序区

whileright:

再将首要字最大的记录R[1](即堆顶)和无序区的末尾一个记录R[n]沟通,因此赢得新的无序区R[1..n-1]和有序区R[n],且满足R[1..n-1].keys≤R[n].key

result.append(right.pop(0));

出于互换后新的根R[1]想必违反堆性质,故应将最近无序区R[1..n-1]调动为堆。

returnresult

重复2、3步骤,直到无序区唯有一个要素为止。

火速排序

c++代码落成

即刻排序是由东尼·霍尔所发展的一种排序算法。在平均处境下,排序 n 个项目要
Ο(nlogn) 次相比。在最坏现象下则须要 Ο(n2)
次相比较,但那种情景并不普遍。事实上,快捷排序平常显然比别的 Ο(nlogn)
算法更快,因为它的里边循环(inner
loop)可以在大部分的架构上很有功效地被已毕出来。

/**

高效排序使用分治法(Divide and
conquer)策略来把一个串行(list)分为四个子串行(sub-lists)。

* 将数组arr构建大根堆

敏捷排序又是一种分而治之思想在排序算法上的一级应用。本质上来看,火速排序应该算是在冒泡排序基础上的递归分治法。

* @param arr 待调整的数组

很快排序的名字起的是大致严酷,因为一听到这一个名字你就了然它存在的意义,就是快,而且功效高!它是处理大数据最快的排序算法之一了。虽然Worst Case 的日子复杂度达到了
O(n²),可是人家就是雅观,在一大半情景下都比平均时间复杂度为 O(n logn)
的排序算法表现要更好,不过那是怎么呢,我也不知晓。好在自家的性障碍又犯了,查了
N 多材料终于在《算法艺术与信息学竞技》上找到了满足的答案:

* @param i   待调整的数组元素的下标

快快排序的最坏运行情况是
O(n²),比如说顺序数列的快排。但它的摊派期望时间是 O(nlogn),且 O(nlogn)
记号中包蕴的常数因子很小,比复杂度稳定等于 O(nlogn)
的联结排序要小很多。所以,对半数以上顺序性较弱的任性数列而言,神速排序总是优于归并排序。

* @param len 数组的尺寸

1. 算法步骤

*/

从数列中挑出一个要素,称为 “基准”(pivot);

void heap_adjust(int arr[], int i, int len)

再也排序数列,所有因素比基准值小的摆放在基准前边,所有因素比基准值大的摆在基准的后边(相同的数可以到任一边)。在这么些分区退出之后,该规范就处于数列的中游地点。这些名叫分区(partition)操作;

{

递归地(recursive)把小于基准值元素的子数列和过量基准值元素的子数列排序;

   int child;

递归的最底部情况,是数列的高低是零或一,也就是恒久都曾经被排序好了。固然平素递归下去,不过那个算法总会脱离,因为在每一趟的迭代(iteration)中,它起码会把一个因素摆到它最后的职位去。

   int temp;

2. 动图演示

   for (; 2 * i + 1 < len; i = child)

ca88亚洲城网站 6

   {

3. Python 代码完结

       child = 2 * i + 1;  // 子结点的地点 = 2 * 父结点的义务 + 1

defquickSort(arr, left=None, right=None):

       // 得到子结点中键值较大的结点

left =0ifnotisinstance(left,(int, float))elseleft

       if (child < len – 1 && arr[child + 1] > arr[child])

right = len(arr)-1ifnotisinstance(right,(int, float))elseright

           child ++;

ifleft < right:

       //
如若较大的子结点大于父结点那么把较大的子结点往上运动,替换它的父结点

partitionIndex = partition(arr, left, right)

       if (arr[i] < arr[child])

quickSort(arr, left, partitionIndex-1)

       {

quickSort(arr, partitionIndex+1, right)

           temp = arr[i];

returnarr

           arr[i] = arr[child];

defpartition(arr, left, right):

           arr[child] = temp;

pivot = left

       }

index = pivot+1

       else

i = index

           break;

whilei <= right:

   }

ifarr[i] < arr[pivot]:

}

swap(arr, i, index)

/**

index+=1

* 堆排序算法

i+=1

*/

swap(arr,pivot,index-1)

void heap_sort(int arr[], int len)

returnindex-1

{

defswap(arr, i, j):

   int i;

arr[i], arr[j] = arr[j], arr[i]

   // 调整体系的前半片段元素,调整完事后第四个因素是连串的最大的因素

堆排序

   for (int i = len / 2 – 1; i >= 0; i–)

堆排序(Heapsort)是指利用堆那种数据结构所设计的一种排序算法。堆积是一个好像完全二叉树的构造,并还要满足堆积的属性:即子结点的键值或索引总是小于(或者超越)它的父节点。堆排序能够说是一种选择堆的定义来排序的精选排序。分为二种办法:

   {

大顶堆:每个节点的值都大于或等于其子节点的值,在堆排序算法中用来升序排列;

       heap_adjust(arr, i, len);

小顶堆:每个节点的值都自愧不如或等于其子节点的值,在堆排序算法中用于降序排列;

   }

堆排序的平均时间复杂度为 Ο(nlogn)。

   for (i = len – 1; i > 0; i–)

1. 算法步骤

   {

始建一个堆 H[0……n-1];

       //
将第1个要素与眼前最终一个因素沟通,保障当前的末段一个义务的元素都是昨日的这些队列中最大的

把堆首(最大值)和堆尾交流;

       int temp = arr[0];

把堆的尺寸减少 1,并调用
shift_down(0),目标是把新的数组顶端数据调整到相应地方;

       arr[0] = arr[i];

双重步骤 2,直到堆的尺寸为 1。

       arr[i] = temp;

. 动图演示2. 动图演示

       //
不断压缩调整heap的范围,每五次调整达成有限支撑第二个要素是时下连串的最大值

ca88亚洲城网站 7

       heap_adjust(arr, 0, i);

3. Python 代码落成

   }

defbuildMaxHeap(arr):

}

importmath

未完待续

foriinrange(math.floor(len(arr)/2),-1,-1):

heapify(arr,i)

defheapify(arr, i):

left =2*i+1

right =2*i+2

largest = i

ifleft < arrLenandarr[left] > arr[largest]:

largest = left

ifright < arrLenandarr[right] > arr[largest]:

largest = right

iflargest != i:

swap(arr, i, largest)

heapify(arr, largest)

defswap(arr, i, j):

arr[i], arr[j] = arr[j], arr[i]

defheapSort(arr):

globalarrLen

arrLen = len(arr)

buildMaxHeap(arr)

foriinrange(len(arr)-1,0,-1):

swap(arr,0,i)

arrLen -=1

heapify(arr,0)

returnarr

计数排序

计数排序的主目的在于于将输入的数据值转化为键存储在附加开辟的数组空间中。作为一种线性时间复杂度的排序,计数排序需求输入的数据必须是有确定限制的整数。

ca88亚洲城网站 8

2. Python 代码已毕

defcountingSort(arr, maxValue):

bucketLen = maxValue+1

bucket = [0]*bucketLen

sortedIndex =0

arrLen = len(arr)

foriinrange(arrLen):

ifnotbucket[arr[i]]:

bucket[arr[i]]=0

bucket[arr[i]]+=1

forjinrange(bucketLen):

whilebucket[j]>0:

arr[sortedIndex] = j

sortedIndex+=1

bucket[j]-=1

returnarr

桶排序

桶排序是计数排序的升级版。它应用了函数的映射关系,高效与否的第一就在于那一个映射函数的确定。为了使桶排序越发急迅,大家必要形成那两点:

ca88亚洲城网站,在附加空间充足的气象下,尽量增大桶的多寡

动用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

而且,对于桶中元素的排序,选取何种相比较排序算法对于性能的影响重大。

1. 怎么样时候最快

当输入的数码可以均匀的分红到每一个桶中。

2. 哪些时候最慢

当输入的数量被分配到了同一个桶中。

基数排序

基数排序是一种非比较型整数排序算法,其规律是将整数按位数切割成分歧的数字,然后按每个位数分别相比较。由于整数也足以发挥字符串(比如名字或日期)和一定格式的浮点数,所以基数排序也不是只可以接纳于整数。

1. 基数排序 vs 计数排序 vs 桶排序

基数排序有二种格局:

这三种排序算法都选用了桶的定义,但对桶的行使方法上有鲜明差别:

基数排序:根据键值的每位数字来分配桶;

计数排序:每个桶只存储单一键值;

桶排序:每个桶存储一定限制的数值;

2. LSD 基数排序动图演示

ca88亚洲城网站 9

(完)

相关文章