持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第5天，点击查看活动详情
BubbleSort
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
function ArrayList() {
this.array = []
ArrayList.prototype.swap = (m, n) => {
let temp = this.array[m]
this.array[m] = this.array[n]
this.array[n] = temp
}
ArrayList.prototype.insert = item => {
this.array.push(item)
}
ArrayList.prototype.toString = () => {
return this.array.join('-')
}
ArrayList.prototype.bubbleSort = () => {
let length = this.array.length;
for (let j = length - 1; j >= 0; j--) {
for (let i = 0; i < j; i++) {
//注意i<j就可以了
//第一次进来，i=0
//最后一次寄来 i=length-2,与j(length-1)进行比较
if (this.array[i] > this.array[i + 1]) {
this.swap(i, i + 1)
}
}
}
}
}
let list = new ArrayList();
list.insert(2);
list.insert(5);
list.insert(1);
list.insert(4);
list.insert(3);
console.log(list.toString());
list.bubbleSort();
console.log(list.toString());
InsertSort
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
function ArrayList() {
this.array = []
ArrayList.prototype.swap = (m, n) => {
let temp = this.array[m]
this.array[m] = this.array[n]
this.array[n] = temp
}
ArrayList.prototype.insert = item => {
this.array.push(item)
}
ArrayList.prototype.toString = () => {
return this.array.join('-')
}
ArrayList.prototype.insertSort = () => {//插入排序
//1.获取数组长度
let length = this.array.length;
//2.外层循环：从第一个位置获取元素，向前面局部有序进行插入
for (let i = 1; i < length; i++) {
var temp = this.array[i];
//3.因为在内层while循环中要对i操作，所以用j来代替i
var j = i;
//4.内层循环：获取i位置的元素和前面的数据进行比较
while (this.array[j - 1] > temp && j > 0) {
this.array[j] = this.array[j - 1];
j--;//通过减小j值，达到多次比较
}
//5.将j位置的数据放置temp
this.array[j] = temp;
}
}
}
let list = new ArrayList();
list.insert(2);
list.insert(5);
list.insert(1);
list.insert(4);
list.insert(3);
list.insert(13);
console.log(list.toString());
list.insertSort();
console.log(list.toString());
QuickSort
从数列中挑出一个元素，称为 "基准"（pivot）
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序
function quickSort(list) {
if (list.length == 0 || list.length == 1) return list;
let center = Math.floor(list.length / 2);
let currentItem = list.splice(center, 1);
let leftList = [], rightList = [];
list.forEach(element => element < currentItem?leftList.push(element):rightList.push(element))
return quickSort(leftList).concat(currentItem).concat(quickSort(rightList));
}
let list = [5, 3, 7, 86, 4, 9];
console.log(quickSort(list));
SelectionSort
选择排序减少了交换次数，但比较次数不变（高级冒泡）
思路：选定第一个索引位置，然后和后面比较，当后面的数值小时，记录下此时的索引，然后以此索引为标志继续比下去。一个循环后，确定最小的值的位置，交换第一个索引和最小值索引，完成第一个循环，以此类推
function ArrayList() {
this.array = []
ArrayList.prototype.swap = (m, n) => {
let temp = this.array[m]
this.array[m] = this.array[n]
this.array[n] = temp
}
ArrayList.prototype.insert = item => {
this.array.push(item)
}
ArrayList.prototype.toString = () => {
return this.array.join('-')
}
ArrayList.prototype.selectionSort = () => {
let length = this.array.length;
for (let i = 0; i < length; i++) {
let temp = this.array[i]
let slogin = i
for (let j = i + 1; j < length; j++) {
if (temp > this.array[j]) {
slogin = j
temp = this.array[j]
}
}
this.swap(i, slogin)
}
}
}
let list = new ArrayList();
list.insert(2);
list.insert(5);
list.insert(1);
list.insert(4);
list.insert(3);
list.insert(500);
console.log(list.toString());
list.selectionSort();
console.log(list.toString());
