js排序算法

1. js排序问题怎么实现

你要给变量名排序? 这有什么意义呢? 只有值排序才是有意义的.而且,排序通常是使用集合或数组的情况,独立的变量不需要排序.

2. JS实现数组排序的方法有哪些

从给定的数据中，随机抽出一项，这项的左边放所有比它小的，右边放比它大的，然后再分别这两边执行上述操作，采用的是递归的思想，总结出来就是实现一层，分别给两边递归，设置好出口

functionfastSort(array,head,tail){
//考虑到给每个分区操作的时候都是在原有的数组中进行操作的，所以这里head,tail来确定分片的位置
/*生成随机项*/
varrandomnum=Math.floor(ranDom(head,tail));
varrandom=array[randomnum];
/*将小于random的项放置在其左边策略就是通过一个临时的数组来储存分好区的结果，再到原数组中替换*/
vararrayTemp=[];
varunshiftHead=0;
for(vari=head;i<=tail;i++){
if(array[i]<random){
arrayTemp.unshift(array[i]);
unshiftHead++;
}elseif(array[i]>random){
arrayTemp.push(array[i]);
}
/*当它等于的时候放哪，这里我想选择放到队列的前面，也就是从unshift后的第一个位置放置*/
if(array[i]===random){
arrayTemp.splice(unshiftHead,0,array[i]);
}
}
/*将对应项覆盖原来的记录*/
for(varj=head,u=0;j<=tail;j++,u++){
array.splice(j,1,arrayTemp[u]);
}
/*寻找中间项所在的index*/
varnowIndex=array.indexOf(random);

/*设置出口，当要放进去的片段只有2项的时候就可以收工了*/
if(arrayTemp.length<=2){
return;
}
/*递归，同时应用其左右两个区域*/
fastSort(array,head,nowIndex);
fastSort(array,nowIndex+1,tail);
}

javaScript实现多维数组、对象数组排序，其实用的就是原生的sort()方法，用于对数组的元素进行排序。

sort() 方法用于对数组的元素进行排序。语法如下：

arrayObject.sort(sortby)

例如：
functionNumAscSort(a,b)
{
returna-b;
}
functionNumDescSort(a,b)
{
returnb-a;
}
vararr=newArray(3600,5010,10100,801);
arr.sort(NumDescSort);
alert(arr);
arr.sort(NumAscSort);
alert(arr);

3. javascript中的冒泡排序法

AVA气泡分类法

拓展资料

气泡排序的原理是，有五个数字54321，例如从小到大排列。

首先比较前两个，5个和4个，如果第一个小于第二个，没有运算，如果第一个大于第二个，则交换两个位置，即45321个，然后第二个和第三个，交换位置，变成43521个，然后第三个和第四个，第四个和第五个，这样的时间周期下来，转向。进入43215

因此，一个循环的效果是挑选出最大的数字5并将其泡泡到底。但是选择第二，第三等等。因此，一层循环是不够的，它必须是另一层。例如，五个数字，至少四个周期。至于为什么这个，长度-i，是因为第一个比较五个数字，第二个只要第一个四将做，第五个必须是最大的。

var数组＝〔5， 4， 3，2， 1〕；

VATP＝0；

对于（var i＝0；i <数组，长度；i++）

{

对于（var j＝0；j<数组，长度-i；j++）

{

IF（数组[j] >数组[j+1]）

{

TEMP=数组[J＋1 ]；

数组[j+2]＝数组[j]；

数组[j]＝TEMP；

}

}

}

控制台，日志（数组）；

4. JS，排列，组合，实现方法

var arr = new Array(0,1,2,3,4,5,6,7,8,9); // 0-9 的数
var tempArr = new Array(3); // 取出的任意三个数
var count = 0; // 组合的个数
var resultStr = ""; // 最后打印出的结果

// 取到任意三个数
for(var i = 0; i < 3; i++){
tempArr[i] = arr[Math.floor(Math.random()*10)];
}

// 排列组合
for(var i = 0; i < 3; i++){
for(var j = 0; j < 3; j++){
for(var k = 0; k < 3; k++){
count++;
resultStr += tempArr[i] + "," + tempArr[j] + "," + tempArr[k] + ";\n";
}
}
}

alert(resultStr);

你试一下，上面这段，是你想要的不？
这可是我一个字一个字敲出来的啊！ 呵呵

5. 用Javascript写排序算法的动画演示

1.让JavaScript暂停下来，慢下来。
JavaScript排序是很快的，要我们肉眼能看到它的实现过程，我首先想到的是让排序慢下来。 排序的每一个循环都让它停300ms然后再继续进行。 怎么样才能停下来呢。查了一下JavaScript貌似没有sleep()这样的函数。暂停做不到，但是可以想办法让实现跟暂停差不多的效果。比如在循环里做一些无关的事情 。
首先尝试了让while(true)来一直执行一个空操作。执行一段时间再回到排序逻辑。代码大致是这样：
for (var i = 0; i < 3; i++) {
document.writeln(i); //DOM操作
var now = new Date().getTime();
while(new Date().getTime() - now < 3000){}
}

慢是慢下来了。不过太耗资源，排序进行过程中dom并不会有任何改变，直到排序结束， DOM会变成排序好之后的样子。 但是如果设置断点一步步执行的时候 又可以看到一步步的排序变化。估计是因为这个操作太耗资源导致浏览器下达了一个DOM操作的命令但是一直腾不出资源来进行DOM操作。所以真正DOM操作的时候在js代码执行结束之后。
所以让JavaScript排序慢来来还是没有实现。
另一种让JavaScript暂停下来的思路：
写这个文章的时候又想到一种方法来让JavaScript停下来。 那就是AJAX的同步请求，以及超时操作。 也就是在要停下来的地方放一个AJAX请求，同步请求， 然后设置超时。超时的时间就是我们要暂停的时间。为了避免在到达超时请求之前服务 器就返回了我们的AJAX请求。可以在服务端运行类似 sleep()的程序 。从而保证AJAX不会返回。直接超时然后返回到我们的循环。不过这只是个设想。有兴趣的可以去尝试一下。
2.闭包和定时器。 这种思路不需要让排序过程慢下来。而是使用闭包缓存排序过程中数组的变化。然后使用setTimeout来确定展示每一个数组状态的顺序。在排序循环中放入类似下面的代码。
(function(){
var theArr = arr.slice();//当前数组状态的备份
setTimeout(function(){
bubbleSortDom(theArr);//排序的DOM操作。
},500*timeCount);
timeCount++;//定时器的顺序。
})();

不过后来发现这样子写的话代码量会比较大，逻辑有修改的话要修改的地方会有点多。局限性很多，比如要实现排序动画加快或减慢操作几乎是很困难的。所以还要另想办法。
3.缓存排序中的数组状态。
也就是在排序过程中。将数组的每一轮循环的状态保存到一个数组。然后再用这个数组依次将排序状态保存下来。 只需要在排序中加入一句就行。
this.pushHis(arr.slice(),i-1,j,k,temp);

这样就只需要一个setInterval()就可以了。并且可以很方便的实现动画的加快与减慢。逻辑也比较好理解 。
问题二：如何实现JavaScript排序动画的加快与减慢。
我们问题一使用的第三种方法。 得到一个保存了每一步排序状态的数组arr。 然后我们可以使用一个setInterval()定时器一步步展现排序状态。 如果要加快速度或减慢速度。就clearInterval()，修改定时器的执行间隔，重新setInterval()，从前一个定时器执行到数组中的位置开始执行。
问题三：对于使用递归实现的数组怎么办？ 不是在原数组上进行操作的怎么办？
使用递归实现的排序。 可能并没有在一个数组上进行操作，只是最后返回一个排序好的数组出来。那么我们要如何获得排序中的数组的完整状态呢。
比如快速排序。
最开始不考虑动画，我的实现是这样的：
function quickSort(arr){
var len = arr.length,leftArr=[],rightArr=[],tag;
if(len<2){
return arr;
}
tag = arr[0];
for(i=1;i<len;i++){
if(arr[i]<=tag){
leftArr.push(arr[i])
}else{
rightArr.push(arr[i]);
}
}
return quickSort(leftArr).concat(tag,quickSort(rightArr));
}

然后为了考虑动画，我改写了它的逻辑，让它在同一个数组上进行了实现。 其实是在递归的时候传入了当前的的子数组在原数组中的起始位置。从而在原数组上进行了操作。
用了两种方法来实现方式。在排序逻辑上略有不同。
第一种是先跟远处的对比。遇到比自己小的放到自己前面去。循环序号+1。比自己大的放到当前排序子数组的最后面去，循环序号不变。直到排列完成。
这种方法的缺点是即使是一个有序数组。它也会重新排。
第二种方法是 除了标记位，再设置一个对比位。 遇到比自己小的，放到前面去，标记位的位置+1，标记位与对比位之间所有的往后面移动一个位置。
遇到比自己大的。标记位不变，对比位+1。
这种方法的缺点是对数组进行的操作太多。优点是对有序数组不会再排。
方式一：
function quickSort(arr,a,b,qArr){

var len = arr.length,leftArr=[],rightArr=[],tag,i,k,len_l,len_r,lb,ra,temp;
if(a == undefined && b == undefined){
a = 0; b= arr.length-1;//初始化起始位置。
}
if(qArr == undefined){
qArr = arr.slice();
}

if((len == 2 && arr[0] == arr[1])||len<2){
return arr;
}

tag = qArr[a];
for (i = 1; i < len;) {
if(qArr[a+i]<=tag){
leftArr.push(qArr[a+i]);
qArr[a+i-1] = qArr[a+i];
qArr[a+i] = tag;
k = a+i;
i++;
}else{
if(leftArr.length+rightArr.length == len-1){
break;
}
temp = qArr[a+i];
qArr[a+i] = qArr[b-rightArr.length];
qArr[b-rightArr.length] = temp;
rightArr.push(temp);
k = a+i-1;
}
this.pushHis(qArr.slice(),a,b,k);
}

len_l = leftArr.length;
len_r = rightArr.length;
if(len_l== 0){
lb = a;
}else{
lb = a+len_l -1;
this.sort(leftArr,a,lb,qArr);
}

if(len_r == 0){
ra = b;
}else{
ra = b + 1 - len_r;
this.sort(rightArr,ra,b,qArr)
}
return qArr
}

方式二：
function quickSort2(arr,a,b,qArr){
var len = arr.length,leftArr=[],rightArr=[],tag,i,j,k,temp,len_l,len_r,lb,ra;
if(a == undefined && b == undefined){
a = 0; b= arr.length-1;//初始化起始位置。
}
if(qArr == undefined){
qArr = arr.slice();
}
if(len<2){
return arr;
}
if(len == 2 && arr[0] == arr[1]){
return arr;
}
tag = qArr[a];
for (i = 1,k = 0; i < len;) {
if(qArr[a+i]>=tag){
rightArr.push(qArr[a+i]);
i++;
}else{
temp = qArr[a+i];
for(j = a+i;j>a+k;j--){
qArr[j] = qArr[j-1];
// this.pushHis(qArr.slice(),a,b,a+k);
}
qArr[a+k] = temp;
leftArr.push(temp);
k++;
i++;
}
this.pushHis(qArr.slice(),a,b,a+k,i-1);
}
len_l = leftArr.length;
len_r = rightArr.length;
if(len_l== 0){
lb = a;
}else{
lb = a+len_l -1;
this.sort(leftArr,a,lb,qArr);
}
if(len_r == 0){
ra = b;
}else{
ra = b + 1 - len_r;
this.sort(rightArr,ra,b,qArr)
}
return qArr;
}

具体的不同下面会有动画演示。
问题四：动画的流畅。
排序动画的DOM操作是很多的很快的。这里我做的优化只是让每一个排序步骤只涉及一个DOM操作。 全部由JavaScript拼接好，一次替换。类似下面的代码。
效果图：

主要实现了：
冒泡排序JavaScript动画演示
插入排序JavaScript动画演示
选择排序JavaScript动画演示
快速排序JavaScript动画演示
归并排序JavaScript动画演示
希尔排序JavaScript动画演示

6. js sort方法是什么排序

这个排序这进行两两比较.
比如你这个数组按升序排列var arrA = [6,2,4,3,5,1];
第一次比较6,2
6比2大得到2,6
原数组变成[2,6,4,3,5,1]

第2次比较第2个和第3个数,6和4.
6比4大,得到4,6
结果[2,4,6,3,5,1]

第3次比较第3个和第4个数6和3.
得到[2,4,3,6,5,1]

第4次[2,4,3,5,6,1]
第5次[2,4,3,5,1,6]
第一轮完毕

第二轮
第6次,2比4小,不变[2,4,3,5,1,6]
第7次[2,3,4,5,1,6]
第8次4比5小,不变[2,3,4,5,1,6]
第9次[2,3,4,1,5,6]
第三轮
第10次 2比3小,不变[2,3,4,1,5,6]
第11次 3比4小,不变[2,3,4,1,5,6]
第12次 [2,3,1,4,5,6]

第4轮
第13次 2比3小,不变[2,3,1,4,5,6]
第14次 [2,1,3,4,5,6]

第5轮
第15次[1,2,3,4,5,5]

看出规律了么.第一轮比较数组总数-1次.以后每轮比较次数再-1
(6-1)+(6-1-1)+(6-1-1)+(6-1-1-1)+(6-1-1-1-1)+(6-1-1-1-1-1)=5+4+3+2+1

7. js 按名称排序

1. 冒泡排序吧！
交换那里为什么这么做，看上去Books应该是Array, push是array的方法，是在array最后添加若干元素。而Books[i]应该是一个Book，你确定他有push这个方法吗？

这么写就可以了：
var tmp =$scope.reader.Books[j],
$scope.reader.Books[j] = $scope.reader.Books[j + 1],

$scope.reader.Books[j + 1] = tmp;

2. 另外若不考虑排序的稳定性可以使用js原生的sort，很高效的。

1)
var arr = [1, 3, 2, 4];
arr.sort(); //arr 变成了[1, 2, 3, 4]
2)
//按名称排序。
var arr = [{k: 1, v: 's'}, {k: 3, v: 's'}, {k: 2, v: 'f'}, {k: 4, v: 'h'}];
arr.sort(functoin(a, b) {
return a.k - b.k;

});
//arr编程 [{k: 1, v: 's'}, {k: 2, v: 'f'}, {k: 3, v: 's'}, {k: 4, v: 'h'}
即可以按arr.k进行排序。
sort中的这个参数是个函数。函数返回负数表示a应该排在b的前面，正数相反（b在a的前面）。
3)
js原生的sort排序在不同的浏览器中的实现是不同的。请看下例：
在2)中若arr = [{k: 1, v: 's'}, {k: 3, v: 's'}, {k: 1, v: 'f'}, {k: 4, v: 'h'}]
即第2个（从0开始的）和第2个数据的k一样（arr[0].k==1 arr[2].k == 1）
这样的数据用2）的方式排序的结果怎么样的？
结果可能是： sfsh也有可能是fssh，因为sort里面的那个函数并没有强调返回0时谁应该在前面。
这就是排序的稳定性，稳定排序是指：排序时对于值相同的元素，其相对位置不会发生变化。据我说知：firefox排序算法是合并排序；chrome在对待少量数据是用插入排序，对待数据量较大时用快速排序（好像是以10个元素个数为界限）；ie排序算法我不知道，但是好像它的排序很慢，它用的排序也是不稳定的（会不会用的是选择排序呢？）。
现在说一下个算法的稳定性和效率吧：
a).快排。顾名思义，效率很高（o(nlgn)），chrome选择了他，并做了优化（少量数据用插入排序优于快速排序的），效率很高，一般的排序都选择用它；但他是非稳定排序。
b).合并排序。效率比快排差(时间负责度o(nlgn)，空间复杂度o(n))，一般较少用于排序；他是稳定排序。
c)堆排序。o(nlgn)； 非稳定排序。
d)冒泡、插入 排序。 o(n^2)； 稳定排序。
e)选择排序。 o(n^2): 非稳定排序。
这里说了好多废话。。。
4）给你写个排序怎么样。你要就说，我就去写，不要就不写了。你的冒泡排序效率很低的。。。

8. 求js对象键名根据键值排序，按排序顺序产生新键名数组的高效算法

constdata={1001:1,1002:3,1003:2,1004:2,1005:1};
constkeys=Object.keys(data);
keys.sort(function(a,b){
returndata[b]-data[a];});
console.log(keys);

['1002','1003','1004','1001','1005']

只是js对象的健是字符串，用的时候还要转换一下

constout=keys.map(function(x){returnparseInt(x);});
console.log(out);

[1002,1003,1004,1001,1005]

9. JS常用的排序算法有哪些，如何实现这些算法

1.冒泡排序
var bubbleSort = function (arr) {
var flag = true;
var len = arr.length;
for (var i = 0; i < len - 1; i++) {
flag = true;
for (var j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
var temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
flag = false;
}
}
if (flag) {
break;
}
}
};
2.选择排序
var selectSort = function (arr) {
var min;
for (var i = 0; i < arr.length-1; i++) {
min = i;