1. 冒泡排序
数组相邻元素进行比较,每次比较将最大/最小的值冒泡到应在的位置,经过n-1次比较后,数组变为有序数组。
function bubble(arr) {
let temp;
for (let i = 0; i < arr.length - 1; i++) {
for (let j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
2.选择排序
每次比较一轮,将比较的结果(最大值或者最小值)放在应在的位置。
function selectSort(arr) {
let min;
for(let i = 0; i < arr.length; i++) {
// 将当前位置设为最小值
min = i;
for(let j = i + 1; j < arr.length; j++) {
// 遍历数组其他元素,查看有没有更小的
if (arr[j] < arr[min]) {
min = j;
}
}
// 如果当前位置不是最小值,那么交换位置
if (min !== i) {
const temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
return arr;
}
3. 插入排序
将未排序的元素插入到已排序的数组中去,最后形成一个排序数组。
function insertSort(arr) {
let value, i, j;
for(i = 0; i < arr.length; i++) {
value = arr[i];
// 比较排序的数组和当前元素
// 从排序数组最后一项开始比较,如果大于当前值,则向后移一位
// 直到当前值大于排序数组的某一个值
for(j = i - 1; j > -1 && arr[j] > value; j--) {
arr[j + 1] = arr[j];
}
arr[j + 1] = value;
}
return arr;
}
4. 合并排序
将两个已经排序的数组合并成一个有序的数组。
// 合并两个数组
function merge(left, right) {
let i = 0, j = 0;
const result = [];
while(i < left.length && j < right.length) {
if (left[i] < right[j]) {
result.push(left[i++]);
} else {
result.push(right[j++]);
}
}
return result.concat(left.slice(i), right.slice(j));
}
// 将数组拆分成若干个数组,两两合并
function mergeSort(arr) {
if (arr.length === 1) {
return arr;
}
const middle = Math.floor(arr.length / 2);
const left = arr.slice(0, middle);
const right = arr.slice(middle);
return merge(mergeSort(left), mergeSort(right));
}
5. 快速排序
快速排序通过选择一个基准值将数据进行分割,使得小于基准值的数据在一个数组中,大于基准值的数据在另一个数组,然后递归这两个数组直到排序完成。
function getPosition(arr, left, right) {
let pointer = arr[left];
while (left < right) {
while (left < right && arr[right] > pointer) {
right--;
}
arr[left] = arr[right];
while (left < right && arr[left] <= pointer) {
left++;
}
arr[right] = arr[left];
}
arr[left] = pointer;
return left;
}
function quickSort(arr, left, right) {
if (left < right) {
let pos = getPosition(arr, left, right);
quickSort(arr, left, pos - 1);
quickSort(arr, pos + 1, right);
return arr;
}
}