javascript数据结构与算法--基本排序算法（冒泡、选择、排序）及效率比较

最新推荐文章于 2024-11-07 13:38:59 发布
最新推荐文章于 2024-11-07 13:38:59 发布
阅读量91 收藏
点赞数
文章标签： javascript 数据结构与算法 ViewUI

javascript数据结构与算法--基本排序算法（冒泡、选择、排序）及效率比较

一、数组测试平台。

javascript数据结构与算法--基本排序（封装基本数组的操作），封装常规数组操作的函数，比如：插入新数据，显示数组数据，还有交换数组元素等操作来调用不同的排序算法

 

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;//是一个索引值，默认为0，从第一个开始
    this.numElements = numElements;//是保存所有的数组元素
    this.insert = insert;//向数组中插入一个元素的方法
    this.toString = toString;//显示数组中所有元素
    this.clear = clear;//清空数组数据
    this.setData = setData;//生成了存储在数组中的随机数字
    this.swap = swap;//交换数组中两个元素的位置
    this.bubbleSort = bubbleSort;
    /*将传入的数组，存储在datastore中*/
    for (var i = 0; i < numElements.length; ++i) {
        this.dataStore[i] = numElements[i];
    }
}

function setData() {
    for (var i = 0; i < this.numElements; ++i) {
        this.dataStore[i] = Math.floor(Math.random() *
            (this.numElements+1));
    }
}

function clear() {
    for (var i = 0; i < this.dataStore.length; ++i) {
        this.dataStore[i] = 0;
    }
}

function insert(element) {
    this.dataStore[this.pos++] = element;
}

function toString() {
    var retstr = "";
    for (var i = 0; i < this.dataStore.length; ++i) {
        retstr += this.dataStore[i] + " ";
        if (i > 0 && i % 10 == 0) {
            retstr += "\n";
        }
    }
    return retstr;
}

function swap(arr, index1, index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}
//测试生成一组数组数据（随机数）
var numElements = 100;
var myNums = new CArray(numElements);
myNums.setData();
console.log(myNums.toString());
17 94 81 80 25 24 73 76 24 35 81 
63 81 59 4 76 30 47 73 98 18 
54 36 53 47 22 60 88 41 66 24 
73 94 40 45 72 74 14 61 92 48 
36 12 42 11 12 82 24 84 60 1 
17 98 63 36 84 13 18 50 89 26 
98 1 6 54 52 69 6 52 98 14 
79 28 19 69 76 99 97 100 10 7 
24 54 81 73 18 21 45 73 66 30 
28 56 54 21 88 31 20 86 48

 

二、冒泡排序算法

我们先来了解一下冒泡排序算法，它是最慢的排序算法之一，但也是一种最容易实现的排序算法。
之所以叫冒泡排序是因为使用这种排序算法排序时，数据值会像气泡一样从数组的一端漂浮到另一端。
假设正在将一组数字按照升序排列，较大的值会浮动到数组的右侧，而较小的值则会浮动到数组的左侧。
之所以会产生这种现象是因为算法会多次在数组中移动，比较相邻的数据，当左侧值大于右侧值时将它们进行互换。

JS代码如下：

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;//是一个索引值，默认为0，从第一个开始
    this.numElements = numElements;//是保存所有的数组元素
    this.insert = insert;//向数组中插入一个元素的方法
    this.toString = toString;//显示数组中所有元素
    this.clear = clear;//清空数组数据
    this.setData = setData;//生成了存储在数组中的随机数字
    this.swap = swap;//交换数组中两个元素的位置
    this.bubbleSort = bubbleSort;//冒泡算法
    /*将传入的数组，存储在datastore中*/
    for (var i = 0; i < numElements.length; ++i) {
        this.dataStore[i] = numElements[i];
    }
}

function setData() {
    for (var i = 0; i < this.numElements; ++i) {
        this.dataStore[i] = Math.floor(Math.random() *
            (this.numElements+1));
    }
}

function clear() {
    for (var i = 0; i < this.dataStore.length; ++i) {
        this.dataStore[i] = 0;
    }
}

function insert(element) {
    this.dataStore[this.pos++] = element;
}

function toString() {
    var retstr = "";
    for (var i = 0; i < this.dataStore.length; ++i) {
        retstr += this.dataStore[i] + " ";
        if (i > 0 && i % 10 == 0) {
            retstr += "\n";
        }
    }
    return retstr;
}

function swap(arr, index1, index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

function bubbleSort() {
    var numElements = this.dataStore.length;
    for (var outer = numElements; outer >= 2; --outer) {
        for (var inner = 0; inner <= outer-1; ++inner) {
            if (this.dataStore[inner] > this.dataStore[inner+1]) {
                swap(this.dataStore, inner, inner+1);
            }
        }
        console.log("outer为" + outer + ": " +  this.toString());
    }
}

//测试冒泡排序算法
var numElements = [2,4,1,3];
var myNums = new CArray(numElements);
console.log("原来的数组："+myNums.toString());
myNums.bubbleSort();
console.log("排序后的数组："+myNums.toString());
冒泡算法代码分析如下：

原先数组为 [2,4,1,3];

1. outer为4的时候
    1. inner为0，值为2，inner+1为1，值为4，不符合，不交换。
    2. inner为1，值为4，inner+1为2，值为1，交换，数组变为[2,1,4,3]
    3. inner为2，值为4，inner+1为3，值为3，交换 数组变为[2,1,3,4]
    4. inner为3，值为4，inner+1为4，不符合 不交换。 

2. outer为3的时候
    1. inner为0，值为2，inner+1为1，值为1,交换 数组变为[1,2,3,4]
    2. inner为1, 值为2，inner+1为2，值为3 不符合 不交换。
    3. inner为2, 值为3，inner+1为3，值为4，不符合 不交换。

 再下面继续循环都不符合条件，所以如上就是最后一步了。这就是冒泡排序。

 

三、选择排序算法

选择排序从数组的开头开始，将第一个元素和其他元素进行比较。
检查完所有元素后，最小的元素会被放到数组的第一个位置，然后算法会从第二个位置继续。
这个过程一直进行，当进行到数组的倒数第二个位置时，所有的数据便完成了排序。

选择排序会用到嵌套循环。
外循环从数组的第一个元素移动到倒数第二个元素；
内循环从第二个数组元素移动到最后一个元素，查找比当前外循环所指向的元素小的元素。
每次内循环迭代后，数组中最小的值都会被赋值到合适的位置。

JS代码如下：

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;//是一个索引值，默认为0，从第一个开始
    this.numElements = numElements;//是保存所有的数组元素
    this.insert = insert;//向数组中插入一个元素的方法
    this.toString = toString;//显示数组中所有元素
    this.clear = clear;//清空数组数据
    this.setData = setData;//生成了存储在数组中的随机数字
    this.swap = swap;//交换数组中两个元素的位置
    this.selectionSort = selectionSort;//选择排序算法
    /*将传入的数组，存储在datastore中*/
    for (var i = 0; i < numElements.length; ++i) {
        this.dataStore[i] = numElements[i];
    }
}

function setData() {
    for (var i = 0; i < this.numElements; ++i) {
        this.dataStore[i] = Math.floor(Math.random() *
            (this.numElements+1));
    }
}

function clear() {
    for (var i = 0; i < this.dataStore.length; ++i) {
        this.dataStore[i] = 0;
    }
}

function insert(element) {
    this.dataStore[this.pos++] = element;
}

function toString() {
    var retstr = "";
    for (var i = 0; i < this.dataStore.length; ++i) {
        retstr += this.dataStore[i] + " ";
        if (i > 0 && i % 10 == 0) {
            retstr += "\n";
        }
    }
    return retstr;
}

function swap(arr, index1, index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

function selectionSort() {
    var min, temp;
    for (var outer = 0; outer <= this.dataStore.length-2; ++outer) {
        min = outer;
        for (var inner = outer + 1;inner <= this.dataStore.length-1; ++inner) {
            if (this.dataStore[inner] < this.dataStore[min]) {
                min = inner;
            }
        }
        swap(this.dataStore, outer, min);
        console.log("第"+outer +"次："+myNums.toString());
    }
}

//测试排序算法
var numElements = [2,4,1,3];
var myNums = new CArray(numElements);
console.log("原来的数组："+myNums.toString());
myNums.selectionSort();
console.log("排序后的数组："+myNums.toString());
原来的数组：2 4 1 3 
第0次：1 4 2 3 
第1次：1 2 4 3 
第2次：1 2 3 4 
排序后的数组：1 2 3 4

四、插入排序算法

插入排序有两个循环。
外循环将数组元素挨个移动，而内循环则对外循环中选中的元素及它前面的那个元素进行比较。
如果外循环中选中的元素比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;//是一个索引值，默认为0，从第一个开始
    this.numElements = numElements;//是保存所有的数组元素
    this.insert = insert;//向数组中插入一个元素的方法
    this.toString = toString;//显示数组中所有元素
    this.clear = clear;//清空数组数据
    this.setData = setData;//生成了存储在数组中的随机数字
    this.swap = swap;//交换数组中两个元素的位置
    this.insertionSort = insertionSort;//插入排序算法
    /*将传入的数组，存储在datastore中*/
    for (var i = 0; i < numElements.length; ++i) {
        this.dataStore[i] = numElements[i];
    }
}

function setData() {
    for (var i = 0; i < this.numElements; ++i) {
        this.dataStore[i] = Math.floor(Math.random() *
            (this.numElements+1));
    }
}

function clear() {
    for (var i = 0; i < this.dataStore.length; ++i) {
        this.dataStore[i] = 0;
    }
}

function insert(element) {
    this.dataStore[this.pos++] = element;
}

function toString() {
    var retstr = "";
    for (var i = 0; i < this.dataStore.length; ++i) {
        retstr += this.dataStore[i] + " ";
        if (i > 0 && i % 10 == 0) {
            retstr += "\n";
        }
    }
    return retstr;
}

function swap(arr, index1, index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

function insertionSort() {
    var temp, inner;
    //外循环将数组元素挨个移动
    for (var outer = 1; outer <= this.dataStore.length-1; ++outer) {
        temp = this.dataStore[outer];//外循环选中的元素temp
        inner = outer;
        //内循环对外循环中选中的元素temp与temp前面的元素一个个进行比较。
        //如果外循环中选中的元素temp比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置
        while (inner > 0 && (this.dataStore[inner-1] >= temp)) {
            this.dataStore[inner] = this.dataStore[inner-1];
            --inner;
        }
        this.dataStore[inner] = temp;
        console.log("第"+outer+"次："+myNums.toString());
    }
}

//测试排序算法
var numElements = [9,1,8,6,2,3,5,4];
var myNums = new CArray(numElements);
console.log("原来的数组："+myNums.toString());
myNums.insertionSort();
console.log("排序后的数组："+myNums.toString());
  原来的数组：9 1 8 6 2 3 5 4 //先用1和1前面的对比，9比1大，所以9向右移动一个位置，给1腾位置
      第1次：1 9 8 6 2 3 5 4 //用8与8前面的对比，9比8大，所以9向右移动一个位置，给8腾位置
      第2次：1 8 9 6 2 3 5 4 //用6与6前面的对比,8，9比6大，所以8、9向右移动一个位置，给6腾位置
      第3次：1 6 8 9 2 3 5 4 
      第4次：1 2 6 8 9 3 5 4 
      第5次：1 2 3 6 8 9 5 4 
      第6次：1 2 3 5 6 8 9 4 
      第7次：1 2 3 4 5 6 8 9 
排序后的数组：1 2 3 4 5 6 8 9

 

五、基本排序算法的效率比较

function CArray(numElements) {
    this.dataStore = [];
    this.pos = 0;//是一个索引值，默认为0，从第一个开始
    this.numElements = numElements;//是保存所有的数组元素
    this.insert = insert;//向数组中插入一个元素的方法
    this.toString = toString;//显示数组中所有元素
    this.clear = clear;//清空数组数据
    this.setData = setData;//生成了存储在数组中的随机数字
    this.swap = swap;//交换数组中两个元素的位置
    this.bubbleSort = bubbleSort;//冒泡排序算法
    this.selectionSort = selectionSort;//选择排序算法
    this.insertionSort = insertionSort;//插入排序算法
    /*将传入的数组，存储在datastore中*/
    for (var i = 0; i < numElements.length; ++i) {
        this.dataStore[i] = numElements[i];
    }
}

function setData() {
    for (var i = 0; i < this.numElements; ++i) {
        this.dataStore[i] = Math.floor(Math.random() *
            (this.numElements+1));
    }
}

function clear() {
    for (var i = 0; i < this.dataStore.length; ++i) {
        this.dataStore[i] = 0;
    }
}

function insert(element) {
    this.dataStore[this.pos++] = element;
}

function toString() {
    var retstr = "";
    for (var i = 0; i < this.dataStore.length; ++i) {
        retstr += this.dataStore[i] + " ";
        if (i > 0 && i % 10 == 0) {
            retstr += "\n";
        }
    }
    return retstr;
}

function swap(arr, index1, index2) {
    var temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

function bubbleSort() {
    var numElements = this.dataStore.length;
    for (var outer = numElements; outer >= 2; --outer) {
        for (var inner = 0; inner <= outer-1; ++inner) {
            if (this.dataStore[inner] > this.dataStore[inner+1]) {
                swap(this.dataStore, inner, inner+1);
            }
        }
//        console.log("outer为" + outer + ": " +  this.toString());
    }
}

function selectionSort() {
    var min, temp;
    for (var outer = 0; outer <= this.dataStore.length-2; ++outer) {
        min = outer;
        for (var inner = outer + 1;inner <= this.dataStore.length-1; ++inner) {
            if (this.dataStore[inner] < this.dataStore[min]) {
                min = inner;
            }
        }
        swap(this.dataStore, outer, min);
//        console.log("第"+outer +"次："+this.toString());
    }
}

function insertionSort() {
    var temp, inner;
    //外循环将数组元素挨个移动
    for (var outer = 1; outer <= this.dataStore.length-1; ++outer) {
        temp = this.dataStore[outer];//外循环选中的元素
        inner = outer;
        //内循环则对外循环中选中的元素与它前面的那个元素进行比较。
        //如果外循环中选中的元素比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置
        while (inner > 0 && (this.dataStore[inner-1] >= temp)) {
            this.dataStore[inner] = this.dataStore[inner-1];
            --inner;
        }
        this.dataStore[inner] = temp;
//        console.log("第"+outer+"次："+this.toString());
    }
}

/*测试冒泡、选择、插入算法的效率*/
var numElements = 10000;
var nums = new CArray(numElements);
nums.setData();
var start = new Date().getTime();
nums.bubbleSort();
var stop = new Date().getTime();
var elapsed = stop - start;
console.log("用冒泡算法，排序 " + numElements + " 个元素耗时 : " + elapsed + " milliseconds.");

start = new Date().getTime();
nums.selectionSort();
stop = new Date().getTime();
elapsed = stop - start;
console.log("用选择算法，排序 " + numElements + " 个元素耗时: " +  elapsed + " milliseconds.");

start = new Date().getTime();
nums.insertionSort();
stop = new Date().getTime();
elapsed = stop - start;
console.log("用插入算法，排序 " + numElements + " 个元素耗时: " + elapsed + " milliseconds.");

 

运行结果：

 

 选择排序和插入排序要比冒泡排序快，插入排序是这三种算法中最快的。

 

 

weixin_33884611
关注
JS中数据结构与算法---排序算法(Sort Algorithm)实例详解
10-16
在JavaScript中，数据结构与算法是提升程序效率和优化代码的关键。排序算法是其中的核心部分，用于将一组数据按照特定顺序进行排列。本文将详细解释排序算法的概念、分类及其时间复杂度。 首先，排序算法是一种将...
JavaScript-使用javascript开发的排序算法-sorting.zip
02-25
在这个"JavaScript-使用javascript开发的排序算法-sorting.zip"压缩包中，很可能是包含了各种常见的排序算法实现，比如冒泡排序、插入排序、选择排序、快速排序、归并排序以及堆排序等。 1. **冒泡排序**：冒泡排序...
数据结构排序算法之冒泡
12-18 95
l算法介绍 冒泡排序也叫起泡排序，它是通过一系列的”交换”动作完成的。首先第一个记录和第二个记录比较，如果第一个比较大，则二者进行交换，否则不交换；然后第二个和第三个进行比较，如果第二个比较大，则二者交换，否则不交换···一直按照这种方式排序下去，最终最大的那个数据将被排到最后的位置...
js常用的两种排序方式（冒泡和选择）
moanuan的博客
12-04 190
js常用的两种排序方式（冒泡和选择） 冒泡排序 var arr1 = [12,35,48,10,26]; var a; function fn(arr){ for(var x=0;x<arr.length;x++){ //外层循环控制交换的总轮数 for(var y=0;y<arr.length-x-1;y++){ //内循环进行本位和下一位的对比 if(arr[y]>arr[...
js版数据结构与算法—5.1冒泡排序
jiaojsun的博客
05-05 163
https://www.jianshu.com/p/f4cca5ce055a 循环的次数 时间复杂度 占用的内存 空间复杂度 为了方便理解 5274631 （a）5和2比较=》沉（2574631）， 2和7比较=》不动（2574631），7和4比较=》沉（2547631），7和6比较=》沉（2546731）,7和3比较=》沉（2546371）,7和1比较=》沉（...
JavaScript数据结构与算法-排序全详解
qq_45859670的博客
08-23 955
因此，算法将会使用10个桶用来分布元素并且基于个位数字进行排序、然后十位、然后百位以此类推。分别设i和j从左右开始寻找，从左边找到第一个比基数大的数，从右边找到第一个比基数小的数，然后交换这两个数。选择排序大致的思路是找到数据结构中的最小值并将其放置到第一位，接着找到第二小的值并将其放在第二位。1、选定一个基准数，要使得基数的左边的数字全部小于它，右边的数字全部大于它。基数排序也是一个分布式算法，根据数组的有效位或基数将整数分不到桶中。2、对每个桶进行插入排序算法和将所有桶并为排序后的结果数组。
数据结构与算法--javascript（持续更新中...）
du_aitiantian的博客
07-05 1370
数据结构与算法
【数据结构】排序算法(冒泡排序、选择排序) 用JavaScript实现
南栀的博客
05-16 184
排序算法：冒泡排序选择排序 冒泡排序 数组元素依次进行两两比较，若两个元素存在大小关系就进行交换，直到数组有序 /* 冒泡排序——从小到大进行排序 */ var arr = [10,7,5,27,98,31] console.log("排序前的数组元素:") console.log(arr) for(var i=0;i<arr.length;i++){ for(var j=0;j<arr.length-1-i;j++){ if(arr[j+1]<arr[j]){
JS数据结构与算法.pdf
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
JavaScript算法学习之冒泡排序和选择排序
12-13
前言 算法与数据结构构成了程序，数据结构用于实现数据的表示、存储、管理，算法通过使用数据完成一定的业务逻辑与操作，最终实现了程序的功能。因此算法在编程中的重要性是不言而喻的。很多复杂的算法都是借助最基本的算法实现的。本文主要选取经典排序算法中的冒泡排序与选择排序对JavaScript编程实现算法进行简单描述与说明。 程序算法 算法说明 算法（Algorithm）是解决问题的一种策略机制，算法也是有限操作指令的集合。按照算法策略输入符合要求的数据，最终获得解决问题的输出结果。冒泡算法与选择算法主要用于实现对无序的数字集合进行排序。算法描述分别如下： 1、冒泡排序算法 冒泡算法顾名思义，可以将
JavaScript 数据结构与算法十大经典排序算法-冒泡排序(一)
DreamFive
08-02 209
实现原理 简单来说就是实现的思想 冒泡排序只会操作相邻的两个数据 每次冒泡操作都会对相邻两个元素进行比较，看是否满足大小关系要求。如果不满足就让他俩互换 一次冒泡会让至少一个元素移动到它应该再度位置，重复 n 次，就完成了 n 个数据的排序工作 特点 优点：排序算法的基础，简单使用易于理解 缺点：比较次数多，效率较低 实现 //冒泡排序（未优化） const buddleSort = ar...
JavaScript 生成二维码
qq_30049249的博客
11-02 250
我试过了，这一款js库支持中英文混合。进入网站后，可以直接点击运行哟～
软件测试学习笔记丨Vue常用指令-条件渲染（v-if）
ceshiren_com的博客
11-05 580
v-show只是简单控制dom元素的display属性。v-if通过操纵dom元素来进行切换显示。
上门理发系统的搭建
最新发布
app830的博客
11-07 311
上门理发系统的搭建涉及多个方面，包括技术架构、功能模块、用户体验以及运营策略等。服务器：部署应用到云服务器（如AWS、阿里云）或本地服务器上，确保系统的稳定性和可扩展性。消息通知：通过短信、邮件或APP推送等方式，向用户发送预约确认、提醒等消息。订单管理：用户可以查看自己的预约订单，包括待付款、已付款、已完成等状态。服务浏览与选择：展示各类理发服务，包括价格、时长、适用人群等信息。在搭建过程中，要确保系统的安全性和稳定性，防止数据泄露和系统崩溃。操作便捷：优化用户操作流程，减少不必要的步骤，提高用户体验。
vxe-grid ，增加新行，并且定位到新增的行
花花鱼的专栏
11-05 200
vxe-grid新增空行，并且定位到空行位置。
JavaScript数据类型- BigInt详解（处理任意大小整数的终极指南）
cx18333的博客
11-05 511
随着ECMAScript 11（ES11）引入了BigInt，JavaScript开发者现在可以轻松地处理超出传统Number类型限制的大整数。本文全面解析了BigInt的使用方法、核心特性和限制条件，为你提供了处理大型整数数据的强大工具。从BigInt的基础用法到算术运算和比较，再到类型检查和兼容性考量，一步步的深入了解这个新的数据类型。
Vue2+3
m0_73557953的博客
11-04 129
创建Vue实例 Vue指令
JavaScript-数组
weixin_64689713的博客
11-04 866
/ 定义一个长度为 4 的数组，但是这 4 项都是 undefined两种定义方法根据实际需求选择即可，两者的底层都是同样的实现逻辑。推荐：方括号定义法！
情怀系列国际版棋牌完整源码具备强大的多语言扩展功能，涵盖了900多款子游戏，专为全球市场的游戏开发和运营设计。
z926098的博客
11-05 380
客户端使用Cocos Creator进行跨平台开发，可以发布为App、H5网页和PC网页。这种跨平台的能力使运营商只需维护一套代码，就能同时管理多个终端。除此之外，系统还支持产品的热更新功能，大幅提升运营效率并降低成本，实现了产品层面的“降维打击”。情怀棋牌源代码的服务器端使用JAVA和Node.js开发，采用RocketMQ作为消息队列中间件，有效防止服务器堵塞、消峰。该源码包涵盖了完整的服务器端代码、服务端900款子游戏源码、客户端代码、客户端700款子游戏、管理后台代码、数据库以及热更新生成脚本等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值