经常提及的几个js排序方法（冒泡排序、选择排序、计数排序）

前言

一般来说，前端在算法方面接触的不多，除非是一些大公司，可能对此有要求，但是对于一个前端来说，了解一些基本的算法也是必需的，在遇到这方面的需求时，也不至于捉襟见肘，手足无措，今天来说说经常提及的几个算法，后续如有必要在补充。

冒泡排序

冒泡排序是最基本的排序，也是算法入门的第一个排序方法，比较简单，两两比较，值大的与值小的交换位置，经过一定循环次数后就能完成排序，相比其他排序方法，在面对较多数据时耗时最多。

平均时间复杂度：O(n^2)

最好情况：O(n)

最坏情况：O(n^2)

稳定性：稳定

伪代码：

“<-”表示赋值符号，
a<-{
    "0":7
    "1":5
    "2":4
    "3":3
    "4":2
    "length":5
}
//循环次数
n<-1
while(n<length)
    while(i<-0;i<length-n)
    if(a[i]>a[i+1])
        t<-a[i]
        a[i]<-a[i+1]
        a[i+1]<-t
        i<-i+1
        end
        n<-n+1
    end
    print a
    end
     
复制代码

js代码

function arr(a) {
            var j=a.length;
            n=1;
            for(n=1;n<j;n++){
            for(i=0;i<j-n;i++){
                if (a[i]>a[i+1]){
                    t=a[i];
                    a[i]=a[i+1];
                    a[i+1]=t;
                }
                
            }
           
        } console.log(a); 
        }
        arr([4,2,7,5,3,10,8,1,0,16])
复制代码

流程图

选择排序

选择排序首先从原始数组中找到最小的元素，并把该元素放在数组的最前面，然后再从剩下的元素中寻找最小的元素，放在之前最小元素的后面，直到排序完毕。

平均时间复杂度：O(n^2)

最好情况：O(n^2)

最坏情况：O(n^2)

稳定性：不稳定

伪代码

a<-{
    "0":7
    "1":5
    "2":4
    "3":3
    "4":2
    "length":5
}
n<-1//循环次数
while(n<length)
    minindex<-n-1
    index<-minindex+1
    while(index<length)
        if(a[minindex]>a[index])
        minindex<-index
        index<-index+1
    end
    n<-n+1
    end
    print a
    end
复制代码

js代码

function iarr(a){    
            for(var n=1;n<a.length;n++){
                var minindex=n-1;
                for(var index=minindex+1;index<a.length;index++){
                    if(a[minindex]>a[index]){
                        minindex=index;
                    }
                     
                }
                var t=a[n-1];
                    a[n-1]=a[minindex];
                    a[minindex]=t;
                     
            }
            console.log(a) 
        }
        iarr([4,2,7,5,3,10,8,1,0,16])
复制代码

计数排序

计数排序是用于确定范围的整数的线性时间排序算法,这一句话我们就可以知道计数排序该如何用了(注意：它只能使用在整数范围)

平均时间复杂度：O(n+k)

最好情况：O(n+k)

最坏情况：O(n+k)

稳定性：稳定

伪代码

a<-{
    "0":7
    "1":5
    "2":4
    "3":3
    "4":2
    "length":5
}
n<-1//循环次数
max<-n-1
index<-max+1
while(index<length)
  if(a[max]<a[index])//循环找出最大值max
    max<-index
    index<-index+1
    end
    t<-a[n-1]
    a[n-1]<-a[max]
    a[max]<-t
end
b<-{}//创建新数组，填充0
max<-a[0]
while(index2<max+1)
    b[index2]<-0
    index2<-index2+1
end
while(index2<length)//将a数组值依照出现次数放在对应的b数组中，
    b[a[index]]<-b[a[index]]+1
index2<-index2+1
end
b<-{
    "0":0
    "1":0
    "2":1
    "3":1
    "4":1
    "5":1
    "6":0
    "7":1
}
arr<-{}
index3<-0
while(index3<max+1)
    if(b[index3]>0)
    arr.push(index3)//将符合要求的值推入新数组arr
    b[index3]<-b[index3]-1
    index3<-index3+1
end
    print a
end

复制代码

js代码

function maths(arr){
        var j=arr.length;
        var orr=[];
        n=1;
        max=n-1;
        for(n=1;index<j;index++){
            if(arr[max]<arr[index]){
                max=index;

            }   
            var t=arr[n-1];
            arr[n-1]=arr[max]
            arr[max]=t;
        }
        max=arr[0];
            var B=[];
            for(var index2=0;index2<max+1;index2++){
                B[index2]=0;
            }
        for(index2=0;index2<j;index2++){
            B[arr[index2]]++

        }
        for(index3=0;index3<max+1;index3++){
            while (B[index3]>0) {
                orr.push(index3);
                B[index3]--;
            }
            
        }
        console.log(orr);  
}
maths([7,5,4,3,2])
复制代码

流程图

未完待续……

转载于:https://juejin.im/post/5c78db46f265da2d9d1cc3db