排序算法 JavaScript

    //冒泡排序
    sort(elements){
        for (let i = 0; i < elements.length - 1; i++){
            for(let j = 0; j < elements.length - 1 - i; j++){
                if(elements[j] < elements[j + 1]){
                    let temp = elements[j];
                    elements[j] = elements[j + 1];
                    elements[j + 1] = temp;
                }
            }
        }
        console.log(elements);
    }
    //快速排序
    quickSort(elements){
        if (elements.length <= 1 ){
            return elements;
        }
        var mid = Math.floor(elements.length / 2);
        var val = elements[mid];
    
        var left = [];
        var right = [];
        for (let i = 0; i <elements.length; i++){
            if (elements[i] > val){
                right.push(elements[i]);
            }else if(elements[i] < val){
                left.push(elements[i]);
            }
        }
        // concat() 方法用于连接两个或多个数组。此方法返回一个新数组，不改变原来的数组。
        // arrayObject.concat(array1,array2,...,arrayN)
        return this.quickSort(left).conact([val], this.quickSort(right));
    }


    //快速排序  
    quick_sort(s, start , end )  
    {  
        if (start < end)  
        {  
            //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1  
            var i = start , j = end , x = s[start];  
            while (i < j)  
            {  
                while(i < j && s[j] >= x) // 从右向左找第一个小于x的数  
                    j--;    
                if(i < j)   
                    s[i++] = s[j];  
                
                while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数  
                    i++;    
                if(i < j)   
                    s[j--] = s[i];  
            }  
            s[i] = x;  
            this.quick_sort(s, start, i - 1); // 递归调用   
            this.quick_sort(s, i + 1, end );  
        }  
    }  
    //插入排序
    insertSort(element){
        for (let i = 1; i < element.length; i++){
            // 如果i的值比i-1大，那就不需要排序了
            if (element[i] < element[i - 1]){
                let startJ = i - 1;
                let keyVal = element[i];
    
                //由于keyVal小于element[startJ]，那么把关键字element[startJ]往后移动一个位置
                while (startJ >= 0 && keyVal < element[startJ]){
                    element[startJ + 1] = element[startJ];
                    startJ--;
                }
                element[startJ + 1] = keyVal;
            }
        }
    }

    //哈希排序
    shellSort(elements)
    {
        if (elements.length==0)
        {
            return;
        }
        let len = elements.length;
        let step =  Math.floor(elements.length/2); 
        while(step>0)
        {

            for (let i= step;i<elements.length;i++){
                let j = i;
                while(j >= step && elements[j] < elements[j-step])
                {
                    var temp = elements[j];
                    elements[j] = elements[j-step];
                    elements[j-step] = temp;
                    j -=step;
                }
            }
            step=Math.floor(step/2);
        }
    }