数据结构--基本排序算法（js版）

排序，数据结构不可或缺的一大用途。排序有很多种算法，每种情况有对应的最佳算法，今天先来看看3大基本排序算法。

一：冒泡排序

冒泡排序算法是最慢的排序之一，但也是一种最容易实现的排序算法。使用冒泡排序时，数据值会像气泡一样从数组的一端飘浮到另一端。之所以产生这种现象是因为算法会多次在数组中移动，比较相邻的数据，如果是升序排序，当左侧值大于右侧值时他们会进行互换。

function Sort(list) {
this.list = list;
}

Sort.prototype.wrap = function(arr,index1,index2) {  //交换
var temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}

Sort.prototype.bubbleSort = function() {
var temp;
for(var outer = this.list.length; outer >=2; outer--) {
for(var inner = 0; inner <= outer - 1; inner++) {
if(this.list[inner] > this.list[inner + 1]) {
this.wrap(this.list,inner,inner+1);
}
}
//为了方便看排序的过程，打印出来
console.log(this.list.toString());
}
}

var s = [5,9,0,16,46,1,68,7,59,4];
var sort = new Sort(s);
sort.bubbleSort();

每结束里层一个循环，就会从后面确定一位数。因为只要它比右侧值大，就会交换,直至到达循环的最后一位，所以遍历的个数每次都少一个。

最好的情况只需一趟扫描（即本来就有序的）。比较n次移动0，时间复杂度是O(n)。

最坏的情况是反序或随机排序，需要n-1次扫描，移动和扫描都是O(n²)，时间复杂度是O(n²)。

二：选择排序

选择排序从数组的开头开始，将第一个元素和其他元素比较，检查完所有元素后，最小的元素就会放到第一位。

Sort.prototype.selectionSort = function() {
var temp;
for(var outer = 0; outer < this.list.length; outer++) {
var min = outer;
for(var inner = outer + 1; inner < this.list.length; inner++) {
if(this.list[inner] < this.list[min]) {
min = inner;
}
}
this.wrap(this.list,outer,min);
console.log(this.list.toString());
}
}

- 选择排序的比较次数和数据的初始排序无关，空间复杂度是O(1)，比较次数是n*(n-1)/2，时间复杂度是O(n²)。

三：插入排序

插入排序是两个循环，外循环将数组元素挨个移动，二内循环则对外循环选中的元素即后一个元素进行比较。如果外循环选中的元素比内循环要小，那个数组元素会右移动，为内循环的这个元素腾出位置。

Sort.prototype.insertionSort = function() {
var temp,inner;
for(var outer = 1; outer < this.list.length; outer ++) {
temp = this.list[outer];
inner = outer;
while(inner > 0 && this.list[inner-1] > temp) {
this.list[inner] = this.list[inner - 1];
--inner;
}
this.list[inner] = temp;
console.log("outer" + outer + "-->" + this.list.toString());
}
}

插入排序不是通过数据交换，而是通过将较大的数组元素移动到右侧，为数组较小元素腾出位置。

空间复杂度是O(1)，时间复杂度是O(n²)。