前端常用排序算法

JavaScript排序算法

冒泡排序

//冒泡排序
// f: false 升序；true 降序
let bubbleSort = (arr, f = false) => {
  let len = arr.length;
  let flag = false;
  for (let i = 0; i < len - 1; ++i) {
    flag = false;
    for (let j = 0; j < len - 1 - i; ++j) {
      if (!f) {
        if (arr[j] > arr[j + 1]) {
          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
          flag = true;
        }
      } else {
        if (arr[j] < arr[j + 1]) {
          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
          flag = true;
        }
      }
    }
    if (!flag) break;
  }
  return arr;
};

• 时间复杂度
  • 平均O(n^2)
  • 最坏O(n^2)
  • 最好O(n)
• 空间复杂度 O(1)
• 稳定性-稳定

选择排序

//选择排序
// f：false---升序；true：降序
let selectSort = (arr, f = false) => {
  let len = arr.length;
  for (let i = 0; i < len - 1; ++i) {
    let index = i;
    for (let j = i + 1; j < len; ++j) {
      if (!f) {
        if (arr[index] > arr[j]) {
          index = j;
        }
      } else {
        if (arr[index] < arr[j]) {
          index = j;
        }
      }
    }
    if (index != i) {
      [arr[i], arr[index]] = [arr[index], arr[i]];
    }
  }
  return arr;
}

• 时间复杂度
  • 平均O(n^2)
  • 最坏O(n^2)
  • 最好O(n)
• 空间复杂度 O(1)
• 稳定性-不稳定

插入排序

//插入排序
// f：false---升序；true：降序
let insertSort = (arr, f = false) => {
  let len = arr.length;
  for (let i = 1;i < len; ++i) {
    let pre = i - 1;
    let cur = arr[i];
    if (!f) {
      while (pre >= 0 && arr[pre] > cur) {
        arr[pre + 1] = arr[pre];
        --pre;
      }
    } else {
      while (pre >= 0 && arr[pre] < cur) {
        arr[pre + 1] = arr[pre];
        --pre;
      }
    }
    arr[pre + 1] = cur;
  }

  return arr;
};

希尔排序

//希尔排序
// f：false---升序；true：降序
let shellSort = (arr, f = false) => {
  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];
      if (!f) {
        while (j - gap >= 0 && current < arr[j - gap]) {
          arr[j] = arr[j - gap];
          j -= gap;
        }
      } else {
        while (j - gap >= 0 && current > arr[j - gap]) {
          arr[j] = arr[j - gap];
          j -= gap;
        }
      }
      arr[j] = current;
    }
  }
  return arr;
};

• 时间复杂度
  • 平均O(n^1.3)
  • 最坏O(n^2)
  • 最好O(n)
• 空间复杂度 O(1)
• 稳定性-不稳定

快速排序

//快速排序
// f：false---升序；true：降序
let quickSort = (arr, f = false) => {
  let right = arr.length - 1;
  let left = 0;
  //获取第一遍快排的位置
  const getPosition = (arr, left, right) => {
    let temp = arr[left];
    let flag = false; //false右往左；true：左往右
    while (left < right) {
      if (!f) {
        if (!flag) {
          if (arr[right] < temp) {
            arr[left] = arr[right];
            ++left;
            flag = true;
          } else {
            --right;
          }
        } else {
          if (arr[left] > temp) {
            arr[right] = arr[left];
            --right;
            flag = false;
          } else {
            ++left
          }
        }
      } else {
        if (!flag) {
          if (arr[right] > temp) {
            arr[left] = arr[right];
            ++left;
            flag = true;
          } else {
            --right;
          }
        } else {
          if (arr[left] < temp) {
            arr[right] = arr[left];
            --right;
            flag = false;
          } else {
            ++left
          }
        }
      }
    }
    arr[left] = temp;
    return left;
  };
  const Sort = (arr, left, right) => {
    if (left < right) {
      let position = getPosition(arr, left, right);
      Sort(arr, left, position - 1);
      Sort(arr, position + 1, right);
    }
  };
  Sort(arr, left, right);
  return arr;
};

• 时间复杂度
  • 平均O(nlog2(n))
  • 最坏O(n^2)
  • 最好O(nlog2(n))
• 空间复杂度 O(nlog2(n))
• 稳定性-不稳定

归并排序

//归并排序
// f：false---升序；true：降序
let mergeSort = (arr, f = false) => {
  let Merge = (left, right) => {
    let res = [];
    while (left.length > 0 && right.length > 0) {
      if (!f) {
        if (left[0] <= right[0]) res.push(left.shift());
        else res.push(right.shift());
      } else {
        if (left[0] >= right[0]) res.push(left.shift());
        else res.push(right.shift());
      }
    }
    while (left.length) res.push(left.shift());
    while (right.length) res.push(right.shift());
    return res;
  };
  let Sort = (arr) => {
    let len = arr.length;
    if (len < 2) return arr;

    let mid = Math.floor(len / 2);
    let left = arr.slice(0, mid);
    let right = arr.slice(mid);
    return Merge(Sort(left), Sort(right));
  };
  return Sort(arr);
};

• 时间复杂度
  • 平均O(nlog2(n))
  • 最坏O(nlog2(n))
  • 最好O(nlog2(n))
• 空间复杂度 O(n)
• 稳定性-稳定