1、冒泡排序
var a = [5,3,2,7,3,1,0,5,6,2]
function BubbleSort(a) {
var len = a.length
var temp
var flag = false
for (var i = 0; i < len - 1; i++) {
flag = false
for (var j = len - 1; j > i; j--) {
if (a[j] < a[j-1]) {
temp = a[j]
a[j] = a[j-1]
a[j-1] = temp
flag = true
}
}
if (!flag) { //如果某一趟排序一次交换都没有发生就表名已经是排好序的
break
}
console.log("冒泡排序：第%d趟",i ,a)
}
}
BubbleSort(a)
2、选择排序
var a = [5,3,2,7,3,1,0,5,6,2]
function SelectSort(a) {
var len = a.length
for (var i = 0; i < len - 1; i++) {
var minIndex = i
for (var j = i + 1; j < len; j++) {
if (a[j] < a[minIndex]) {
minIndex = j
}
}
if (minIndex != i) {
var temp = a[i]
a[i] = a[minIndex]
a[minIndex] = temp
}
console.log("选择排序：第%d趟",i ,a)
}
}
SelectSort(a)
3、插入排序
var a = [5,3,2,7,3,1,0,5,6,2]
function InsertSort(a)
{
len = a.length
var temp
for(var i = 0; i < len-1; i++) {
for (var j = i + 1; j > 0; j--) {
if (a[j] < a[j-1]) {
temp = a[j]
a[j] = a[j-1]
a[j-1] = temp
} else {
break
}
}
console.log("插入排序：第%d趟",i ,a)
}
}
InsertSort(a)
4、希尔插入排序
var a = [5,3,2,7,3,1,0,5,6,2]
function ShellSort(array) {
var temp = 0,
len = a.length,
incre = len / 2,
while(true){
incre = Math.floor(incre / 2)
for(var k = 0; k < incre; k++){ //根据增量分为若干子序列
for(var i = k + incre; i < len; i += incre){
for(var j = i; j > k; j -= incre){
if(array[j] < array[j-incre]){
temp = array[j-incre];
array[j-incre] = array[j];
array[j] = temp;
}else{
break;
}
}
}
}
if(incre == 1){
break;
}
}
console.log("希尔插入排序：", array)
}
ShellSort(a)
5、快速排序
var a = [5,3,2,7,3,1,0,5,6,2]
function QuickSort(arr) {
if (arr.length < 1) {
return arr
}
var centerIndex = Math.floor(arr.length / 2),
centerNum = arr.splice(centerIndex, 1),
arrLeft = [],
arrRight = []
for (i = 0; i < arr.length; i++) {
if (arr[i] < centerNum[0]) {
arrLeft.push(arr[i])
} else{
arrRight.push(arr[i])
}
}
console.log("快速排序: ", arr)
return QuickSort(arrLeft).concat(centerNum, QuickSort(arrRight))
}
QuickSort(a)
6、归并排序
var a = [5,3,2,7,3,1,0,5,6,2]
function merge(left, right) {
var result = []
while(left.length > 0 && right.length > 0) {
if(left[0] < right[0]) {
result.push(left.shift())
}
else {
result.push(right.shift())
}
}
/* 当左右数组长度不等.将比较完后剩下的数组项链接起来即可 */
return result.concat(left).concat(right)
}
function mergeSort(arr){
if(arr.length == 1) {
return arr
}
var mid = Math.floor(arr.length/2)
var left_arr = arr.slice(0,mid),
right_arr = arr.slice(mid)
return merge(mergeSort(left_arr),mergeSort(right_arr))
}
mergeSort(a)
7、堆排序
var a = [5,3,2,7,3,1,0,5,6,2]
/* 排序思路：（降序）
* 将堆根保存于尾部，并对剩余序列调用调整函数，调整完成后，再将最大跟保存于尾部-1（-1，-2，...，-i），
* 再对剩余序列进行调整，反复进行该过程，直至排序完成。
*/
/* 将最大的元素调整到堆顶*/
function AdjustHeap(arr, pos, len){
var swap = arr[pos]; //保存当前节点
var child = pos * 2 + 1; //定位到当前节点的左边的子节点
while(child < len){ //递归遍历所有的子节点
//判断当前节点是否有右节点，若右节点较大，就采用右节点和当前节点进行比较
if(child + 1 < len && arr[child] < arr[child + 1]){
child += 1;
}
//比较当前节点和最大的子节点，小于就交换，交换后将当前节点定位到子节点上
if(arr[pos] < arr[child]){
arr[pos] = arr[child];
pos = child;
child = pos * 2 + 1;
}
else{
break;
}
arr[pos] = swap;
}
}
/* 构建堆：
* 满足：树中任一非叶子结点的关键字均不大于（或不小于）其左右孩子结点的关键字。
* 实现：从最后一个拥有子节点的节点开始，将该节点和其他节点进行比较，将最大的数交换给该节点，
* 交换后再依次向前节点进行相同的交换处理，直到构建出大顶堆。
*/
function BuildHeap(arr) {
for(var i = arr.length/2; i >= 0; i--) { //构建打顶堆
AdjustHeap(arr, i, arr.length)
}
}
/*堆排序算法*/
function HeapSort(arr) {
BuildHeap(arr); //构建堆
for(var i = arr.length-1; i > 0; i--) { //从数组的尾部进行调整
var swap = arr[i]; //堆顶永远是最大的元素,将堆顶和尾部元素交换，最大元素就保存在尾部，
//并且不参与后面的调整
arr[i] = arr[0];
arr[0] = swap;
AdjustHeap(arr, 0, i); //将最大的元素进行调整，将最大的元素调整到堆顶
}
}
HeapSort(a)
console.log("堆排序：", a)
