阅读 533

十大经典排序算法(Python版本 和 JavaScript版本)

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

排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序

是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。常见的内

部排序算法有:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、

基数排序等。用一张图概括:


关于时间复杂度:

  1. 平方阶 (O(n2)) 排序 各类简单排序:直接插入、直接选择和冒泡排序。

  2. 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序;

  3. O(n1+§)) 排序,§ 是介于 0 和 1 之间的常数。希尔排序

  4. 线性阶 (O(n)) 排序 基数排序,此外还有桶、箱排序。

关于稳定性:

  • 排序后 2 个相等键值的顺序和排序之前它们的顺序相同

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

  • 不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序。

名词解释:

n:数据规模

k:“桶”的个数

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

Out-place:占用额外内存


(一)python版本

1、冒泡排序

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

作为最简单的排序算法之一,冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样,每次都在第一页第一位,所以最熟悉。冒泡排序还有一种优化算法,就是立一个 flag,当在一趟序列遍历中元素没有发生交换,则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

(1)算法步骤

  1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。

  2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

  3. 针对所有的元素重复以上的步骤,除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

(2)动图演示

(3)Python 代码

def bubbleSort(arr):    
    for i in range(1, len(arr)):        
        for j in range(0, len(arr)-i):            
            if arr[j] > arr[j+1]:                
                arr[j], arr[j + 1] = arr[j + 1], arr[j]    
    return arr复制代码


2、选择排序

选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

(1)算法步骤

  1. 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置

  2. 再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

  3. 重复第二步,直到所有元素均排序完毕。

(2)动图演示

(3)Python 代码

def selectionSort(arr):    
    for i in range(len(arr) - 1):        
        # 记录最小数的索引        
        minIndex = i        
    for j in range(i + 1, len(arr)):            
        if arr[j] < arr[minIndex]:                
            minIndex = j        
    # i 不是最小数时,将 i 和最小数进行交换        
    if i != minIndex:            
        arr[i], arr[minIndex] = arr[minIndex], arr[i]    
    return arr复制代码


3、插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴,但它的原理应该是最容易理解的了,因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法,它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

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

(1)算法步骤

  1. 将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。

  2. 从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)

(2)动图演示

(3)Python 代码

def insertionSort(arr):    
    for i in range(len(arr)):        
        preIndex = i-1        
        current = arr[i]        
        while preIndex >= 0 and arr[preIndex] > current:            
            arr[preIndex+1] = arr[preIndex]            
            preIndex-=1        
        arr[preIndex+1] = current    
    return arr复制代码


4、希尔排序

希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的:

  • 插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率;

  • 但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位;

希尔排序的基本思想是:先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行依次直接插入排序。

(1)算法步骤

  1. 选择一个增量序列 t1,t2,……,tk,其中 ti > tj, tk = 1;

  2. 按增量序列个数 k,对序列进行 k 趟排序;

  3. 每趟排序,根据对应的增量 ti,将待排序列分割成若干长度为 m 的子序列,分别对各子表进行直接插入排序。仅增量因子为 1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。

(2)Python 代码

def shellSort(arr):    
    import math    
    gap=1    
    while(gap < len(arr)/3):        
        gap = gap*3+1    
    while gap > 0:        
        for i in range(gap,len(arr)):            
            temp = arr[i]            
            j = i-gap            
            while j >=0 and arr[j] > temp:                
                arr[j+gap]=arr[j]                
                j-=gap            
            arr[j+gap] = temp        
        gap = math.floor(gap/3)    
    return arr}复制代码

5、归并排序

归并排序(Merge sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

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

  • 自上而下的递归(所有递归的方法都可以用迭代重写,所以就有了第 2 种方法);

  • 自下而上的迭代;

和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。

(1)算法步骤

  1. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;

  2. 设定两个指针,最初位置分别为两个已经排序序列的起始位置;

  3. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;

  4. 重复步骤 3 直到某一指针达到序列尾;

  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

(2)动图演示

(3)Python 代码

def mergeSort(arr):    
    import math    
    if(len(arr)<2):        
        return arr    
    middle = math.floor(len(arr)/2)    
    left, right = arr[0:middle], arr[middle:]    
    return merge(mergeSort(left), mergeSort(right))

def merge(left,right):    
    result = []    
    while left and right:        
        if left[0] <= right[0]:            
            result.append(left.pop(0));        
        else:            
            result.append(right.pop(0));    
    while left:        
        result.append(left.pop(0));    
    while right:        
        result.append(right.pop(0));    
    return result复制代码


6、快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较,但这种状况并不常见。事实上,快速排序通常明显比其他 Ο(nlogn) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。

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

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

快速排序的名字起的是简单粗暴,因为一听到这个名字你就知道它存在的意义,就是快,而且效率高!它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 O(n²),但是人家就是优秀,在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好,可是这是为什么呢,我也不知道。好在我的强迫症又犯了,查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案:


快速排序的最坏运行情况是 O(n²),比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn),且 O(nlogn) 记号中隐含的常数因子很小,比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以,对绝大多数顺序性较弱的随机数列而言,快速排序总是优于归并排序。

(1)算法步骤

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

  2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;

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

递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会退出,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。

(2)动图演示

(3)Python 代码

def quickSort(arr, left=None, right=None):    
    left = 0 if not isinstance(left,(int, float)) else left   
    right = len(arr)-1 if not isinstance(right,(int, float)) else right    
    if left < right:        
        partitionIndex = partition(arr, left, right)       
        quickSort(arr, left, partitionIndex-1)        
        quickSort(arr, partitionIndex+1, right)    
    return arr

def partition(arr, left, right):    
    pivot = left    
    index = pivot+1    
    i = index    
    while  i <= right:        
        if arr[i] < arr[pivot]:            
            swap(arr, i, index)            
            index+=1        
        i+=1    
    swap(arr,pivot,index-1)    
    return index-1

def swap(arr, i, j):    
    arr[i], arr[j] = arr[j], arr[i]复制代码


7、堆排序

堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法:

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

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

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

(1)算法步骤

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

  2. 把堆首(最大值)和堆尾互换;

  3. 把堆的尺寸缩小 1,并调用 shift_down(0),目的是把新的数组顶端数据调整到相应位置;

  4. 重复步骤 2,直到堆的尺寸为 1。

(2)动图演示

(3)Python 代码

def buildMaxHeap(arr):    
    import math    
    for i in range(math.floor(len(arr)/2),-1,-1):        
        heapify(arr,i)

def heapify(arr, i):    
    left = 2*i+1    
    right = 2*i+2    
    largest = i    
    if left < arrLen and arr[left] > arr[largest]:        
        largest = left    
    if right < arrLen and arr[right] > arr[largest]:        
        largest = right    
    if largest != i:        
        swap(arr, i, largest)        
        heapify(arr, largest)

def swap(arr, i, j):    
    arr[i], arr[j] = arr[j], arr[i]

def heapSort(arr):    
    global arrLen    
    arrLen = len(arr)    
    buildMaxHeap(arr)    
    for i in range(len(arr)-1,0,-1):        
        swap(arr,0,i)        
        arrLen -=1        
        heapify(arr, 0)    
    return arr复制代码


8、计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。

(1)动图演示

(2)Python 代码

def countingSort(arr, maxValue):    
    bucketLen = maxValue+1    
    bucket = [0]*bucketLen    
    sortedIndex =0    
    arrLen = len(arr)    
    for i in range(arrLen):        
        if not bucket[arr[i]]:            
            bucket[arr[i]]=0        
        bucket[arr[i]]+=1    
    for j in range(bucketLen):        
        while bucket[j]>0:           
            arr[sortedIndex] = j            
            sortedIndex+=1            
            bucket[j]-=1    
    return arr复制代码


9、桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效,我们需要做到这两点:

  1. 在额外空间充足的情况下,尽量增大桶的数量

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

同时,对于桶中元素的排序,选择何种比较排序算法对于性能的影响至关重要。

什么时候最快

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

什么时候最慢

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

Python 代码

def bucket_sort(s):    
    """桶排序"""    
    min_num = min(s)    
    max_num = max(s)    
    # 桶的大小    
    bucket_range = (max_num-min_num) / len(s)    
    # 桶数组    
    count_list = [ [] for i in range(len(s) + 1)]    
    # 向桶数组填数    
    for i in s:        
        count_list[int((i-min_num)//bucket_range)].append(i)    
    s.clear()    
    # 回填,这里桶内部排序直接调用了sorted    
    for i in count_list:        
        for j in sorted(i):            
            s.append(j)

if __name__ == __main__ :    
    a = [3.2,6,8,4,2,6,7,3]    
    bucket_sort(a)    
    print(a) # [2, 3, 3.2, 4, 6, 6, 7, 8]复制代码


10、基数排序

基数排序是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。

(1)基数排序 vs 计数排序 vs 桶排序

基数排序有两种方法:

这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:

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

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

  • 桶排序:每个桶存储一定范围的数值;

(2)动图演示

(3)Python 代码

def RadixSort(list):    
    i = 0            #初始为个位排序    
    n = 1            #最小的位数置为1(包含0)    
    max_num = max(list) #得到带排序数组中最大数    
    while max_num > 10**n: #得到最大数是几位数        
        n += 1    
    while i < n:        
        bucket = {} #用字典构建桶        
        for x in range(10):            
            bucket.setdefault(x, []) #将每个桶置空        
        for x in list: #对每一位进行排序            
            radix =int((x / (10**i)) % 10) #得到每位的基数            
            bucket[radix].append(x) #将对应的数组元素加入到相 #应位基数的桶中        
        j = 0        
        for k in range(10):            
            if len(bucket[k]) != 0: #若桶不为空                
                for y in bucket[k]: #将该桶中每个元素                    
                    list[j] = y #放回到数组中                    
                        j += 1        
                        i += 1
    return  list复制代码



(二)JavaScript版本

1、 冒泡排序法

解析:1.比较相邻的两个元素,如果前一个比后一个大,则交换位置。

   2.第一轮的时候最后一个元素应该是最大的一个。

   3.按照步骤一的方法进行相邻两个元素的比较,这个时候由于最后一个元素已经是最大的了,所以最后一个元素不用比较)(所以减 i )。

var arr=[7,20,3,8,4,9,4,0,-4,1]        
function sort(elements){            
    for(var i=0;i<elements.length-1;i++){                
        for(var j=0;j<elements.length-i-1;j++){                    
            if(elements[j]>elements[j+1]){                        
                var swap=elements[j];                        
                elements[j]=elements[j+1];                        
                elements[j+1]=swap;                    
            }                
        }            
    }        
}         
console.log("before:"+arr)//before:[7,20,3,8,4,9,4,0,-4,1] 
sort(arr);        
console.log("after:"+arr) //after:-4,0,1,3,4,4,7,8,9,20复制代码

二维数组使用冒泡排序

var arr=[["北京",80],["上海",50],["福州",10],["广州",50],["成都",70],["西安",100]];
var t;
for(var i=0;i<arr.length;i++){    
    for(var j=0;j<arr.length-1;j++){        
        if(arr[j][1]>arr[j+1][1]){            
            t=arr[j][1];            
            arr[j][1]=arr[j+1][1];            
            arr[j+1][1]=t;        
        }    
    }
}
console.log(arr);  
//["福州",10],["上海",50],["广州",50],["成都",70],["北京",80],["西安",100]复制代码

冒泡排序动图:


2、选择排序法

相对于冒泡排序还有一种类似的方法就是选择排序,顾名思义就是选择性排序,什么意思呢?
这么来理解,假设在三伏天有一趟室内游泳课,教练说了先在露天场地等着,从你们当中先选取最大个先进去,然后再从剩余的人中选择最大个进去,依次类推。那么小个的就在想了,教练你TMD的脑子是不是被驴踢了。但是如果是冒泡排序那更有意思了,所有的人先排好队再进去,这样还好一点最起码每个人的心理能平衡一点。简单理解选择排序就是从一个未知数据空间,选取数据之最放到一个新的空间。
废话不多说,看例子:

var array = [1,4,-8,-3,6,12,9,8];        
function selectSort(arr){            
    for(var i=0;i<arr.length;i++){                
    //设置当前范围最小值和索引                
    var min = arr[i];             
    var minIndex = i;                
    //在该范围选出最小值                
        for(var j=i+1;j<arr.length;j++){                    
            if(min>arr[j]){                       
                min = arr[j];                       
                minIndex = j;                    
            }                
        }                
    //将最小值插入,并将原来位置的最小值删除                
    arr.splice(i,0,min);                
    arr.splice(minIndex+1,1);            
    }        
}        
selectSort(array);        
document.write(array);复制代码

  • (1)在未排序序列中找到最小(大)元素
  • (2)并存放到排序序列的起始位置
  • (3)然后,再从剩余未排序元素中继续寻找最小(大)元素
  • (4)然后放到已排序序列的末尾。
  • (5)以此类推

选择排序动图


3、插入排序法

(1) 从第一个元素开始,该元素可以认为已经被排序

(2) 取出下一个元素,在已经排序的元素序列中从后向前扫描

(3) 如果该元素(已排序)大于新元素,将该元素移到下一位置

(4) 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置

(5)将新元素插入到下一位置中

(6) 重复步骤2

var array = [1,4,-8,-3,6,12,9,8];        
function insertSort(arr){
//假设第0元素是有序序列,第1元素之后是无序的序列。从第1元素开始依次将无序序列的元素插入到有序序列中      
    for(var i=1; i<arr.length;i++){
        if(arr[i]<arr[i-1]){    
            //取出无序序列中需要插入的第i个元素       
            var temp = arr[i];                    
            //定义有序中的最后一个位置                    
            var j = i-1;                    
            arr[i] = arr[j];                                     
            while(j>=0 && temp<arr[j]){ //比较大小,找到插入的位置
                arr[j+1] = arr[j];                        
                j--;                   
            };                                       
           arr[j+1] = temp; //插入             
       }            
    }        
}        
insertSort(array)       
 console.log(array);复制代码

插入排序动图

4、希尔排序法

function shellSort(arr) {  
    var len = arr.length, temp, gap = 1;  
    console.time('希尔排序耗时:');  
    while(gap < len/5) { //动态定义间隔序列    
        gap =gap*5+1;  
    }  
    for (gap; gap > 0; gap = Math.floor(gap/5)) {    
        for (var i = gap; i < len; i++) {      
            temp = arr[i];      
            for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {        
                arr[j+gap] = arr[j];      
            }      
            arr[j+gap] = temp;    
        }  
    }  
    console.timeEnd('希尔排序耗时:');  
    return arr;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(shellSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50];复制代码
当读到while循环时,我类个去,什么鬼?什么意思?再往下读,好了,放弃吧!看起来云里雾里,变量附来附去,什么意思?
抽象看不明白那就实例化,以arr为例代进去一看究竟,len/5 以五步为增量,这好像是说的通,但是gap = gap *5 +1 ;这是什么鬼?
别着急慢慢读,len = 15 ,gap = 6 ;while循环结束。再往下读,var i = gap ;也就是说从i = 6开始循环一直到数组末尾,然后从i=6开始记录元素,而对于下标为 j 的for循环,则是从0开始,然后以步长为6开始比较,接下来就会发现一个问题,j-=gap ? 又是什么鬼? j=0,j-=gap ,那 j 不就是负的了么?编者这么写是有他的理由的,对,在下标为6之前的元素之循环了一次,那下边如果超过6呢,所以小编觉得这个地方也算是个亮点吧!
还没结束,这层内层循环结束了,跳了出来,gap = Math.floor(gap/5) 又是什么玩意?只是常规的思想局限了创新,这个不就是与while循环的gap = gap *5+1 ;与之相应么?这么做有什么好处呢,也就是说无论数据有多大,最终肯定会走到每隔6步为已增量的循环中,这就是希尔排序的亮点所在,而且前面定义的gap=1;还有gap = gap*5+1 ;这个1不是随便定义的,因为最终回归到的就是增量为1的循环当中!

5、归并排序法

归并排序其实可以类比二分法,二分法其实就是二等分的意思,简而言之就是不断和新序列的中间值进行比较。归并排序似乎有异曲同工之妙,什么意思呢,就是将一个原始序对等分为两部分,然后不断地对等分新的序列,直至序列的长度为1或者2,那么想,如果一个序列为1,那就没有比较的意义了,它本身就是之最,如果是两个呢,那直接比较不就完了,把比较之后的值推送到一个新的数组。就这样不断地细分,不断的产生子序列,然后把穿产生的新序列作为新的父序列,然后同等级的父序列再比较产生新的祖序列,依次类推。
有点抽象了,那就具体化,比如现在有个十万人的司令部,习大大是首长,习大大跟司令说了,把所有的人按年龄排序,司令想了,让我一个人也忙活不过来啊,这怎么办,然后就把任务下达给军长,军长下达给师长,依次类推,排长再把一个排分成两个小队,小队再分成两个小组,最后分成两个人一组或一人一组,接下来就是组员之间进行比较,完了小队与小队比较,排与排之间比较,依次类推,最后军团和军团比较,形成最后的序列。
废话不多说,看代码:

function mergeSort(arr) { //采用自上而下的递归方法  
    var len = arr.length;  
    if(len < 2) {    
        return arr;  
    }  
    var middle = Math.floor(len / 2),  left = arr.slice(0, middle),  right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
} 

function merge(left, right){  
    var result = [];  
    console.time('归并排序耗时');  
        while (left.length && right.length) {    
            if (left[0] <= right[0]) {      
                result.push(left.shift());    
            } else {      
                result.push(right.shift());    
            }  
    }   
    while (left.length){    
        result.push(left.shift());  
    }  
    while (right.length){    
        result.push(right.shift());  
    }  
    console.timeEnd('归并排序耗时');  
    return result;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(mergeSort(arr));复制代码

6、快速排序法

对冒泡排序的一种改进,第一趟排序时将数据分成两部分,一部分比另一部分的所有数据都要小。然后递归调用,在两边都实行快速排序。

var array = [1,4,-8,-3,6,12,9,8];
function quickSort(arr){
//如果数组长度小于等于1,则返回数组本身    
    if(arr.length<=1){        
        return arr;    
    }    
    var index = Math.floor(arr.length/2);  //定义中间值的索引    
    var temp = arr.splice(index,1); //取到中间值 
    //定义左右部分数组    
    var left = [];    
    var right = [];    
    for(var i=0;i<arr.length;i++){     
        //如果元素比中间值小,那么放在左边,否则放右边        
        if(arr[i]<temp){           
            left.push(arr[i]);        
        }else{            
            right.push(arr[i]);        
        }    
    }    
    return quickSort(left).concat(temp,quickSort(right));
}
console.log(quickSort(array));复制代码

Math.floor(x)方法是向下取整,返回小于或等于x的最接近的整数。

splice(index,num,item)方法是向数组中添加项目,或是从数组中删除项目,并返回被删除的项目。

  • index是整数,被操作项目所在的位置(必须)
  • num是整数,要删除的项目的数量,如果为0,表示不删除(必须)
  • item是向数组中添加的新项目,可以是多个(可选)

push()方法是向数组末尾添加一个或多个新项目并返回新数组的长度

concat()方法连接两个或多个数组,不会改变原有数组,返回一个新数组

快速排序动图


7、堆排序

这种排序方式呢,理论性太强,看动图的时候满脸写着懵逼,多看几遍似乎明白了编者的意图,但是要把这种理论的概念写成代码却不容易,且看代码:

function heapSort(array) {          
    console.time('堆排序耗时');          
    //建堆          
    var heapSize = array.length, temp;          
    for (var i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {              
        heapify(array, i, heapSize);          
    }          
    //堆排序          
    for (var j = heapSize - 1; j >= 1; j--) {            
        temp = array[0];            
        array[0] = array[j];            
        array[j] = temp;            
        heapify(array, 0, --heapSize);          
    }          
    console.timeEnd('堆排序耗时');          
    return array;        
}        
function heapify(arr, x, len) {          
    var l = 2 * x + 1, r = 2 * x + 2, largest = x, temp;          
    if (l < len && arr[l] > arr[largest]) {            
        largest = l;          
    }          
    if (r < len && arr[r] > arr[largest]) {            
        largest = r;          
    }          
    if (largest != x) {            
        temp = arr[x];            
        arr[x] = arr[largest];            
        arr[largest] = temp;            
        heapify(arr, largest, len);          
    }        
}        
var arr = [-26, 54, 25, 7, -21, 24, 68, 29, 16, 41, 87];        
console.log(heapSort(arr));复制代码


8、计数排序法

计数排序就是遍历数组记录数组下的元素出现过多次,然后把这个元素找个位置先安置下来,简单点说就是以原数组每个元素的值作为新数组的下标,而对应小标的新数组元素的值作为出现的次数,相当于是通过下标进行排序。

function countingSort(array) {          
    var len = array.length, B = [], C = [], min = max = array[0];          
    console.time('计数排序耗时');          
    for (var i = 0; i < len; i++) {            
        min = min <= array[i] ? min : array[i];            
        max = max >= array[i] ? max : array[i];            
        C[array[i]] = C[array[i]] ? C[array[i]] + 1 : 1;          
    }          
    // 计算排序后的元素下标          
    for (var j = min; j < max; j++) {            
        C[j + 1] = (C[j + 1] || 0) + (C[j] || 0);          
    }          
    for (var k = len - 1; k >= 0; k--) {            
        B[C[array[k]] - 1] = array[k];            
        C[array[k]]--;          
    }          
    console.timeEnd('计数排序耗时');          
    return B;        
}        
var arr = [-26, 54, 25, 7, -21, 24, 68, 29, 16, 41, 87];        
console.log(countingSort(arr)); 复制代码


9、桶排序

一看到这个名字就会觉得奇特,几个意思,我排序还要再准备几个桶不成?还真别说,想用桶排序还得真准备几个桶,但是此桶非彼桶,这个桶是用来装数据用的。其实桶排序和计数排序还有点类似,计数排序是找一个空数组把值作为下标找到其位置,再把出现的次数给存起来,这似乎看似很完美,但也有局限性,不用小编说相信读者也能明白,既然计数是把原数组的值当做下标来看待,那么该值必然是整数,那假如出现小数怎么办?这时候就出现了一种通用版的计数排序——桶排序。

我得桶排序可以这么理解,它是以步长为分隔,将最相近数据分隔在一起,然后再在一个桶里排序。好了,现在有个概念,步长是什么玩意?这么来说吧,比如在知道十位的情况下48和36有比较的必要吗?显然没有,十位就把你干下去了,还比什么?那在这里可以简单的把步长理解为10,桶排序就是这样,先把同一级别的分到一组,由同一级别的元素进行排序。

代码实现:

@param array 数组
@param num 桶的数量

function bucketSort(array, num) {          
    if (array.length <= 1) {            
        return array;          
    }          
    var len = array.length, buckets = [], result = [], min = max = array[0], space, n = 0;
    var index = Math.floor(len / num) ;          
    while(index<2){            
        num--;            
        index = Math.floor(len / num) ;          
    }          
    console.time('桶排序耗时');          
    for (var i = 1; i < len; i++) {            
        min = min <= array[i] ? min : array[i];            
        max = max >= array[i] ? max : array[i];          
    }          
    space = (max - min + 1) / num;  //步长          
    for (var j = 0; j < len; j++) {            
        var index = Math.floor((array[j] - min) / space);            
        if (buckets[index]) { // 非空桶,插入排序              
            var k = buckets[index].length - 1;              
            while (k >= 0 && buckets[index][k] > array[j]) {            
                buckets[index][k + 1] = buckets[index][k];                
                k--;              
            }              
            buckets[index][k + 1] = array[j];            
        } else { //空桶,初始化              
            buckets[index] = [];              
            buckets[index].push(array[j]);            
        }          
    }          
    while (n < num) {            
        result = result.concat(buckets[n]);            
            n++;          
    }          
    console.timeEnd('桶排序耗时');          
    return result;        
}       
var arr = [-26, 54, 25, 7, -21, 24, 68, 29, 16, 41, 87];   
console.log(bucketSort(arr,4));复制代码

但是这边有个坑点,就是桶的数量不能过多,也就说说至少两个桶!为什么?你试下就知道了!

附图理解: