js数组排序

原生排序方法  sort（）

在不加函数的情况下sort（）是按照ascll码来的

const arr = ['c', 'd', 'f', 'j', 'q', 'a', 's', 'r', 'y', 'k', 'x', 'b','C'];
var newarr = null
newarr = arr.sort()

但是这样的话大写的永远在小写的前面，所以加以优化就是

const arr = ['c', 'd', 'f', 'j', 'q', 'a', 's', 'r', 'y', 'k', 'x', 'b','C'];
var newarr = null
newarr = arr.sort(function(s1, s2) {
				x1 = s1.toUpperCase();
				x2 = s2.toUpperCase();
				if (x1 < x2) {
					return -1;
				}
				if (x1 > x2) {
					return 1;
				}
				return 0;
			})
			console.log(newarr);

当然我们用到最多的可能还是数字的排序

const arr = [2,3,4,5,3,1];
var newarr = null
newarr = arr.sort(function(a,b){
		return a - b
	})

还有js 的快速排序法

Array.prototype.quickSort = function () { 
    const rec = (arr) => { 
       // 预防数组是空的或者只有一个元素, 当所有元素都大于等于基准值就会产生空的数组
       if(arr.length === 1 || arr.length === 0) { return arr; }
       const left = [];
       const right = [];
       //以第一个元素作为基准值   
       const mid = arr[0];
       //小于基准值的放左边，大于基准值的放右边
       for(let i = 1; i < arr.length; ++i) { 
           if(arr[i] < mid) { 
               left.push(arr[i]);
           } else { 
               right.push(arr[i]);
           }
       }
        //递归调用，最后放回数组    
       return [...rec(left),mid,...rec(right)];
    };
    const res = rec(this);
    res.forEach((n,i) => { this[i] = n; })
}

const arr = [2,3,4,5,3,1];
arr.quickSort();
console.log(arr);

在这里我加了优化，在数组的排序后期长度太短时改为插入排序

  this.quickSort = function(){
    var self = this
    var cutoff = 3
 
    function partition(arr,left,right){ //分割操作
      var pivot = findPivot(arr,left,right)
      var length = right - left
      if (length>cutoff) {
        var i = left
        var j = right - 2
        while(i<=j){
          while(arr[i]<pivot){
            i++
          }
          while(arr[j]>pivot){
            j--
          }
          if (i<=j) {
            self.swapItemInArray(i,j)
            i++
            j--
          }
        }
        self.swapItemInArray(i,right-1)
        if (left<i-1) {
          partition(arr,left,i-1)
        }
        if (i+1<right) {
          partition(arr,i+1,right)
        }
      }else{
        insertSort(left,right)
      }
    }
    function findPivot(arr,left,right){//主元取中位数
      var center = Math.floor((left+right)/2)
      if (arr[left] > arr[center]) {
        self.swapItemInArray(left,center)
      }
      if (arr[left] > arr[right]) {
        self.swapItemInArray(left,right)
      }
      if (arr[center] > arr[right]) {
        self.swapItemInArray(center,right)
      }
      self.swapItemInArray(center,right-1)//主元被藏在倒数第二个
      return arr[right-1]
    }
    function insertSort(left,right){ //当分块足够小的时候，用插入排序
      var len = right - left
      for (var i = 0; i <= len; i++) {
        for (var j = i; j > 0; j--) {
          if (array[j]<array[j-1]) {
            self.swapItemInArray(j,j-1)
          }
        }
      }
    }
    partition(array,0,array.length-1)
  }

综合效率来说快速排序的速度比原生的快3分之一左右，但是在数据量不大时基本没有区别，所以在面对大量的数据时建议用快速排序，在日常简单的场景中可以使用原生排序