冒泡排序
冒泡排序算法的原理如下：
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3、针对所有的元素重复以上的步骤，除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
// 思路：遍历数组，然后将最大数放到最后；
// 时间复杂度：O(N^2)；
// 空间复杂度：O(1)
var arr = [1, 12, 5, 6, 2, 9, 3, 8]
function BubbleSort(arr) {
if (arr == null || arr <= 0) {
return []
}
else {
for (var i = 0; i < arr.length - 1; i++) {
//（个人理解）
//减1是因为下面会判断arr[j+1],防止下标越界,即相当于循环判断条件是j+1<arr.length
//每次循环都能确定这一次的最大数，下一轮就不用再比较它,内循环就可以少循环一次，循环几次就能确定几个最大数，所以减去循环次数i
for (var j = 0; j < arr.length - 1 - i; j++) {
//相邻两数比较，前面的数比后一个大的话交换到后面
if (arr[j] > arr[j + 1]) {
var team = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = team;
}
}
}
return arr
}
}
BubbleSort(arr);
console.log(arr)
打印结果
[ 1, 2, 3, 5, 6, 8, 9, 12 ]
方法二
//方法二
var arr = [1, 12, 5, 6, 2, 9, 3, 8]
function BubbleSort(arr) {
var len = arr.length;
for (var end = len - 1; end > 0; end--) {
for (var j = 0; j < len - 1; j++) {
if (arr[j] > arr[j + 1]) {
var team = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = team;
}
}
}
return arr
}
BubbleSort(arr);
console.log(arr)
输出结果同上
选择排序
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
选择排序：算法复杂度 O(n^2)
它的基本思想是：第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，
第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换，
第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，
…，第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换，
…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，
总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
function SelectionSort(arr) {
if (arr == null || arr.length < 0) {
return arr;
}
for (var i = 0; i < arr.length - 1; i++) {
var minIndex = i;
for (var j = i + 1; j < arr.length; j++) {
minIndex = arr[j] < arr[minIndex] ? j : minIndex;
}
if (i != minIndex) {
swap(arr, i, minIndex);
}
}
return arr;
}
function swap(arr, i, j) {
//用异或运算符进行两个值的交换
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
var arr = [1, 12, 5, 6, 2, 9, 3, 8]
SelectionSort(arr)
console.log(arr)
结果
[ 1, 2, 3, 5, 6, 8, 9, 12 ]
插入排序
插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法 。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动
//插入排序
function insertSort(arr) {
if (arr == null || arr <= 0) {
return [];
}
//外层循环 i=1开始，留着0作为有序部分，也就是说，外层循环获取数组后面的元素，也就是无序部分
for (var i = 1; i < arr.length; i++) {
//内层循环 j=i-1，就是获取有序部分最后的一个元素作为对照，也就是有序部分
for (var j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
//j--,就是从有序部分的后面元素开始和无序部分的元素作比较
swap(arr, j, j + 1)
}
}
return arr;
}
function swap(arr, i, j) {
//互换元素
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
var arr = [1, 12, 5, 6, 2, 9, 3, 8]
insertSort(arr)
console.log(arr)
结果
[ 1, 2, 3, 5, 6, 8, 9, 12 ]
快速排序
1、从数组中取出一个数作为基准。
2、在原数组中进行移动，将大于基准的数放到基准右边，小于基准的数放到基准左边，在基准左右形成两个子数组。
3、递归
function quickSort(arr) {
//4、结束递归（当数组小于等于一项，则不用处理）
if (arr.length <= 1) {
return arr;
}
//1、找到数组的中间项，在原有的数组中把它移除
let middleIndex = Math.floor(arr.length / 2);
//middleValue中间项的值
let middleValue = arr.splice(middleIndex, 1)[0];
//2、准备左右两个数组，循环剩下数组中的每一项，比当前项小的放到左边的数组中，反之放到右边数组中
let leftAry = [];
let rightAry = [];
for (let i = 0; i < arr.length; i++) {
let item = arr[i];
item < middleValue ? leftAry.push(item) : rightAry.push(item);
}
//3、递归方式让左右两边的数组持续这样处理，一直到左右两边都排好序为止（最后让左边+中间+右边拼接成为最后的结果）
return quickSort(leftAry).concat(middleValue, quickSort(rightAry))
}
let arr = [1, 12, 5, 6, 2, 9, 3, 8]
let result = quickSort(arr)
console.log(result)
结果
[ 1, 2, 3, 5, 6, 8, 9, 12 ]