一、冒泡排序
1.实现原理
两两比较，较大的值不断向后移动。
2.特点
- 时间复杂度：O(n^2)
- 空间复杂度：O(1)
- 稳定性：稳定
3.代码
const bubbleSort = (arr: number[]): number[] => {
let len: number = arr.length;
//冒泡次数
for (let i = 0; i < len - 1; i++) {
//一次冒泡，两两进行比较的次数
for (let j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
//交换两数位置
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
二、选择排序
1.实现原理
找到数组中的最小值并将其放置在第一位，然后从第二位置开始找次小值并将其放在第二位，依次遍历。
2.特点
- 时间复杂度：O(n^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
3.代码
const selectSort = (arr: number[]): number[] => {
let len: number = arr.length;
//排序次数
for (let i = 0; i < len - 1; i++) {
let minIndex = i;//记录最小值下标
for (let j = i + 1; j < len; j++) {
if (arr[minIndex] > arr[j]) {
minIndex = j;
}
}
//当前位置不是最小值则交换两数
if (minIndex !== i) {
[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
}
}
return arr;
}
三、插入排序
1.实现原理
从数组第二位开始循环，从当前元素位置向前比较，遇到比当前元素大，元素向后移动，最后插入当前元素。
2.特点
- 时间复杂度：O(n^2)
- 空间复杂度：O(1)
- 稳定性：稳定
3.代码
const insertSort = (arr: number[]): number[] => {
let len: number = arr.length;
//从第二位开始向前比较
for (let i = 1; i < len; i++) {
let temp = arr[i];//记录当前元素
let j = i;//当前元素下标
//从当前元素向前比较，遇到比当前元素大，元素向后移动
while (j > 0 && arr[j - 1] > temp) {
arr[j] = arr[j - 1];
j--;
}
//将当前元素插入
arr[j] = temp;
}
return arr;
}
四、希尔排序
1.实现原理
希尔排序也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。
- 指定一个增量将待排序的元素进行分组。
- 然后再对每一组进行插入排序。
- 直到增量减至1时，整个序列恰好被分成一组，最后排成有序序列。
2.特点
- 平均时间复杂度为：O(n^1.3)，取决于增量序列的选择
- 最好时间复杂度：O(nlog n)
- 最坏时间复杂度：O(n^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
3.代码
const shellSort = (arr: number[]): number[] => {
let len: number = arr.length;
//指定一个增量
let gap: number = Math.floor(len / 2);
while (gap > 0) {
//对每一组进行插入排序
for (let i = gap; i < len; i++) {
let temp = arr[i];
let j = i;
while (j - gap >= 0 && arr[j - gap] > temp) {
arr[j] = arr[j - gap];
j = j - gap;
}
arr[j] = temp;
}
gap = Math.floor(gap / 2);
}
return arr;
}
五、归并排序
js中sort()方法，火狐浏览器实现用的是归并排序。
1.实现原理
“分而治之” 思想
- 在原始数组中间位置，将原始数组切分成两个较小的数组。
- 左右两个数组，重复步骤1（递归），直到每个小数组只有一个元素。
- 将小数组合并排序成较大的数组，直到最后只有一个排序完毕的大数组。
2.特点
- 时间复杂度为：O(nlogn)
- 空间复杂度：O(n)
- 稳定性：稳定
3.代码
const mergeSort = (arr: number[]): number[] => {
let len: number = arr.length;
if (len < 2) {
return arr;
}
//中间点
let mid: number = Math.floor(len / 2);
//左数组
let left: number[] = mergeSort(arr.slice(0, mid));
//右数组
let right: number[] = mergeSort(arr.slice(mid));
return merge(left, right);
}
const merge = (left: number[], right: number[]): number[] => {
let res: number[] = [];
//左右两个数组下标
let l: number = 0;
let r: number = 0;
while (l < left.length && r < right.length) {
//将左右两个数组中较小的数push进res
if (left[l] > right[r]) {
res.push(right[r]);
r++;
} else {
res.push(left[l]);
l++;
}
}
//left和right两个数组，其中一个数组中的元素还没push到res，所以concat
return res.concat(left.slice(l)).concat(right.slice(r));
}
六、快速排序
js中sort()方法，谷歌浏览器实现用的是快速排序。
1.实现原理
“分而治之” 思想
- 选择一个基准元素，把数组分为两个子数组
- 小于基准的数放到左边数组;大于等于基准的数放到右边数组。
- 对基准左边和右边的两个子集，不断重复第一步和第二步（递归），直到所有子集只剩下一个元素为止。
2.特点
- 时间复杂度为：O(nlogn)
- 空间复杂度：O(logn)
- 稳定性：不稳定
3.代码
const quickSort = (arr: number[]): number[] => {
let len: number = arr.length;
if (len < 2) {
return arr;
}
//选择一个基准元素，这里选数组第一个元素
let base = arr[0];
let left: number[] = [];
let right: number[] = [];
for (let i = 1; i < len; i++) {
if (arr[i] < base) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
//将左边数组，base，右边数组合并
return [...quickSort(left), base, ...quickSort(right)];
}
七、堆排序
1.实现原理
1.将数组构建成大顶堆，最大值就是堆顶的根节点 2.将堆顶元素与最后一个元素交换，那么末尾元素就存入了最大值 3.将剩余的 n - 1个元素重新构建成一个大顶堆，重复上面的操作
2.特点
- 时间复杂度为：O(nlogn)
- 空间复杂度：O(1)
- 稳定性：不稳定
