JS - 常见的排序算法

一、冒泡排序

原理：比较两个相邻的元素，将值大的元素交换至右端。

const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];

function bubbleSort (arr) {
  let len = arr.length;
  for (var j = 0; j < len - 1; j++) {
     for (var i = 0; i <len -1 - j; i++) {
        if (arr[i] < arr[i-1]) {
            let temp = arr[i-1];
            arr[i-1] = arr[i];
            arr[i] = temp;
         }
     }
   
  }
  return arr;
}

console.log(bubbleSort(arr))

二、选择排序

原理：遍历数组寻找最大值，从数组末端依次放置

const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];

function selectionSort (arr) {
  let len = arr.length;
  let maxIndex, tamp;
  for (var j = 0; j < len - 1; j++) {
    maxIndex = 0;
    for (var i = 1; i <len - j; i++) {
        if (arr[maxIndex] < arr[i]) {
            maxIndex = i; 
        }
    }
    temp = arr[maxIndex];
    arr[maxIndex] = arr[len - 1 -j];
    arr[len - 1 -j] = temp;
    
   
  }
  return arr;
}

console.log(selectionSort(arr))

三、插入排序

原理：遍历数组，从后向前进行比较，符合条件交换位置。前面都是排序好的。

function insertSort(arr) {
  let len = arr.length;
  for(let i = 1; i < len; i ++){
    for(let j = i; j > 0; j --) {
      if (arr[j] < arr[j - 1]) {
        [arr[j-1], arr[j]] = [arr[j], arr[j-1]];
      }
    }
  }
  return arr;
}

console.log(insertSort(arr))

四、快速排序（二分法）

原理：

1. 先从数列中取出一个数作为“基准”。
2. 分区过程：将比这个“基准”大的数全放到“基准”的右边，小于或等于“基准”的数全放到“基准”的左边。
3. 再对左右区间重复第二步，直到各区间只有一个数。

const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];

function quickSort (arr) {
  let len = arr.length;
  if(len === 1) {
    return arr;
  }
  const [left, right] = slicePart(arr, len);

  if (len > 3) {
    const leftArr = arr.slice(0, left);
    const rightArr = arr.slice(left, len);
    const newLeftArr = quickSort(leftArr);
    const newRightArr = quickSort(rightArr);
    const newArr = newLeftArr.concat(newRightArr);
    return newArr;
  }
  return arr;
}

function slicePart(arr, len) {
  let left = 0;
  let right = len -1;
  let midIndex = Math.round(len /2);
  let midNumber = arr[midIndex];
  let temp;
  while(left < right) {
    while (arr[left] < midNumber) left ++;
    while (arr[right] > midNumber) right --;
    swap(arr, left, right);
  }
  return [left, right];
}

function swap(arr, left, right) {
  let temp = arr[right];
  arr[right] = arr[left];
  arr[left] = temp;
}


console.log(quickSort(arr))

五、归并排序

原理:
归并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即

1. 把待排序序列分为若干个子序列，直到各区间只有一个数。
2. 将每个子序列排序成有序的在合并。
3. 直到最后一个有序数组。

const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];

function mergeSort(arr) {
  let len = arr.length;
  if(len === 1) {
    return arr;
  }
  let midIndex = Math.round(len /2);
  let leftArr = arr.slice(0, midIndex);
  let rightArr = arr.slice(midIndex, len);
  return merge(mergeSort(leftArr), mergeSort(rightArr));

}

function merge(leftArr, rightArr) {
  let result = [];
  while(leftArr.length && rightArr.length) {
    if (leftArr[0] < rightArr[0]) {
      result.push(leftArr[0]);
      leftArr.shift();
    } else {
      result.push(rightArr[0]);
      rightArr.shift();
    }
  }
  return result.concat(leftArr).concat(rightArr);
}
console.log(mergeSort(arr))

六、希尔排序

const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];

function shellSort(arr) {
  let len = arr.length;
  for (let gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
    for (let i = gap; i < len; i++) {
      let j = i;
      let current = arr[i];
      while(j - gap >= 0 && current < arr[j - gap]) {
        arr[j] = arr[j - gap];
        j = j - gap;
      }
      arr[j] = current;
    }
  }
  return arr;
}