这学期刚刚学完数据结构，之前就自己写了一点东西，现在整理一下。

<!DOCTYPE html>

<html>

<head>

    <meta charset="utf-8">

    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

    <title>JS实现排序</title>

    <meta name="description" content="用JS自己写的排序算法">

    <meta name="keywords" content="JS，排序">

</head>

<body>

    <script type="text/javascript">

    //从小到大排序

    var a = [, , , , , , , , ];

    //第一种:简单冒泡排序

    function bubbleSort0(ar) {

        for (var i = ; i < ar.length - ; i++) { //a.length长的数组只要进行a.length-1次排序，0-a.length-2刚好为a.length-1的长度

            for (var j = i + ; j < ar.length; j++) {

                if (a[i] > a[j]) {

                    a[i] ^= a[j]; //交换两个数

                    a[j] ^= a[i];

                    a[i] ^= a[j];

                }

            }

        }

    }

    bubbleSort0(a);

    console.log("简单冒泡排序：" + a);

    //第二种:正宗冒泡排序

    var a = [, , , , , , , , ];

    function bubbleSort(ar) {

        var flag = true;

        for (var i = ; i < ar.length -  && flag; i++) { //a.length长的数组只要进行a.length-1次排序，0-a.length-2刚好为a.length-1的长度

            for (var j = ar.length - ; j > i; j--) { //判断条件与下面的判断条件的边界值需要注意

                flag = false; //默认标志为false,则当不进入下面括号的时候代表i之后的数已经排好了序，这里用的是上一轮排序的结果

                if (a[j] < a[j - ]) {

                    a[j] ^= a[j - ];

                    a[j - ] ^= a[j];

                    a[j] ^= a[j - ];

                    flag = true; //当i后面有数据交换的时候则认为排序没有完成

                }

            }

        }

    }

    bubbleSort(a);

    console.log("正宗冒泡排序：" + a);

    //第三种:简单选择排序

    var a = [, , , , , , , , ];

    function selectSort(ar) {

        for (var i = ; i < ar.length - ; i++) {

            var temp = i;

            for (var j = i + ; j < ar.length; j++) {

                if (a[j] < a[temp])

                    temp = j;

            }

            if (temp != i) {

                a[i] ^= a[temp];

                a[temp] ^= a[i];

                a[i] ^= a[temp];

            }

        }

    }

    selectSort(a);

    console.log("简单选择排序：" + a);

    //第四种:插入排序

    var a = [, , , , , , , , , ]; //第一个0是放暂存数的，为了能让后面的数有空间挪动

    function insertSort(ar) {

        for (var i = ; i < ar.length; i++) { //假设a[1]为已经排好序的数列，虽然只有一个数

            if (a[i] < a[i - ]) { //当后面的数比前面的数小的时候

                a[] = a[i];

                for (var j = i - ; a[j] > a[]; j--) //暂存位还可以起到比较的作用

                    a[j + ] = a[j];

                a[j + ] = a[];

            }

        }

        a[] = ; //小洁癖，还原暂存数位为0，美观

    }

    insertSort(a);

    console.log("插入排序：" + a);

    //第五种:希尔排序

    var a = [, , , , , , , , , ]; //第一个0是放暂存数的，为了能让后面的数有空间挪动

    function shellSort(ar) {

        var incre = ar.length - ; //初始化递增量为数组内排序的数字的长度，不包括暂存位

        do {

            incre = parseInt(incre / ) + ; //经研究递增量为n/3+1,n/9+1,n/27+1……时的排序效率最高，这里取n/3+1方法

            for (var i = incre + ; i <= ar.length - ; i++) {

                if (a[i] < a[i - incre]) {

                    a[] = a[i];

                    for (var j = i - incre; j >  && a[j] > a[]; j -= incre)

                        a[j + incre] = a[j];

                    a[j + incre] = a[];

                }

            }

        } while (incre > );

        a[] = ;

    }

    shellSort(a);

    console.log("希尔排序：" + a);

    //第六种：基数排序

    var b = [, , , , , , , , ]; //测试基数排序的数组，定义大一点

    function radixSort(arr) {

        var i, j, k, lsd;

        var n = ; //变量n,每次递增10倍

        var t = ; //数字的最大位数递增量，从个位开始

        var temp = new Array(); //创建一维数组

        var count = new Array();

        for (i = ; i < ; i++) {

            temp[i] = new Array(arr.length); //创建二维数组

        }

        for (i = ; i < ; i++) { //初始化二维数组和计数数组

            count[i] = ;

            for (j = ; j < arr.length; j++)

                temp[i][j] = ;

        }

        var numLength = getNumberLength(arr); //得到数的宽度，比如[337,1,22]得到为3，函数放在基数排序函数radixSort的最后

        while (t++ <= numLength) { //这里循环数组数字的位数进行统计和收集

            for (j = ; j < arr.length; j++) { //统计

                lsd = parseInt((arr[j] / n) % ); //取得当前位数的数字

                temp[lsd][count[lsd]++] = arr[j]; //将其存入二维数组temp

            }

            for (i = , k = ; i < ; i++) { //收集二维数组的计数存入原来的数组

                if (count[i] != ) //当前的数字统计有数

                    for (j = ; j < count[i]; j++) //***计数数组的作用体现了，不用每次都把二维数组temp置0

                        arr[k++] = temp[i][j];

                count[i] = ;

            }

            n *= ; //统计后一位数组

        }

        function getNumberLength(a) { //计算数组的数字的最大长度，比如[337,1,22]得到为3，放在最后没关系，JS有隐式提升

            var numberLength, max = ;

            for (var i = ; i < a.length; i++) {

                var temp = a[i];

                numberLength = ;

                while (temp >= ) {

                    temp /= ;

                    numberLength++;

                    if (temp < ) {

                        numberLength++;

                        break;

                    }

                }

                if (numberLength > max)

                    max = numberLength;

            }

            return max;

        }

    }

    radixSort(b);

    console.log("基数排序：" + b);

    //第七种:快速排序

    var a = [, , , , , , , , ]; //第一个0是放暂存数的，为了能让后面的数有空间挪动

    function quickSort(ar, low, high) {

            var povit;

            if (low < high) {

                povit = partition(ar, low, high);

                quickSort(ar, low, povit - );

                quickSort(ar, povit + , high);

            }

        }

        //求枢轴

    function partition(ar, low, high) {

        var povitkey;

        povitkey = ar[low]; //取最低的数作为枢轴

        var temp;

        while (low < high) {

            while (low < high && ar[high] >= povitkey)

                high--;

            if (ar[high] != ar[low]) {

                ar[high] ^= ar[low];

                ar[low] ^= ar[high];

                ar[high] ^= ar[low];

            }

            while (low < high && ar[low] <= povitkey)

                low++;

            if (ar[high] != ar[low]) {

                ar[high] ^= ar[low];

                ar[low] ^= ar[high];

                ar[high] ^= ar[low];

            }

        }

        return low;

    }

    quickSort(a, , a.length - );

    console.log("快速排序：" + a);

    //第八种:堆排序

    var a = [, , , , , , , , , ]; //第一个0是放暂存数的，为了能让后面的数有空间挪动

    function heapSort(ar) {

        var i;

        for (i = parseInt((ar.length - ) / ); i > ; i--) { //构建大顶堆

            heapAdjust(ar, i, ar.length - );

        }

        for (i = ar.length - ; i > ; i--) {

            //交换两个数,ar[1]和ar[i]

            ar[] ^= ar[i];

            ar[i] ^= ar[];

            ar[] ^= ar[i];

            heapAdjust(ar, , i - );

        }

    }

    function heapAdjust(ar, s, m) { //s为上标，m为下标

        var temp, j;

        temp = ar[s];

        for (j =  * s; j <= m; j *= ) {

            if (j < m && ar[j + ] > ar[j]) //当右孩子比左孩子大的时候

                j++;

            if (temp > ar[j])

                break;

            ar[s] = ar[j];

            s = j;

        }

        ar[s] = temp;

    }

    heapSort(a);

    console.log("堆排序：" + a);

    //第八种:堆排序改进

    var a = [, , , , , , , , ]; //第一个0是放暂存数的，为了能让后面的数有空间挪动

    function heapSort(ar) {

        var i;

        for (i = parseInt((ar.length - ) / ) - ; i >= ; i--) { //构建大顶堆

            heapAdjust(ar, i, ar.length - );

        }

        for (i = ar.length - ; i >= ; i--) {

            //交换两个数,ar[1]和ar[i]

            ar[] ^= ar[i];

            ar[i] ^= ar[];

            ar[] ^= ar[i];

            if (i !== )

                heapAdjust(ar, , i - );

        }

    }

    function heapAdjust(ar, s, m) { //s为上标，m为下标

        var temp, j;

        temp = ar[s];

        for (j =  * s; j <= m; j *= ) {

            if (j < m && ar[j + ] > ar[j]) //当右孩子比左孩子大的时候

                j++;

            if (temp > ar[j])

                break;

            ar[s] = ar[j];

            s = j;

        }

        ar[s] = temp;

    }

    heapSort(a);

    console.log("堆排序改进：" + a);

    </script>

</body>

</html>

也不知道是不是最好的排序算法，学的时候是用的C语言写的，C语言的版本后面再整理吧，这里的都是JS的。

感觉高级语言封装好了太多东西，像排序只要一个sort方法就搞定了，但是自己写完才知道，后面封装了太多东西，一个排序方法可能Brenden Eich(JS发明者)已经写了几百行代码。

像Java，C#等等都封装了太多的基本代码在里面，感觉我们开发项目就是在组装电脑，拿起内存和硬盘看下型号插插插。最后剩下的就只有动手能力了。

keep fighting!：）

 

自己写的JS排序算法的更多相关文章

  1. js排序算法汇总

    JS家的排序算法   十大经典算法排序总结对比 一张图概括: 主流排序算法概览 名词解释: n: 数据规模k:“桶”的个数In-place: 占用常数内存,不占用额外内存Out-place: 占用额外 ...

  2. 总结下js排序算法和乱序算法

    其实本人最怕的就是算法,大学算法课就感觉老师在讲天书,而且对于前端来说,算法在实际的应用中实在是很有限.毕竟算法要依靠大量的数据为基础才能发挥出算法的效率,就浏览器那性能,......是吧,退一万步说 ...

  3. 排序图解：js排序算法实现

    之前写过js实现数组去重, 今天继续研究数组: 排序算法实现. 排序是数据结构主要内容,并不限于语言主要在于思想:大学曾经用C语言研究过一段时间的排序实现, 这段时间有空用JS再将排序知识点熟悉一遍. ...

  4. 常用的 JS 排序算法整理

    关于排序算法的问题可以在网上搜到一大堆,但是纯 JS 版比较零散,之前面试的时候特意整理了一遍,附带排序效率比较. //1.冒泡排序 var bubbleSort = function(arr) { ...

  5. 用Java来写常见的排序算法

    随着校招的临近 算法是校招中很重要的一个部分 总结了常见几种排序算法,各种算法的时间复杂度和空间复杂度大家也需要多了解下 package com.huwei.sort; /** * 各种排序算法 * ...

  6. js排序算法总结—冒泡，快速，选择，插入，希尔，归并

    相信排序是任何一个程序猿都会用到的东西,今天简单总结记录下常见的排序算法. 一.冒泡排序 说起冒泡排序,可能每个人都不会陌生,实现思路相当简单明了,就是不停的对数组进行两两比较,将较大(较小)的一项放 ...

  7. js排序算法总结——冒泡，快速，选择，插入，希尔，归并

    相信排序是任何一个程序猿都会用到的东西,今天简单总结记录下常见的排序算法. 一.冒泡排序 说起冒泡排序,可能每个人都不会陌生,实现思路相当简单明了,就是不停的对数组进行两两比较,将较大(较小)的一项放 ...

  8. 结构-行为-样式-Js排序算法之 直接插入排序

    最新因工作原因需要接触到算法,之前学习C++的时候有接触过算法,Javascript中实现算法其实也是大同小异.下面我讲下第一个实现的排序算法--直接插入排序.基本实现思路:假定一个数组中前n(n&g ...

  9. js排序算法总结

    快速排序 大致分三步: 1.找基准(一般是以中间项为基准) 2.遍历数组,小于基准的放在left,大于基准的放在right 3.递归 快速排序的平均时间复杂度是O(nlogn),最差情况是O(n²). ...

随机推荐

  1. 《从零开始学Swift》学习笔记（Day 58）—— Swift编码规范之变量或常量声明规范

    原创文章,欢迎转载.转载请注明:关东升的博客 声明是在声明变量.常量.属性.方法或函数和自定义类型时候需要遵守的规范. 首先变量或常量时每行声明变量或常量的数量推荐一行一个,因为这样以利于写注释.示例 ...

  2. angular做的简单购物车

    虽然本人也是刚刚才开始学习angular.js,并不是非常会,但是这并不能阻止我对angular的喜爱.因为它太省代码了,比如说一个比较简单的购物车,就是只有商品名称,单价,数量,小计,总计和删除功能 ...

  3. 《JAVA多线程编程核心技术》 笔记：第七章：拾遗增补

    一.线程的状态 1.1 状态种类及理解:(一共6个) 文字说明和理解: NEW状态:线程实例化后还从未执行start()方法时的状态: RUNNABLE状态:线程进入运行的状态: TERMINATED ...

  4. 疯狂Html+CSS+JS 中JS总结

    来自:http://mzkmzk.github.io/blog/2015/10/05/amazeing-js/ 0 总结 本书的JS 第一章有讲语法有挺多常见的坑点和原理解释很不错 第二章DOM编程讲 ...

  5. virtualbox mac-debian共享文件夹

    1 这篇笔记所要解决的问题 How to Install VirtualBox Guest Additions in Debian 9 Virtual Machine 不需要管host os的类型. ...

  6. 如何基于Go搭建一个大数据平台

    如何基于Go搭建一个大数据平台 - Go中国 - CSDN博客 https://blog.csdn.net/ra681t58cjxsgckj31/article/details/78333775 01 ...

  7. Java 语言基础之数组应用

    什么时候使用数组呢? 如果数据出现了对应关系, 而且对应关系的一方是有序的数字编号, 并作为角标使用. 这时,就必须要想到数组的使用. 也就是将这些数据存储到数组中, 根据运算的结果作为角标, 直接去 ...

  8. 报错：PermissionError: [WinError 5] Access is denied: 'C:\\Program Files\\Anaconda3\\Lib\\site-packages\\pywebhdfs'

    Outline 在本(Windows系统)地往 “PAI”(hdfs)上上传数据时,需要安装pywebhdfs包,然后就报错了: 报错信息: PermissionError: [WinError 5] ...

  9. R中的data.table 快速上手入门

    data.table包提供了一个非常简洁的通用格式:DT[i,j,by]. 可以理解为:对于数据集DT,选取子集行i,通过by分组计算j. 对比与dplyr等包,data.table的运行速度更快. ...

  10. ajax异步请求返回对象

    使用ajax异步请求返回一个对象. java code: @RequestMapping({"getAstSingleWheelImg_bbs"+Constant.JSON}) @ ...