JavaScript 基础（006_排序算法）

最新推荐文章于 2024-05-03 21:05:41 发布
最新推荐文章于 2024-05-03 21:05:41 发布
阅读量396 收藏
点赞数
分类专栏： JavaScript 文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Google2606/article/details/52604630
版权

排序算法：最近在浏览技术博客的时候无意中发现了一篇关于排序算法的文章，个人觉得总结的非常好，本人是计算机专业的人，看完之后，在觉得汗颜的同时也是受益良多，作为程序员，多积累是个好习惯。自己动手写一写，加深理解，顺便把好文章分享一下。（本文只是用 js 写了各种排序算法的实现，至于各种排序算法的优劣、怎样在不同场合选择最佳的排序算法，这里就不班门弄斧，网上有很多资料，或者查百度百科。）

JS家的排序算法（郑重声明，转载）：http://www.jianshu.com/p/1b4068ccd505

冒泡排序：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Bubble Sort</title>
        <script type="text/javascript">
            var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
            console.log(bubbleSort(arr));
            function bubbleSort(arr) {
                var i = arr.length;
                while (i > 0) {
                    for (let j = 0; j < i - 1; j++) {
                        if (arr[j] > arr[j + 1]) {
                            arr[j] = arr[j] + arr[j + 1];
                            arr[j + 1] = arr[j] - arr[j + 1];
                            arr[j] = arr[j] - arr[j + 1];
                        }
                    }
                    i--;
                }
                return arr;
            }
        </script>
    </head>
    <body>
    </body>
</html>

选择排序：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Select Sort</title>
        <script type="text/javascript">
            var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
            console.log(selectSort(arr));
            function selectSort(arr) {
                var index = 0; // 记录最小数据的数组下标
                if((arr == undefined) || (arr.length == 0)) {
                    return arr;         
                }
                for(let i=0; i<arr.length; i++) {
                    index = i;
                    for(let j=i+1; j<arr.length; j++) {
                        if(arr[j] < arr[index]) {
                            index = j;
                        }
                    }
                    if(index == i) continue;
                    arr[i] = arr[i] + arr[index];
                    arr[index] = arr[i] - arr[index];
                    arr[i] = arr[i] - arr[index];
                }
                return arr;
            }
        </script>
    </head>
    <body>
    </body>
</html>

插入排序：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert Sort</title>
        <script type="text/javascript">
            var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
            console.log(insertSort(arr));
            function insertSort(arr) {
                if((arr == undefined) || (arr.length < 2)) {
                    return arr;         
                }
                for(let i=1; i<arr.length; i++) {
                    for(let j=i; j>0; j--) {
                        if(arr[j] < arr[j-1]) {
                            arr[j] = arr[j] + arr[j-1];
                            arr[j-1] = arr[j] - arr[j-1];
                            arr[j] = arr[j] - arr[j-1];
                        } else {
                            break;
                        }
                    }
                }
                return arr;
            }
        </script>
    </head>
    <body>
    </body>
</html>

希尔排序：

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Shell Sort</title>
<script type="text/javascript">
    var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
    console.log(shellSort(arr));
    function shellSort(arr) {
        if((arr == undefined) || (arr.length < 2)) {
            return arr;
        }
        var len = arr.length;
        for(var fraction=Math.floor(len/2); fraction>0; fraction=Math.floor(fraction/2)) {
            for(var i=fraction; i<len; i++) {
                for(var j=i-fraction; j>=0 && arr[j]>arr[fraction+j]; j=j-fraction) {
                    arr[j] = arr[j] + arr[fraction+j];
                    arr[fraction+j] = arr[j] - arr[fraction+j];
                    arr[j] = arr[j] - arr[fraction+j];
                }
            }
        }
        return arr;
    }
</script>
</head>
<body>
</body>
</html>

归并排序：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Merge Sort</title>
        <script type="text/javascript">
            function merge(arr, low, mid, high) {
                var i = low;
                var j = mid + 1;
                var k = 0;
                var tmp = [high - low + 1];
                while(i <= mid && j <= high) {
                    if(arr[i] <= arr[j]) {
                        tmp[k] = arr[i];
                        i++;
                        k++;
                    } else {
                        tmp[k] = arr[j];
                        j++;
                        k++;
                    }
                }
                while(i <= mid) {
                    tmp[k] = arr[i];
                    i++;
                    k++;
                }
                while(j <= high) {
                    tmp[k] = arr[j];
                    j++;
                    k++;
                }
                for (k = 0, i = low; i <= high; i++, k++) {
                    arr[i] = tmp[k];
                }
            }

            function sort(arr) {
                var len = arr.length;
                for (let gap = 1; gap < len; gap = 2 * gap) {
                    var i = 0;
                    for (i = 0; i + 2 * gap - 1 < len; i = i + 2 * gap) {
                        merge(arr, i, i + gap - 1, i + 2 * gap - 1);
                    }
                    if (i + gap - 1 < len) {
                        merge(arr, i, i + gap - 1, len - 1);
                    }
                }
                return arr;
            }

            var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
            console.log(sort(arr));
        </script>
    </head>
    <body>
    </body>
</html>

快速排序：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Quick Sort</title>
        <script type="text/javascript">
            function quickSort(arr) {
                function sort(prev, numsize) {
                    var nonius = prev;
                    var j = numsize - 1;
                    var flag = arr[prev];
                    if((numsize-prev) > 1) {
                        while(nonius < j) {
                            for(; nonius < j; j--) {
                                if(arr[j] < flag) {
                                    arr[nonius] = arr[j];
                                    nonius++;
                                    break;
                                }
                            }
                            for(; nonius < j; nonius++) {
                                if(arr[nonius] > flag) {
                                    arr[j] = arr[nonius];
                                    j--;
                                    break;
                                }
                            }
                        }
                        arr[nonius] = flag;
                        sort(0, nonius);
                        sort(nonius+1, numsize);
                    }
                }
                sort(0, arr.length);
                return arr;
            }
            var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
            console.log(quickSort(arr));
        </script>
    </head>
    <body>
    </body>
</html>

堆排序：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Heap Sort</title>
        <script type="text/javascript">
            Array.prototype.buildMaxHeap = function() {
                for(let i=Math.floor(this.length/2)-1; i>=0; i--) {
                    this.heapAdjust(i, this.length);
                }
            };

            Array.prototype.heapAdjust = function(i, j) {
                var largest = i;
                var left = 2*i + 1;
                var right = 2*i + 2;

                if(left<j && this[largest]<this[left]) {
                    largest = left;
                }

                if(right<j && this[largest]<this[right]) {
                    largest = right;
                }

                if(largest != i) {
                    this.swap(i, largest);
                    this.heapAdjust(largest, j);
                }
            };

            Array.prototype.swap = function(i, j) {
                this[i] = this[i] + this[j];
                this[j] = this[i] - this[j];
                this[i] = this[i] - this[j];
            };

            Array.prototype.headSort = function() {
                this.buildMaxHeap();
                for(let i=this.length-1; i>0; i--) {
                    this.swap(0, i);
                    this.heapAdjust(0, i);
                }
                return this;
            };

            var arr = new Array();
            [].push.apply(arr, [3, 2, 4, 9, 1, 5, 7, 6, 8]);
            console.log(arr.headSort());
        </script>
    </head>
    <body>
    </body>
</html>

计数排序：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Count Sort</title>
        <script type="text/javascript">
            Array.prototype.init = function() {
                for(let i=0; i<this.length; i++) {
                    this[i] = 0;
                }
            }
            function countSort(a) {
                var b = new Array(a.length);
                b.init();
                var max = a[0];
                var min = a[0];
                for(let i in a) {
                    if(a[i] > max) {
                        max = a[i];
                    }
                    if(a[i] < min) {
                        min = a[i];
                    }
                }
                var k = max - min + 1;
                var c = new Array(k);
                c.init();
                for(let i=0; i<a.length; ++i) {
                    c[a[i]-min] += 1;
                }
                for(let i=1; i<c.length; ++i) {
                    c[i] = c[i] + c[i-1];
                }
                for(let i=a.length-1; i>=0; --i) {
                    b[--c[a[i]-min]] = a[i];
                }
                return b;
            }   

            var a = [3, 2, 4, 9, 1, 5, 7, 6, 8];
            console.log(countSort(a));
        </script>
    </head>
    <body>
    </body>
</html>
柯南道尔2606
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用JavaScript实现的冒泡排序算法：
07-26
使用JavaScript实现的冒泡排序算法：
JavaScript基础语法_JavaScript数组和冒泡排序
热门推荐
JiuMeilove的博客
06-16 2万+
数组（array）是按次序排列的一组值。每个值的位置都有编号（从0开始），整个数组用方括号表示。 上面代码中的a、b、c就构成一个数组，两端的方括号是数组的标志。a是0号位置，b是1号位置，c是2号位置。除了在定义时赋值，数组也可以先定义后赋值。 任何类型的数据，都可以放入数组。 上面数组arr的3个成员依次是对象、数组、函数。如果数组的元素还是数组，就形成了多维数组。 数组的本质 本质上，数组属于一种特殊的对象。typeof运算符会返回数组的类型是object。 上面代码表明，typeof运算符认为数组的
JavaScript 算法——排序算法之冒泡排序
weixin_44566194的博客
08-22 2252
冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法，可以把一系列的数据按照一定的顺序进行排列显示（从大到小或从小到大）。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
JavaScript算法——桶排序
诸葛韩信--一个前往前端不归路的浪子
05-07 988
一、桶排序的原理 桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。思路大致是， 设置一个定量的数组当作空桶； 遍历输入数据，并且把数据一个一个放到对应的桶里去； 对每个不是空的桶进行排序； 从不是空的桶里把排好序的数据拼接起来。 二、静态示意图 元素分布在桶中： 然后，元素在每个桶中排序： 其实，很明显，这是计数排序的优化版，当然也可以说成是升级版。主要是分好桶。 三、代码实现 function bucketSort(arr, bucketSize) {
用JavaScript实现排序算法
shao_xuan_的博客
10-31 1289
@TOC 冒泡排序 冒泡排序就是重复从序列右边开始比较相邻两个数字的大小，再根据结果交换两个数字的位置。 JavaScript代码实现: 代码简介：声明一个数组变量，通过while给数组变量赋值，当输入“#”时停止输入，然后遍历相邻的两个数，让相邻的两个数升序排列，遍历n-1次实现排序; var a = Array(); flag=true; var i = 0; var j = 0; var temp = 0; while(flag){ var b
JavaScript算法——快速排序
诸葛韩信--一个前往前端不归路的浪子
04-19 6439
一、概念 快速排序算法由 C. A. R. Hoare 在 1960 年提出。它的时间复杂度也是 O(nlogn)，但它在时间复杂度为 O(nlogn) 级的几种排序算法中，大多数情况下效率更高，所以快速排序的应用非常广泛。 注意： 快速排序不一定是最快的排序方法，这取决于需要排序的数据结构、数据量。不过，大多数情况下，面试官和工作场所用它的概率也是相对较高的，所以我们应该花时间把它学透彻。 二、工作原理 首先设定一个分界值，通过该分界值将数组分成左右两部分。 将大于或等于分界值的数据集中到数组右边
javascript排序算法可视化
m0_46218239的博客
11-29 475
javascript排序算法可视化
JavaScript常用的5种排序算法，你都掌握了吗？
有事儿私信。
06-30 991
今天给大家带来5种最常见的前端排序算法，注释非常详细，欢迎讨论~
JavaScript 拓扑排序 算法
qq_29091239的博客
04-24 1059
拓扑排序会对有向图的所有顶点进行排序，使有向边从前面的顶点指向后面的顶点。拓扑排序算法与深度优先搜索类似。不同的是，拓扑排序算法不会立即输出已访问的顶点，而是访问当前顶点邻接表中的所有相邻顶点，直到这个列表穷尽时，才将当前顶点压入栈中。拓扑排序算法被拆分为两个函数。第一个函数 topSort()，会设置排序进程并调用一个辅助函数 topSortHelper()，然后显示排序好的顶点列表。主要工作是...
JavaScript常用基础算法
玖尘的博客
02-18 4239
一、字符串 1.字符串中出现最多次数的字符 function findMaxDuplicateChar(str) { var cnt = {}, // 用来记录所有的字符的出现频次 c = ""; // 用来记录最大频次的字符 for (var i = 0; i < str.length; i++) { var ci = str[i]; if (!cnt[ci]) {
冒泡排序算法JS代码javascript
Moony_wy的博客
02-03 953
冒泡排序算法JS代码javascript 冒泡排序原理 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换的元素，也就是说数列已经排序完成。
JavaScript桶排序算法1
08-08
JavaScript桶排序算法桶排序算法桶排序（Bucket sort）也称箱排序，是一个排序算法，工作的原理是将数组分到几个桶里，桶的数量可由排序数组最大值与
JavaScript中九种常用排序算法
10-25
不同的排序算法，执行效率有着天壤之别，本脚本用JavaScript演示了各种常见的排序算法，包括：冒泡排序、选择排序、插入排序、谢尔排序、快速排序(递归)、快速排序(堆栈)、归并排序、堆排序
JavaScript计数排序算法1
08-08
JavaScript计数排序算法计数排序算法计数排序（Counting sort）是一种稳定的线性时间排序算法。计数排序使用一个额外的数组，数组的下标对应待排序
基于JavaScript实现的希尔排序算法分析
10-20
主要介绍了基于JavaScript实现的希尔排序算法,简单分析了希尔排序的原理并结合实例形式给出了javascript实现希尔排序的操作步骤与相关注意事项,需要的朋友可以参考下
基于Springboot的家具网站
趙兴晨的博客
05-03 559
本文介绍了一款基于现代Web技术构建的家具网站，旨在通过互联网技术优化家具产品的展示与销售，提高用户的购物体验，同时为家具制造商和零售商提供一个高效的在线销售平台。本研究的主要目的是设计并实现一个高效、易用的家具网站，通过系统化的产品展示流程和智能化的购物功能，提升家具产品的在线销售效率和管理水平。本研究通过设计和实现家具网站，有效地解决了传统家具销售中的展示局限性和购物效率低下的问题，提高了家具产品的在线销售效率和用户的购物体验，并为相关领域的研究和实践提供了有益的参考。
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1229
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
vue快速入门（五十）重定向
不起眼小菜菜的博客
05-03 471
注释很详细，直接上代码……
50个前端实战项目之04：隐藏的搜索小组件
最新发布
前端开发博客
05-03 1119
大家好，我是宝哥。今天讲50个前端实战项目之04：隐藏的搜索小组件。源码下载地址https://github.com/bradtraversy/50projects50days/tree/master/hidden-search前端实战项目系列正在更新：04/5001：可展开卡片02：进度条03：旋转导航动画04：隐藏的搜索小组件项目介绍本项目演示了一个简洁实用的隐藏式搜索小部件。点击搜索按钮后，...
javascript编写的快速排序算法代码
05-17
以下是一个使用 JavaScript 编写的快速排序算法代码： ```javascript function quickSort(arr) { if (arr.length ) { return arr; } const pivot = arr[0]; const left = []; const right = []; for (let i ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值