javascript 常用算法总结

　　算法是程序的灵魂。虽然在前端的开发环境中排序算法不是很经常用到，但常见的排序算法还是应该要掌握的。我在这里从网上整理了一下常见排序算法的javascript实现，方便以后查阅。

一、归并排序：

function merge(left, right){
var result  = [],
il      = 0,
ir      = 0;

while (il < left.length && ir < right.length){
if (left[il] < right[ir]){
result.push(left[il++]);
} else {
result.push(right[ir++]);
}
}

return result.concat(left.slice(il)).concat(right.slice(ir));
}

function mergeSort(items){
// 结束条件: 数组元素少于2个
if (items.length < 2) {
return items;
}

var middle = Math.floor(items.length / 2),
left   = items.slice(0, middle),
right  = items.slice(middle);

return merge(mergeSort(left), mergeSort(right));
}

function mergeSort2(items){
if (items.length < 2) {
return items;
}

var middle = Math.floor(items.length / 2),
left   = items.slice(0, middle),
right  = items.slice(middle),
params = merge(mergeSort(left), mergeSort(right));

params.unshift(0, items.length);
items.splice.apply(items, params);
return items;
}

二、插入排序：

function insertionSort(items) {
var len = items.length,
value,
i,
j;

for (i=0; i < len; i++) {
value = items[i];
for (j=i-1; j > -1 && items[j] > value; j--) {
items[j+1] = items[j];
}
items[j+1] = value;
}
return items;
}

三、选择排序：

function swap(items, firstIndex, secondIndex){
var temp = items[firstIndex];
items[firstIndex] = items[secondIndex];
items[secondIndex] = temp;
}

function selectionSort(items){
var len = items.length,
min;

for (i=0; i < len; i++){
min = i;
for (j=i+1; j < len; j++){
if (items[j] < items[min]){
min = j;
}
}

if (i != min){
swap(items, i, min);
}
}

return items;
}

四、冒泡排序：

function swap(items, firstIndex, secondIndex){
var temp = items[firstIndex];
items[firstIndex] = items[secondIndex];
items[secondIndex] = temp;
}

function bubbleSort(items){
var len = items.length,
i, j, stop;

for (i=0; i < len; i++){
for (j=0, stop=len-i; j < stop; j++){
if (items[j] > items[j+1]){
swap(items, j, j+1);
}
}
}

return items;
}

五、快速排序：

例：arr = [30, 19, 7, 59, 2, 16, 4]; 找出数组中间点为59，循环数组，如果小于59存储到left中，否则存储到right中，然后

var quickSort = function(arr) {
　　if (arr.length <= 1) { return arr; }
　　var pivotIndex = Math.floor(arr.length / 2);
　　var pivot = arr.splice(pivotIndex, 1)[0];
　　var left = [];
　　var right = [];
　　for (var i = 0; i < arr.length; i++){
　　　　if (arr[i] < pivot) {
　　　　　　left.push(arr[i]);
　　　　} else {
　　　　　　right.push(arr[i]);
　　　　}
　　}
　　return quickSort(left).concat([pivot], quickSort(right));
};

六、二分法查找：

function binarySearch(items, value){
var startIndex  = 0,
stopIndex   = items.length - 1,
middle      = Math.floor((stopIndex + startIndex)/2);

while(items[middle] != value && startIndex < stopIndex){

if (value < items[middle]){
stopIndex = middle - 1;
} else if (value > items[middle]){
startIndex = middle + 1;
}

middle = Math.floor((stopIndex + startIndex)/2);
}

return (items[middle] != value) ? -1 : middle;
}

七、基数排序：

var countSort = function(array) {
var i, z = 0, count = [],
min = Math.min.apply({}, array),
max = Math.max.apply({}, array),
size = array.length;
//给新数组预填为零
for (i = min; i <= max; i++) {
count[i] = 0;
}
for (i=0; i < size; i++) {
count[array[i]]++;
}

for (i = min; i <= max; i++) {
while (count[i]-- > 0) {//循环新数组，如果不为零，则把i返回array
array[z++] = i;
}
}
return array;
}

八、希尔排序：

function shellSort(array) {
var j, i, v, h=1, s=3, k,n = array.length;
var result = "";
var count = 0;
while(h < n)
h=s*h+1;

while(h > 1) {
h=(h-1)/s;
for (k=0; k<h; k++)
for (i=k+h,j=i; i<n; i+=h, j=i) {
v=array[i];
while(true)
if ((j-=h) >= 0 && array[j] > v)
array[j+h]=array[j];
else
break;
array[j+h]=v;

}
count++;
result += "<br />第" + count + "遍排序的结果是:";
for (var n = 0; n < array.length; n++) {
result += array
+ ",";
}
}
return result;
}

九、组合排序：

var combSort = function(array){
var gap = array.length;
do{
gap = gap * 10 / 13
if(gap === 9 || gap === 10)
gap = 11
if(gap < 1){
gap = 1
}
var swapped = false;
for(var i=0;i<array.length-gap;i++){
var j = i + gap
if(array[i]>array[j]){
var temp = array[i];
array[i] = array[j];
array[j] = temp;
test(array)
swapped = true
}
}
if(gap == 1 && !swapped){
break;
}
}while(1);
}

十、鸡尾酒排序：

var cocktailSort= function(array) {
var top = array.length - 1, bottom = 0,flag = true,i, j;
while (flag) {
flag = false;
//从左到右到大，把最大的放到每次范围的最右边
for (i = bottom; i < top; i++) {
if (array[i] > array[i + 1]) {
swap(array, i, i + 1);
flag = true;
}
}
top--;
//从右到到左，把最小的放到每次范围的最小边
for (j = top; j > bottom; j--) {
if (array[j] < array[j - 1]) {
swap(array, j, j - 1);
flag = true;
}
}
bottom++;
}
}

var swap = function(array,a,b){
var tmp = array[a];
array[a] = array
array[b] = tmp;
}

[b]二、js数组 sort方法的分析

　　javascript 中 Array.sort()方法是用来对数组项进行排序的 ，默认情况下是进行升序排列，实例代码如下：

var arrA = [6,2,4,3,5,1];
arrA.sort();
document.writeln(arrA);
　 //结果是：1,2,3,4,5,6

sort() 方法可以接受一个 方法为参数 ，这个方法有两个参数。分别代表每次排序比较时的两个数组项。sort()排序时每次比较两个数组项都回执行这个参数，并把两个比较的数组项作为参数传递给这个函数。当函数返回值为1的时候就交换两个数组项的顺序，否则就不交换。

实例如下：

var arrA = [6,2,4,3,5,1];
/*arrA.sort();
document.writeln(arrA);
*/

function desc(x,y)
{
if (x > y)
return -1;
if (x < y)
return 1;
}
function asc(x,y)
{
if (x > y)
return 1;
if (x < y)
return -1;
}

arrA.sort(desc);    // sort by desc
document.writeln(arrA);
document.writeln("<br>");
arrA.sort(asc);    //sort by asc
document.writeln(arrA);

　　//输出结果：

　　6,5,4,3,2,1
　　1,2,3,4,5,6

另外，可以直接把一个无名函数直接放到sort()方法的调用中。如下的例子是将奇数排在前面，偶数排在后面，例子如下：

var arrA = [6,2,4,3,5,1];
arrA.sort( function(x, y) {
if (x % 2 ==0)
return 11;
if (x % 2 !=0)
return -1;
}
);
document.writeln(arrA);

//输出：1,5,3,4,6,2

二、排列组合

从1-10的数中取出六个数字，能排列出多少组不同的顺序

C10 6公式：(1*2*3*4*5*6*7*8*9*10)/((1*2*3*4)*(1*2*3*4*5*6))

<script>
function arrangement(total, target){　　　　// @total：总的排列数　　@target：组合的总数
var nTotal = 1;
var nTarget = 1;
var nNum = 1;

for(var i=1; i<=total; i++){
nTotal *= i;
}

for(var k=1, tar=total-target; k<=tar; k++){
console.log(tar);
nTarget *= k;
}

for(var s=1; s<=target; s++){
nNum *= s;
}

console.log(nTotal,nTarget,nNum)

return nTotal/(nTarget*nNum);
}

var result = arrangement(16, 6);
console.log(result);
</script>

三、冒泡排序

原理：

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

　　用两个循环分别取出第一个数和第二个数，然后做比较如果小于或者大于就将通过一个变量将两个位置互换，并跳出循环，进行下一个数的比较

<script>
var arr = [2,434,7,9,200,11,23,46,238,45,0,67,3,32,12,32,444,555,666,775,443];
var len = arr.length;
var nMax = 0;

function bubbleSort(array){
　　　　　　var i = 0, len = array.length, j, d;
for(i; i<len; i++){
for(j=0; j<len; j++){
if(array[i] < array[j]){　　　　// 冒泡从高到低
d = array[j];
array[j] = array[i];
array[i] = d;
break;
}
}
}
　　　　　　return array;
}

var getSort = bubbleSort(arr);
document.write(getSort);
</script>

四、计算百分比

　　胜200 平10 负40 　　各占的百分比

　　公式：数量 / 总数 * 100

　　　　　求200占的百分比就是 200/250*100=80%

// 保留两位小数
// @num：数量   @sum：总数
function ratio(num, sum){
if(!num || !sum){
return ;
}
var nVal = num / sum * 100;
return nVal.toFixed(2);
}

五、一组数中有多少个重复的数，并重复了多少次

<script>
var arr=[1, 3, 1, 3, 3, 2, 5, 6, 7, 5, 4, 3];
var json={};

for(var i=0; i<arr.length; i++){
var ret = arr[i];
if(!json[ret]){
json[ret]=1;
}
else {
json[ret]++;
}
};

for(var i in json){
alert('"'+i+'"出现了:'+json[i]+'次')
};
</script>

六、表格排序

<script>
/*
* 思路：
* 1、先获取所有tr的指针（DOM元素）
* 2、通过sort进行排序
* 3、排序后的指针重新
* */

function sortTabel(){
var oTab = $("#tab tbody");
var oArr = [];
oTab.find("tr").each(function(){
oArr.push($(this));
})

// console.log(oArr);
oArr.sort(generateCompareTRs("des"));

console.log(oArr);
$.each(oArr, function(i){
oTab.append(oArr[i]);
})
}

function generateCompareTRs(type){
return function compareTRs(t1,t2){
var v1 = parseInt(t1.find("td:eq(0)").text());      // 获取比较列的号
var v2 = parseInt(t2.find("td:eq(0)").text());

if(type==="des"){   // 降序
if(v1>v2){
return 1;
}
else{
return -1;
}
}
if(type==="asc"){   // 升序
if(v1>v2){
return -1;
}
else{
return 1;
}
}
}
}

$("body").click(function(){
sortTabel()
});
</script>

七、数组去重的四种方法

方法一：推荐使用，通过添加到对象中，在查看是否存在

function remRepeatArr(arr){
console.time("b");
if(arr.length < 1){
return false;
}

var arr = arr;
var tempArr = [];
var obj = {};
for(var i= 0, len=arr.length; i<len; i++){
obj[arr[i]] = 0;
}

for(var key in obj){
tempArr.push(key);
}

console.timeEnd("b");
return tempArr;
}

var ss = remRepeatArr([1,45,423,453,2,1,236,68,9,3,457,678,323,3,45,67,7,88,93,2,4]);
console.log(ss);

方法二：双重循环去匹配每个数，效率慢些

function delRepeatArr(arr){
var res = [arr[0]];
for(var i = 1; i < arr.length; i++){
var repeat = false;
for(var j = 0; j < res.length; j++){
if(arr[i] == res[j]){
repeat = true;
break;
}
}
if(!repeat){
res.push(arr[i]);
}
}
return res;
}

var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];
console.log(delRepeatArr(arr));

方法三：

function delRepeatArr(arr){
arr.sort();    //先排序
var res = [arr[0]];
for(var i = 1; i < arr.length; i++){
if(arr[i] !== res[res.length - 1]){
res.push(arr[i]);
}
}
return res;
}

var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];
console.log(delRepeatArr(arr));