JS数组的排序_js对象数组排序不改变原数组 只拿到在数组顺序中的第几位

**

1.数组的sort()方法**

var array = [1,4,-8,-3,6,12,9,8];
function compare(val1,val2){
    return val1-val2;
};
array.sort(compare);
document.write(array);
1
2
3
4
5
6

sort()方法按照升序排列数组项，会调用每个数组项的toString()转型方法，然后比较得到的字符串。

toString()方法是把布尔值或BooleanObject转换为字符串，并返回结果。

compare()函数方法是一个比较函数，作为sort()方法的参数。

2丶冒泡排序

思路：重复遍历数组中的元素，依次比较两个相邻的元素，如果前一个元素大于后一个元素，就依靠第三个变量将它们换过来，直到所有元素遍历完。

   var arr = [1,4,-8,-3,6,12,9,8];
   for(var j=0;j<arr.length-1;j++){
   //两两比较，如果前一个比后一个大，则交换位置。
      for(var i=0;i<arr.length-1-j;i++){
           if(arr[i]>arr[i+1]){
               var temp = arr[i];
               arr[i] = arr[i+1];
               arr[i+1] = temp;
           }
       } 
   }
1
2
3
4
5
6
7
8
9
10
11

3、选择排序

思路：将第一位依次与后面的元素相比较，得到最小值，与第一位交换。再用第二位依次与后面元素相比较，得到最小值，与第二位交换。从原始数据中找到最小元素，并放在数组的最前面。然后再从下面的元素中找到最小元素，放在之前最小元素的后面，直到排序完成。

    var arr = [5,99,2,9,1,5,67,7,10,23]
       for(var i=0;i<arr.length-1;i++){       //大循环，需要比对的次数
           var min = arr[i];                  //假定一个最小值
           var minIndex = i;                  //假定最小值的索引
           for(var j=i+1;j<arr.length;j++){   //小循环，每次需要比对的次数
               if(min>arr[j]){                //判断最小值是否为真的最小值
                   min = arr[j];              //获取真正的最小值
                   minIndex = j;              //获取真正最小值的索引
               }
           }
   
           arr[minIndex] = arr[i];            //将当前元素放在最小值的位置
           arr[i] = min;                      //将最小值放在当前元素的位置
       }
       console.log(arr);            

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、快速排序

思路：
1、找基准（一般是以中间项为基准）
2、遍历数组，小于基准的放在left，大于基准的放在right
3、递归

   function quickSort(arr) {
         var left = [], right = [];
         if (arr == null) {
           return arr;
         } else if (arr.length <= 1) {
           return arr;
         }
         var num = arr.splice([Math.floor(arr.length / 2)], 1)[0];
   
         for (var i = 0; i < arr.length; i++) {
           if (arr[i] <= num) {
             left.push(arr[i]);
           } else {
             right.push(arr[i]);
           }
         }
         return (quickSort(left).concat([num], quickSort(right)));
       }
       alert(quickSort(arr));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5、：插入排序

思路：从第二个元素起，当前元素与靠前的元素依次对比，一、如果当前元素小于靠前的元素，
靠前的元素后移，直到当前元素大于或等于靠前元素，当前元素插入到靠前索引位置后。
二、如果当前元素大于靠前元素，不发生改变。
继续从下一个元素开始遍历数组。直当前一个数组角标preIndex+1=arr.length

   function insertSort(arr) {
         var temp;
         for (var i = 1; i < arr.length; i++) {
           for (var j = i; j >= 0; j--) {
             if (arr[j] < arr[j - 1]) {
               temp = arr[j - 1];
               arr[j - 1] = arr[j];
               arr[j] = temp;
             }
           }
         }
       }
    insertSort(arr);

1
2
3
4
5
6
7
8
9
10
11
12
13
14