四种常见的数组排序方法

一、冒泡排序法

1. 冒泡排序法的思想：将第一个元素和第二个元素进行比较，若为逆序则互换两元素，接着依次比较，直至第n-1个元素与第n个元素进行比较，通过比较可将小的放置前面，大的放到后面。
2. 代码实现

var arr = [1, 9, 4, 0, 6, 0, 11, 3, 2];

    // 1.冒泡排序

    function mySort(arr) {

      // 外层循环控制比多少轮

      for (var i = 0; i <= arr.length - 1; i++) {

        // 内层循环控制一轮比较多少次

        for (var j = 0; j <= arr.length - 1 - i; j++) {

          if (arr[j] > arr[j + 1]) {

            var temp = arr[j];

            arr[j] = arr[j + 1];

            arr[j + 1] = temp;

          }

        }

      }

      console.log(arr);

    }

mySort(arr);

3.运行结果：

 

二、快速选择排序法

1.快速选择排序法的思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.代码实现

 var arr1=[1, 9, 4, 0, 6, 0, 11, 3, 2];
    function selectSort(arr1){
      // 外层控制轮数
      for(var i = 0;i <= arr1.length - 1;i++){
        var minIndex=i;
        // 内层控制每轮比较的次数
        for(var j=i+1;j<arr1.length;j++){
          if(arr1[j]<arr1[minIndex]){//寻找最小的数
            minIndex=j;//将最小数的索引赋值给minIndex，进行保存
          }
        };
        if(minIndex!=i){
            var temp=arr1[i];
            arr1[i]=arr1[minIndex];
            arr1[minIndex]=temp;
          }
      }
      console.log(arr1);
    }
selectSort(arr1);

3.运行结果

三、 插入排序法

1.插入排序法的思想：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

2.代码实现

var arr2=[1, 9, 4, 0, 6, 0, 11, 3, 2];
    function insertionSort(arr2) {
        var preIndex, current;
        for (var i = 1; i <arr2.length; i++) {
            preIndex = i - 1;
            current = arr2[i];
            while (preIndex >= 0 && arr2[preIndex] > current) {
                arr2[preIndex + 1] = arr2[preIndex];
                preIndex--;
            }
            arr2[preIndex + 1] = current;
        }
         console.log(arr2);
      }
      insertionSort(arr2);

3.运行结果

四、快速排序法

1.快速排序法思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

2.代码实现：

 var arr3=[1, 9, 4, 0, 6, 0, 11, 3, 2];
      function quickSort(arr3){
            //如果数组<=1,则直接返回
            if(arr3.length<=1){return arr3;}
            var pivotIndex=Math.floor(arr3.length/2);
            //找基准，并把基准从原数组删除
            var pivot=arr3.splice(pivotIndex,1)[0];
            //定义左右数组
            var left=[];
            var right=[];
            //比基准小的放在left，比基准大的放在right
            for(var i=0;i<arr3.length;i++){
                if(arr3[i]<=pivot){
                    left.push(arr3[i]);
                }
                else{
                    right.push(arr3[i]);
                }
            }
            //递归
            return quickSort(left).concat([pivot],quickSort(right));
      }
      var x = quickSort(arr3);
      console.log(x);

3.运行结果：