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


Posted in Javascript onApril 29, 2014
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)
Javascript 相关文章推荐
Javascript 解疑
Nov 11 Javascript
避免 showModalDialog 弹出新窗体的原因分析
May 31 Javascript
有趣的javascript数组定义方法
Sep 10 Javascript
JavaScript版的TwoQueues缓存模型
Dec 29 Javascript
微信小程序 Toast自定义实例详解
Jan 20 Javascript
Angularjs 依赖压缩及自定义过滤器写法
Feb 04 Javascript
原生JS实现左右箭头选择日期实例代码
Mar 14 Javascript
vue.js内置组件之keep-alive组件使用
Jul 10 Javascript
vue中使用sessionStorage记住密码功能
Jul 24 Javascript
vue组件实践之可搜索下拉框功能
Nov 25 Javascript
element-ui多文件上传的实现示例
Apr 10 Javascript
axios异步提交表单数据的几种方法
Aug 11 Javascript
当某个文本框成为焦点时即清除文本框内容
Apr 28 #Javascript
JS实现两个大数(整数)相乘
Apr 28 #Javascript
关于img的href和src取变量及赋值的方法
Apr 28 #Javascript
php和js对数据库图片进行等比缩放示例
Apr 28 #Javascript
JS计算网页停留时间代码
Apr 28 #Javascript
js分页代码分享
Apr 28 #Javascript
jquery使用ajax实现微信自动回复插件
Apr 28 #Javascript
You might like
用PHP实现多服务器共享SESSION数据的方法
2007/03/16 PHP
php之对抗Web扫描器的脚本技巧
2008/10/01 PHP
PHP中如何调用webservice的实例参考
2013/04/25 PHP
深入PHP内存相关的功能特性详解
2013/06/08 PHP
培养自己的php编码规范
2015/09/28 PHP
解决更换PHP5.4以上版本后Dedecms后台登录空白问题的方法
2015/10/23 PHP
php制作圆形用户头像的实例_自定义封装类源代码
2017/09/18 PHP
JavaScript 字符串乘法
2009/08/20 Javascript
Javascript string 扩展库代码
2010/04/09 Javascript
一款Jquery 分页插件的改造方法(服务器端分页)
2011/07/11 Javascript
JS弹出层单纯的绝对定位居中示例代码
2014/02/18 Javascript
js控制当再次点击按钮时的间隔时间
2014/06/03 Javascript
JS构造函数与原型prototype的区别介绍
2016/07/04 Javascript
Jquery UI实现一次拖拽多个选中的元素操作
2020/12/01 Javascript
vue自定义指令实现v-tap插件
2016/11/03 Javascript
浅谈jQuery before和insertBefore的区别
2016/12/04 Javascript
Vue插件写、用详解(附demo)
2017/03/20 Javascript
使用Vue-Router 2实现路由功能实例详解
2017/11/14 Javascript
vue 1.0 结合animate.css定义动画效果
2018/07/11 Javascript
[04:17]DOTA2完美盛典,rOtk、BurNIng携手巴图演唱《倔强》
2017/11/28 DOTA
python绘图库Matplotlib的安装
2014/07/03 Python
python中使用mysql数据库详细介绍
2015/03/27 Python
Python两个内置函数 locals 和globals(学习笔记)
2016/08/28 Python
python3中int(整型)的使用教程
2017/03/23 Python
Python线程同步的实现代码
2018/10/03 Python
Python 可变类型和不可变类型及引用过程解析
2019/09/27 Python
美国在线奢侈品寄售商店:Luxury Garage Sale
2018/08/19 全球购物
一家专门经营包包的英国网站:MyBag
2019/09/08 全球购物
希腊香水和化妆品购物网站:Parfimo.gr
2019/10/03 全球购物
学生的自我鉴定范文
2013/10/24 职场文书
货物运输服务质量承诺书
2014/05/29 职场文书
2014年汽车销售工作总结
2014/12/01 职场文书
立项申请报告范本
2015/05/15 职场文书
学生会2016感恩节活动小结
2016/04/01 职场文书
对象析构函数__del__在Python中何时使用
2022/03/22 Python
python通过新建环境安装tfx的问题
2022/05/20 Python