Javascript实现的常用算法（如冒泡、快速、鸽巢、奇偶等）

l=[6,2,4,1,98,34,5,9,23,8,10,32]

       
//冒泡排序
/*functionbubbleSort(arr){
    newarr=arr.slice()
    if(newarr.length<=2)returnnewarr
    for(vari=0;i<newarr.length-1;i++){
        for(varj=0;j<newarr.length-i-1;j++){
            if(newarr[j]>newarr[j+1]){
                newarr[j]=[newarr[j+1],newarr[j+1]=newarr[j]][0]

            }
        }
    }
    returnnewarr
}

console.log(l)
result=bubbleSort(l)
console.log(result)*/

       
//快速排序
/*functionquickSort(arr){
    if(arr.length<=1)returnarr;
    varleft=[],
        right=[],
        middle=[];
    varmid=arr[Math.floor(arr.length/2)]
    for(vari=0;i<arr.length;i++){
        if(arr[i]<mid){
            left.push(arr[i]);
        }elseif(arr[i]>mid){
            right.push(arr[i]);
        }else{
            middle.push(mid);
        }
    }
    return[].concat(quickSort(left),middle,quickSort(right))

}

varresults=quickSort(l)
console.log(results)

       
*/

//选择排序
/*functionselectSort(arr){
    varmin=9999,
        minindex=0;
    varleft=[],
        right=arr.slice();
    if(arr.length<=1)returnarr;
    for(vari=0;i<arr.length;i++){
        if(arr[i]<=min){
            min=arr[i];
            minindex=i;
        }
    }
    left.push(min);   
    right.splice(minindex,1);
    return[].concat(left,selectSort(right))
}

       
varresults=selectSort(l)
console.log(results)*/

       
//插入排序
/*functioninsertSort(arr){
    vartmp;
    for(vari=1;i<arr.length;i++){
        tmp=arr[i];
        for(varj=i;j>0;j--){
            if(arr[j-1]>tmp){
                arr[j]=arr[j-1];
            }else{
                break;
            }
        }
        arr[j]=tmp;
    }
    returnarr;
}

varresults=insertSort(l)
console.log(results)*/

//木桶排序
/*functionbucketSort(arr){
    varbucket=[];
    varnewarr=[];
    for(vari=0;i<arr.length;i++){
        bucket[arr[i]]=arr[i];
    }
    for(vari=0;i<bucket.length;i++){
        if(bucket[i]!==undefined){
            newarr.push(bucket[i])
        }
    }
    returnnewarr;
}

varresults=bucketSort(l)
console.log(results)*/

//鸽巢排序,非负整数
/*functionpigeonholeSort(arr){
    vartempArr=[];
    for(vari=0,l=arr.length;i<l;i++){
        tempArr[arr[i]]=(tempArr[arr[i]]+1)||1;
    }

    varresult=[],count;
    for(vark=0;k<tempArr.length;k++){
        count=tempArr[k];
        if(count){
            for(vari=0;i<count;i++){
                result.push(k);
            }
        }     
    }

    returnresult;   
}

varresults=pigeonholeSort(l)
console.log(results)*/

//归并排序
/*functionmergeSort(arr){
    if(arr.length<=1)returnarr;
    varmid=Math.floor(arr.length/2);
    varleft=MergeSort(arr.slice(0,mid));
    varright=MergeSort(arr.slice(mid));
    varresult=[];

    while(left.length&&right.length){
        if(left[left.length-1]<=right[0]){
            result=result.concat(left);
            left=[];
        }elseif(right[right.length-1]<left[0]){
            result=result.concat(right);
            right=[];
        }else{
            if(right[0]<left[0]){
                result.push(right.shift());
            }else{
                result.push(left.shift());
            }
        }
    }
    result=result.concat(left,right);

    returnresult;
}*/

       

/*functionmergeSort(arr){
    varmerge=function(left,right){
        varresult=[];
        while(left.length>0&&right.length>0){
            if(left[0]<right[0]){
                result.push(left.shift());
            }else{
                result.push(right.shift());
            }
        }
        returnresult.concat(left).concat(right);
    }

    if(arr.length==1)returnarr;
    varmiddle=Math.floor(arr.length/2),
        left=arr.slice(0,middle),
        right=arr.slice(middle);
    returnmerge(mergeSort(left),mergeSort(right));
}

varresults=mergeSort(l)
console.log(results)

*/

       
//堆排序

/*functionheapSort(arr){
    varfindRoot=function(arr,p,length){
        p=p||0;
        length=length||arr.length;
        varself=arguments.callee;
        varl=p*2+1;
        varr=(p+1)*2;
        varleft,right;

        if(l<length)left=self(arr,l,length);
        if(r<length)right=self(arr,r,length);
        if(left>arr[p])arr[p]=[left,arr[l]=arr[p]][0];
        if(right>arr[p])arr[p]=[right,arr[r]=arr[p]][0];

        returnarr[p];
    };

       
    for(vari=arr.length;i>0;i--){
        findRoot(arr,0,i);
        arr[i-1]=[arr[0],arr[0]=arr[i-1]][0];
    }
    returnarr;
}

varresults=heapSort(l)
console.log(results)*/

       

//奇偶排列

/*functionoddEvenSort(arr){
    varswaped=true,
        k=0;
    while(swaped){
        if(k>0)swaped=false;

        for(vari=k;i<arr.length-1;i+=2){
            if(arr[i]>arr[i+1]){
                arr[i]=[arr[i+1],arr[i+1]=arr[i]][0];
                swaped=true;
            }
        }
        k=[1,0][k]
    }
    returnarr;
}

varresults=oddEvenSort(l)
console.log(results)*/

functionoddEvenSort(arr){
    varswaped=true;
    while(swaped){
        swaped=false;
        for(vari=0;i<arr.length;i+=2){
            if(arr[i]>arr[i+1]){
                arr[i]=[arr[i+1],arr[i+1]=arr[i]][0];
                swaped=true;
            }
        }
        for(vari=1;i<arr.length;i+=2){
            if(arr[i]>arr[i+1]){
                arr[i]=[arr[i+1],arr[i+1]=arr[i]][0];
                swaped=true;
            }
        }
    }
    returnarr;
}

varresults=oddEvenSort(l)
console.log(results)