常常說起的幾個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])
複製代碼

流程圖

未完待續……