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

代码如下:

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

//冒泡排序
/*function bubbleSort(arr) {
    newarr = arr.slice()
    if (newarr.length <= 2) return newarr
    for (var i = 0; i < newarr.length - 1; i++) {
        for (var j = 0; j < newarr.length - i - 1; j++) {
            if (newarr[j] > newarr[j + 1]) {
                newarr[j] = [newarr[j + 1], newarr[j + 1] = newarr[j]][0]

}
        }
    }
    return newarr
}

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

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

}

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

*/

//选择排序
/*function selectSort(arr) {
    var min = 9999,
        minindex = 0;
    var left = [],
        right = arr.slice();
    if (arr.length <= 1) return arr;
    for (var i = 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))
}

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

//插入排序
/*function insertSort(arr) {
    var tmp;
    for (var i = 1; i < arr.length; i++) {
        tmp = arr[i];
        for (var j = i; j > 0; j--) {
            if (arr[j - 1] > tmp) {
                arr[j] = arr[j - 1];
            } else {
                break;
            }
        }
        arr[j] = tmp;
    }
    return arr;
}

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

//木桶排序
/*function bucketSort(arr){
    var bucket = [];
    var newarr = [];
    for (var i = 0; i < arr.length; i++) {
        bucket[arr[i]] = arr[i];
    }
    for (var i = 0; i < bucket.length; i++) {
        if (bucket[i] !== undefined){
            newarr.push(bucket[i])
        }
    }
    return newarr;
}

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

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

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

return result;   
}

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

//归并排序
/*function mergeSort(arr) {
    if (arr.length <= 1) return arr;
    var mid = Math.floor(arr.length / 2);
    var left = MergeSort(arr.slice(0, mid));
    var right = MergeSort(arr.slice(mid));
    var result = [];

while (left.length && right.length) {
        if (left[left.length - 1] <= right[0]) {
            result = result.concat(left);
            left = [];
        } else if (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);

return result;
}*/

/*function mergeSort(arr) {
    var merge = function(left, right) {
        var result = [];
        while (left.length > 0 && right.length > 0) {
            if (left[0] < right[0]) {
                result.push(left.shift());
            } else {
                result.push(right.shift());
            }
        }
        return result.concat(left).concat(right);
    }

if (arr.length == 1) return arr;
    var middle = Math.floor(arr.length / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}

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

*/

//堆排序

/*function heapSort(arr) {
    var findRoot = function(arr, p, length) {
        p = p || 0;
        length = length || arr.length;
        var self = arguments.callee;
        var l = p * 2 + 1;
        var r = (p + 1) * 2;
        var left, 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];

return arr[p];
    };

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

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

//奇偶排列

/*function oddEvenSort(arr) {
    var swaped = true,
        k = 0;
    while (swaped) {
        if (k > 0) swaped = false;

for (var i = 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]
    }
    return arr;
}

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

function oddEvenSort(arr) {
    var swaped = true;
    while (swaped) {
        swaped = false;
        for (var i = 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 (var i = 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;
            }
        }
    }
    return arr;
}

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

(0)

相关推荐

  • JS常用算法实现代码

    本文的主要目的是帮助大家熟悉熟悉常用的几个算法用JS的实现,具体内容如下 (1)数组去重 原理:定义一个对象obj,然后把数组元素作为obj的属性名,利用属性名是否重复进行判重 var unique = function(arr){ let obj = {}; let newArr = []; arr.forEach(function(x){ if(!obj[x]){ //如果对象中没有该元素对应的属性 obj[x] = true; newArr.push(x); } }); return ne

  • JS实现的几个常用算法

    (1)数组去重 原理:定义一个对象obj,然后把数组元素作为obj的属性名,利用属性名是否重复进行判重 var unique = function(arr){ let obj = {}; let newArr = []; arr.forEach(function(x){ if(!obj[x]){ //如果对象中没有该元素对应的属性 obj[x] = true; newArr.push(x); } }); return newArr; } (2)使用快速排序算法对数组进行排序 这里面包括两种效果,

  • js交换排序 冒泡排序算法(Javascript版)

    比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. function sort(elements){ for(var i=0;i<elements.length-1;i++){ for(var j=0;j<elements.length-i-1;j++){ if(elemen

  • js实现常用排序算法

    本文为大家分享了js实现常用排序算法,具体内容如下 1.冒泡排序 var bubbleSort = function (arr) { var flag = true; var len = arr.length; for (var i = 0; i < len - 1; i++) { flag = true; for (var j = 0; j < len - 1 - i; j++) { if (arr[j] > arr[j + 1]) { var temp = arr[j+1]; arr

  • JavaScript常用数组算法小结

    今天抽点时间把javascript中的一些常用的数组算法做一下总结,以方便大家面试笔试或者日常开发过程中用到.其中部分算法来自网络,这里做了下汇总整理.文章末尾我会把参考的来源附上去,如果直接看算法比较枯燥的可以到参考文献里去看,讲解的非常不错. 一.数组去重 方法1: //利用数组的indexOf方法 function unique (arr) { var result = []; for (var i = 0; i < arr.length; i++) { if (result.indexO

  • JavaScript中九种常用排序算法

    笔试面试经常涉及各种算法,本文简要介绍常用的一些算法,并用JavaScript实现. 一.插入排序 1)算法简介 插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间. 2)算法描述和实现 一般来说,插入排序都采

  • 浅析JavaScript中的常用算法与函数

    代码使用方法: 0001:判断一个计算结果是不是无穷大:if(isFinite(999999999*999999999) == true)----------------------------------------------------------------------------------------------------0002:判断是不是数字:if(isNaN("Blue") == true),不是数字则为true,是数字则为false.---------------

  • JavaScript生成GUID的多种算法小结

    全局唯一标识符(GUID,Globally Unique Identifier)也称作 UUID(Universally Unique IDentifier) . GUID是一种由算法生成的二进制长度为128位的数字标识符.GUID 的格式为"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",其中的 x 是 0-9 或 a-f 范围内的一个32位十六进制数.在理想情况下,任何计算机和计算机集群都不会生成两个相同的GUID. GUID 的总数达到了2^128(3

  • javascript常用经典算法实例详解

    本文实例讲述了javascript常用算法.分享给大家供大家参考,具体如下: 入门级算法-线性查找-时间复杂度O(n)--相当于算法界中的HelloWorld //线性搜索(入门HelloWorld) //A为数组,x为要搜索的值 function linearSearch(A, x) { for (var i = 0; i < A.length; i++) { if (A[i] == x) { return i; } } return -1; } 二分查找(又称折半查找) - 适用于已排好序的

  • 常用JS加密编码算法代码第1/2页

    一:UTF8编码函数 复制代码 代码如下: function URLEncode(Str){ if(Str==null||Str=="") return ""; var newStr=""; function toCase(sStr){ return sStr.toString(16).toUpperCase(); } for(var i=0,icode,len=Str.length;i<len;i++){ icode=Str.charCo

随机推荐