输入十个数进行排序_十大经典排序算法(Javascript描述)

“本文13906字，阅读大约需要35分钟。”

---

这世界上总存在着那么一些看似相似但有完全不同的东西，比如雷锋和雷峰塔，小平和小平头，玛丽和马里奥，Java和Javascript....当年Javascript为了抱Java大腿恬不知耻的让自己变成了Java的干儿子，哦，不是应该是跪舔，毕竟都跟了Java的姓了。可如今，Javascript来了个咸鱼翻身，几乎要统治web领域，Nodejs，React Native的出现使得Javascript在后端和移动端都开始占有了一席之地。可以这么说,在Web的江湖， JavaScript可谓风头无两，已经坐上了头把交椅。

排序算法说明

(1)排序的定义：对一序列对象根据某个关键字进行排序；

输入：n个数：a1,a2,a3,...,an；

输出：n个数的排列:a1',a2',a3',...,an'，使得a1'<=a2'<=a3'<=...<=an'。

再讲的形象点就是排排坐，调座位，高的站在后面，矮的站在前面咯。

(2)对于评述算法优劣术语的说明

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面;

不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面;

内排序：所有排序操作都在内存中完成;

外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行;

时间复杂度: 定性描述算法的运行时间的函数;

空间复杂度: 运行完一个程序所需内存的大小;

(3)排序算法图片总结(图片来源于网络):

排序对比：

图片名词解释：

n:  数据规模；

k: “桶”的个数；

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

Out-place:  占用额外内存

排序分类：

排序分类：

1.冒泡排序(Bubble Sort)

好的，开始总结第一个排序算法，冒泡排序。 我想对于它每个学过C语言的都会了解的吧，这可能是很多人接触的第一个排序算法

(1)算法描述

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

(2)算法描述和实现

具体算法描述如下：

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

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

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

<4>.重复步骤1~3，直到排序完成。

JavaScript代码实现：

function bubbleSort(arr) {
        var len = arr.length;    for (var i = 0; i < len; i++) {
            for (var j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {        //相邻元素两两对比                var temp = arr[j+1];        //元素交换                arr[j+1] = arr[j];                arr[j] = temp;            }        }    }    return arr;}var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];console.log(bubbleSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

改进冒泡排序: 设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

改进后算法如下:

function bubbleSort2(arr) {
        console.time('改进后冒泡排序耗时');    var i = arr.length-1;  //初始时,最后位置保持不变    while ( i> 0) {
            var pos= 0; //每趟开始时,无记录交换        for (var j= 0; j< i; j++)            if (arr[j]> arr[j+1]) {
                    pos= j; //记录交换的位置                var tmp = arr[j]; arr[j]=arr[j+1];arr[j+1]=tmp;            }        i= pos; //为下一趟排序作准备     }     console.timeEnd('改进后冒泡排序耗时');     return arr;}var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];console.log(bubbleSort2(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

改进后的算法实现为:

function bubbleSort3(arr3) {
        var low = 0;    var high= arr.length-1; //设置变量的初始值    var tmp,j;    console.time('2.改进后冒泡排序耗时');    while (low < high) {
            for (j= low; j< high; ++j) //正向冒泡,找到最大者            if (arr[j]> arr[j+1]) {
                    tmp = arr[j]; arr[j]=arr[j+1];arr[j+1]=tmp;            }        --high;                 //修改high值, 前移一位        for (j=high; j>low; --j) //反向冒泡,找到最小者            if (arr[j]-1]) {
                    tmp = arr[j]; arr[j]=arr[j-1];arr[j-1]=tmp;            }        ++low;                  //修改low值,后移一位    }    console.timeEnd('2.改进后冒泡排序耗时');    return arr3;}var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];console.log(bubbleSort3(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

三种方法耗时对比：

由图可以看出改进后的冒泡排序明显的耗时更短了。读者自行尝试可以去g