各种排序算法的js实现

有些时候即便是思路再正确也总有考虑不到的地方,而经验让我们一点点填平不足。

冒泡排序:

    //大泡“浮”到右端
    function bubbleSort1(arr){
      var i=arr.length, j;
      var temp;
      while(i>0){
        for(j=0;j<i-1;j++){
          if(arr[j]>arr[j+1]){
            temp = arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
          }
        }
        i--;
      }
      return arr;
    }
    //这种方式是小泡“浮”到左端
     function bubbleSort2(arr) {
        for (var i = 0; i < arr.length; i++) {
            for (var j = arr.length; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    var temp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = temp;
                }
            }
           document.write(i+"   :"+arr+"<br/>");
        }
        return arr;
    }

插入排序:(中间有个找了好久才找到的错误)

    function insertSort1(arr){
        for (var i = 1; i < arr.length; i++) {
            var key = arr[i];
            for(var j=i-1;j>=0&&arr[j]>key;j--){
                arr[j+1] = arr[j];
                // arr[j] = key;//正确位置
            }
            // arr[j] = key;//错误位置
            document.write(arr+"&nbsp;&nbsp;&nbsp;&nbsp;i="+i+"&nbsp;&nbsp;&nbsp;&nbsp;j="+j+"<br/>");
            /*
                错误位置原因:
                i=1而j=0的时候不满足j循环的条件,然后往下执行到arr[j] = key;则arr[0]为6,arr[1]也是6,所以出错,而,j初始值为i的话就很好地避免了这个错误。(如第二种方法,或者放到j的for循环中)

                6,6,90,2,5,11,24,1    i=1    j=0
                6,90,90,2,5,11,24,1    i=2    j=1
                6,6,90,90,5,11,24,1    i=3    j=-1
                6,6,6,90,90,11,24,1    i=4    j=-1
                6,6,11,90,90,90,24,1    i=5    j=2
                6,6,24,90,90,90,90,1    i=6    j=2
                6,6,6,24,90,90,90,90    i=7    j=-1
            */
        };
        return arr;
    }
    /*个人推荐这种*/
   function insertSort2(arr) {
        for (var i = 1; i < arr.length; i++) {
            var temp = arr[i];
            for (var j = i; j > 0 && temp < arr[j - 1]; j--) {
                arr[j] = arr[j - 1];
            }
            arr[j] = temp;
            document.write(i+"   :"+arr+"<br/>");
        }
        return arr;
    }
时间: 2024-10-05 05:07:26

各种排序算法的js实现的相关文章

常见排序算法(JS版)

常见排序算法(JS版)包括: 内置排序,冒泡排序,选择排序,插入排序,希尔排序,快速排序(递归 & 堆栈),归并排序,堆排序,以及分析每种排序算法的执行时间. index.html 1 <!DOCTYPE html> 2 <html> 3 <head> 4 <title>twobin 常见排序算法 (JS版) </title> 5 <meta http-equiv="content-type" content=&

常见排序算法基于JS的实现

一:冒泡排序 1. 原理 a. 从头开始比较相邻的两个待排序元素,如果前面元素大于后面元素,就将二个元素位置互换 b. 这样对序列的第0个元素到n-1个元素进行一次遍历后,最大的一个元素就“沉”到序列的最后位置(第n-1个位置,n为待排序元素个数) c.排除此次排序最后面的那个元素(n=n-1),继续对剩余序列重复前面两步 d. 当(n= n-1)=0时,排序完成 2. 具体实现 以如下待排序序列为例: 到此,第一次冒泡完成,最大值7冒泡到最后面. 然后继续对除最后元素(7)外的序列进行冒泡排序

冒泡排序算法和简单选择排序算法的js实现

之前已经介绍过冒泡排序算法和简单选择排序算法和原理,现在有Js实现. 冒泡排序算法 let dat=[5, 8, 10, 3, 2, 18, 17, 9]; function bubbleSort(data) { for(let i=0;i<data.length-1;i++){ for(let j=0;j<data.length-1-i;j++){ if(data[j]>data[j+1]){ [data[j],data[j+1]]=[data[j+1],data[j]]; } } }

排序算法的JS实现

排序算法是基础算法,虽然关键在于算法的思想而不是语言,但还是决定借助算法可视化工具结合自己常用的语言实现一下 1.冒泡排序 基本思路:依次比较两两相邻的两个数,前面数比后面数小,不变.前面数比后面数大,交换顺序.一轮下来,最后的一个数是最大的数. 外循环每增加一次,内循环减少一次. 图形展示: function bubbleSort(arr){ for (var i = 0; i < arr.length; i++) { for (var j = 0; j< arr.length-i-1; j

十大经典排序算法的JS版

排序对比: 排序对比.jpg 排序分类: 排序分类.jpg 冒泡排序(Bubble Sort) 冒泡排序是一种简单的排序算法,它重复的走访要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来,走访数列的工作是重复的进行直到没有再需要交换,也就是说数列已经排序完成,这个算法的名字的由来是因为越小的元素会精油交换慢慢浮到数列的顶端. 1.初级版 function bubbleSort(array) { const length = array.length; for (let i =

排序算法之js实现回顾

1. 时间复杂度就是while的次数,二分查找O(h)=O(log2n) 2. 节点的广度优先遍历 function traverse(root){ const queue = [root]; while(queue.length){ const node = queue.shift(); printInfo(node); if(!node.children.length){ continue; } Array.from(node.children).forEach(x=>queue.push(

8大排序算法总结 JS 实现

//bubble sort function bubbleSort(arr,comp){ for(var i = 0;i < arr.length; i++){ for(var j = 0; j < arr.length - i - 1; j++){ if(comp(arr[j],arr[j+1])){ exch(arr,j,j+1); } } } } function exch(a,i,j){ var tmp = a[i]; a[i] = a[j]; a[j] = tmp; } var in

JavaScript版几种常见排序算法

今天发现一篇文章讲“JavaScript版几种常见排序算法”,看着不错,推荐一下原文:http://www.w3cfuns.com/blog-5456021-5404137.html 算法描述: * 冒泡排序:最简单,也最慢,貌似长度小于7最优* 插入排序: 比冒泡快,比快速排序和希尔排序慢,较小数据有优势* 快速排序:这是一个非常快的排序方式,V8的sort方法就使用快速排序和插入排序的结合* 希尔排序:在非chrome下数组长度小于1000,希尔排序比快速更快* 系统方法:在forfox下系

JS 排序算法整理

关于排序算法的问题可以在网上搜到一大堆,但是纯 JS 版比较零散,之前面试的时候特意整理了一遍,附带排序效率比较. //1.冒泡排序 var bubbleSort = function(arr) { for (var i = 0, len = arr.length; i < len - 1; i++) { for (var j = i + 1; j < len; j++) { if (arr[i] > arr[j]) { var temp = arr[i]; arr[i] = arr[j