本文阐述了JavaScript数据结构和算法的基本排序算法定义和效率比较。分享给大家参考，如下：

Javascript数据结构和算法-基本排序算法(冒泡、选择、排序)和效率比较

一、阵列测试平台

Javascript数据结构和算法-基本排序(封装基本数组的操作)，封装常规数组操作的函数，例如插入新数据、显示数组数据以及交换数组元素以调用不同的排序算法

函数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/*将传入阵列存储在数据存储区*/for(var I=0；i numElements.lengthI){ this . datastore[I]=NuMelements[I]；} }函数setData(){ for(var I=0；我这个. this.numElementsI){ this . datastore[I]=math . floor(math . random()*(this . numelements 1))；} }函数clear(){ for(var I=0；I this . Datastore . length；I){ this . Datastore[I]=0；} }函数insert(element){ this . datastore[this . pos]=element；}函数ToString(){ var retstr=' '；for(var I=0；I this . Datastore . length；I){ ret str=this . Datastore[I]' '；if(I 0 I % 10==0){ ret str=' n '；} } return retstr}函数交换(arr，index1，index 2){ var temp=arr[index 1]；arr[index 1]=arr[index 2]；arr[index 2]=temp；}//测试生成一组数组数据(随机数)var numElements=100var MyNums=new Carray(NuMelements)；mynums . setdata()；console . log(mynums . tostring())；17 94 81 80 25 24 73 76 24 35 8163 81 59 4 76 30 47 73 98 1854 36 53 47 22 60 88 41 66 2473 94 40 45 72 74 14 61 92 4836 12 42 11 12 82 24 84 60 117 98 63 36 84 13 18 50 89 2698 1 6 54 52 69 6 52 98 1479 28 19 69 76 99 97 100 10 724 54 81 73 18 21 45 73 66 3028 56 54 21 88 31 20 86 48

二、气泡排序算法

我们来看看冒泡排序算法，它是最慢的排序算法之一，但也是最容易实现的排序算法。

之所以调用冒泡排序，是因为当使用这种排序算法进行排序时，数据值会像冒泡一样从数组的一端浮动到另一端。

假设您正在按升序对一组数字进行排序，较大的值将浮动到数组的右侧，而较小的值将浮动到数组的左侧。

出现这种现象的原因是算法在数组中移动多次，比较相邻的数据，当左值大于右值时进行互换。

JS代码如下：

函数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//冒泡算法/i numElements.lengthI){ this . datastore[I]=NuMelements[I]；} }函数setData(){ for(var I=0；我这个. this.numElementsI){ this . datastore[I]=math . floor(math . random()*(this . numelements 1))；} }函数clear(){ for(var I=0；I this . Datastore . length；I){ this . Datastore[I]=0；} }函数insert(element){ this . datastore[this . pos]=element；}函数ToString(){ var retstr=' '；for(var I=0；I this . Datastore . length；I){ ret str=this . Datastore[I]' '；if(I 0 I % 10==0){ ret str=' n '；} } return retstr}函数交换(arr，index1，index 2){ var temp=arr[index 1]；arr[index 1]=arr[index 2]；arr[index 2]=temp；} function bubbleSort(){ var numElements=this . datastore . length；for(var outer=NuMelements；outer=2；-outer){ for(var inner=0；inner=outer-1；内部){ 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，value为2，inner 1为1，value为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。内部为3，值为4，

2.当outer为3时

1.inner为0，值为2，inner 1为1，值为1，交换数组变成[1，2，3，4] 2。inner是1，value 2，inner 1是2，value 3不符合非交换。3.内部为2，值为3，内部1为3，值为4，不一致，不交换。

继续下面的循环不符合要求，所以上面是最后一步。这就是泡沫排序。

第三，选择排序算法

选择从数组的开头开始排序，并将第一个元素与其他元素进行比较。

检查完所有元素后，最小的元素将被放在数组的第一个位置，然后算法将从第二个位置继续。

这个过程一直在进行。当它到达数组的倒数第二个位置时，所有数据都被排序。嵌套循环用于选择排序。

外部循环从数组的第一个元素移动到倒数第二个元素；

内部循环从第二个数组元素移动到最后一个元素，寻找比当前外部循环所指向的元素小的元素。

在内部循环的每次迭代之后，数组中的最小值将被分配到适当的位置。

JS代码如下：

函数这是。data store=[]；这个。pos=0；//是一个索引值，默认为0,从第一个开始this.numElements=numElements//是保存所有的数组元素this.insert=insert//向数组中插入一个元素的方法this.toString=toString//显示数组中所有元素this.clear=clear//清空数组数据this.setData=setData//生成了存储在数组中的随机数字this.swap=swap//交换数组中两个元素的位置这个。selectionstart=selectionstart//选择排序算法/*将传入的数组，存储在数据存储中*/for(var I=0；这个。数据存储[I]=NuMelements[I]；} }函数setData(){ for(var I=0；我这个。this.numElementsI){ this。数据存储[I]=数学。地板(数学。random()*(这个。numelements 1))；} }函数clear(){ for(var I=0；我喜欢这个。数据存储。长度；我){这个。数据存储[I]=0；} }函数插入(元素){ this。数据存储[这个。pos]=元素；}函数ToString(){ var retstr=' '；for(var I=0；我喜欢这个。数据存储。长度；I){ ret str=这个。数据存储[I]' '；if(I 0 I % 10==0){ ret str=' n '；} }返回retstr}函数交换(arr，index1，index 2){ var temp=arr[index 1]；arr[索引1]=arr[索引2]；arr[索引2]=temp；}函数selectionstart(){ var min，temp for(var outer=0；outer=这个。数据存储。长度-2；outer){ min=outer；for(var inner=outer 1；内心=这个。数据存储。长度-1；内部){如果(这个。数据存储[内部]这个。datastore[min]){ min=inner；} }交换(this.dataStore，外部，最小值)；console.log('第外部次：' MyNums。ToString())；}}//测试排序算法var numElements=[2，4，1，3]；var MyNums=new Carray(NuMelements)；console.log('原来的数组：' MyNums。ToString())；mynums。selection sort()；console.log('排序后的数组：' MyNums。ToString())；原来的数组：2 4 1 3第0次：1 4 2 3第一次：1 2 4 3第2次：1 2 3 4排序后的数组：1 2 3 4

四、插入排序算法

插入排序有两个循环。

外循环将数组元素挨个移动，而内循环则对外循环中选中的元素及它前面的那个元素进行比较。

如果外循环中选中的元素比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置

函数这是。data store=[]；这个。pos=0；//是一个索引值，默认为0,从第一个开始this.numElements=numElements//是保存所有的数组元素this.insert=insert//向数组中插入一个元素的方法this.toString=toString//显示数组中所有元素this.clear=clear//清空数组数据this.setData=setData//生成了存储在数组中的随机数字this.swap=swap//交换数组中两个元素的位置这个。insertionSort=insertionSort//插入排序算法/*将传入的数组，存储在数据存储中*/for(var I=0；这个。数据存储[I]=NuMelements[I]；} }函数setData(){ for(var I=0；我这个。this.numElementsI){ this。数据存储[I]=数学。地板(数学。random()*(这个。numelements 1))；} }函数clear(){ for(var I=0；我喜欢这个。数据存储。长度；我){这个。数据存储[I]=0；} }函数插入(元素){ this。数据存储[这个。pos]=元素；}函数ToString(){ var retstr=' '；for(var I=0；我喜欢这个。数据存储。长度；I){ ret str=这个。数据存储[I]' '；if(I 0 I % 10==0){ ret str=' n '；} }返回retstr}函数交换(arr，index1，index 2){ var temp=arr[index 1]；arr[索引1]=arr[索引2]；arr[索引2]=temp；}函数insertionSort() { var temp，inner//外循环将数组元素挨个移动for(var outer=1；outer=这个。数据存储。长度-1；outer){ temp=this。数据存储[外部]；//外循环选中的元素温度内部=外部；//内循环对外循环中选中的元素临时雇员与临时雇员前面的元素一个个进行比较。 //如果外循环中选中的元素临时雇员比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置而(内部0(这个。数据存储[内部-1]=temp)){这个。数据存储[内部】=这个。数据存储[内部-1];-内心；}这个。数据存储[内部]=temp；console.log('第外部次：' MyNums。ToString())；}}//测试排序算法var numElements=[9，1，8，6，2，3，5，4]；var MyNums=new Carray(NuMelements)；console.log('原来的数组：' MyNums。ToString())；mynums。insertion sort()；console.log('排序后的数组：' MyNums。ToString())；原来的数组：9 1 8 6 2 3 5 4 //先用一和一前面的对比，9比一大，所以9向右移动一个位置，给一腾位置第一次：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 第四次：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 第七次：1 2 3 4 5 6 8 9排序后的数组：1 2 3 4 5 6 8 9

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

函数这是。data store=[]；这个。pos=0；//是一个索引值，默认为0,从第一个开始this.numElements=numElements//是保存所有的数组元素this.insert=insert//向数组中插入一个元素的方法this.toString=toString//显示数组中所有元素this.clear=clear//清空数组数据this.setData=setData//生成了存储在数组中的随机数字this.swap=swap//交换数组中两个元素的位置这个。起泡rt=起泡rt；//冒泡排序算法这个。selectionstart=selectionstart//选择排序算法这个。insertionSort=insertionSort//插入排序算法/*将传入的数组，存储在数据存储中*/for(var I=0；这个。数据存储[I]=NuMelements[I]；} }函数setData(){ for(var I=0；我这个。this.numElementsI){ this。数据存储[I]=数学。地板(数学。random()*(这个。numelements 1))；} }函数clear(){ for(var I=0；我喜欢这个。数据存储。长度；我){这个。数据存储[I]=0；} }函数插入(元素){ this。数据存储[这个。pos]=元素；}函数ToString(){ var retstr=' '；for(var I=0；我喜欢这个。数据存储。长度；I){ ret str=这个。数据存储[I]' '；if(I 0 I % 10==0){ ret str=' n '；} }返回retstr}函数交换(arr，index1，index 2){ var temp=arr[index 1]；arr[索引1]=arr[索引2]；arr[索引2]=temp；} function bubbleSort(){ var numElements=this。数据存储。长度；for(var outer=NuMelements；outer=2；-outer){ for(var inner=0；inner=outer-1；内部){如果(这个。数据存储[内部]这个。数据存储[内部1]){ swap(this。数据存储，内部，内部1)；} }//console.log('outer为外面的：这个。ToString())；} }函数selectionstart(){ var min，temp for(var outer=0；outer=这个。数据存储。长度-2；outer){ min=outer；for(var inner=outer 1；内心=这个。数据存储。长度-1；内部){如果(这个。数据存储[内部]这个。datastore[min]){ min=inner；} }交换(this.dataStore，外部，最小值)；//console.log('第外部次：“这个。ToString())；} }函数insertionSort() { var temp，inner//外循环将数组元素挨个移动for(var outer=1；outer=这个。数据存储。长度-1；outer){ temp=this。数据存储[外部]；//外循环选中的元素内部=外部；//内循环则对外循环中选中的元素与它前面的那个元素进行比较。 //如果外循环中选中的元素比内循环中选中的元素小，那么数组元素会向右移动，为外循环中的这个元素腾出位置而(内部0(这个。数据存储[内部-1]=temp)){这个。数据存储[内部】=这个。数据存储[内部-1];-内心；}这个。数据存储[内部]=temp；//console.log('第外部次：“这个。ToString())；}}/*测试冒泡、选择、插入算法的效率*/var numElements=10000；var nums=new Carray(NuMelements)；nums。setdata()；var start=新日期()。getTime()；nums。bubble sort()；var stop=新日期()。getTime()；定义变量已用=停止-启动；console.log('用冒泡算法，排序数字个元素耗时： '经过'毫秒');开始=新日期()。getTime()；nums。selection sort()；停止=新日期()。getTime()；消逝=停止-开始；console.log('用选择算法，排序数字个元素耗时： '经过'毫秒');开始=新日期()。getTime()；nums。insertion sort()；停止=新日期()。getTime()；消逝=停止-开始；console.log('用插入算法，排序数字个元素耗时： '经过'毫秒');运行结果：

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

感兴趣的朋友可以使用在线HTML/CSS/JavaScript代码运行工具：http://工具。JB 51。net/code/HTMljsrun测试上述代码运行效果。

PS:这里再为大家推荐一款关于排序的演示工具供大家参考：

在线动画演示插入/选择/冒泡/合并/希尔/快速排序过程工具：http://tools.jb51.net/aideddesign/paixu_ys

更多对JavaScript相关内容感兴趣的读者可以查看本网站专题：《JavaScript数学运算用法总结》、《JavaScript数据结构与算法技巧总结》、《JavaScript数组操作技巧总结》、《JavaScript排序算法总结》、《JavaScript遍历算法与技巧总结》、《JavaScript查找算法技巧总结》、《JavaScript错误与调试技巧总结》和0103010

希望本文对JavaScript编程有所帮助。