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;