排序算法基础

稳定：如果a原本在b前面，a=b,排序后a仍然在b前面
不稳定：如果a原本在b前面，a=b,排序后a在b后面
内排序：所有排序操作都在内存中完成
外排序：由于数据过大，因此把数据放在磁盘中，而排序需要通过磁盘和内存的数据传输才能进行
时间复杂度：一个算法执行所需要的时间
空间复杂度：运行完一个程序所需内存的大小

一：冒泡排序
冒泡排序 是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

function bubbleSort(arr){
	let  n = arr.length;
	let  temp = 0;
	for (var i = 0; i < n-1; i++) {
		for (var j = i+1; j < n; j++) {
			if (arr[i] > arr[j]) {
				temp = arr[j]
				arr[j] = arr[i]
				arr[i] = temp
			}
		}
	}
	return arr;
}

二：选择排序
选择排序(Selection-sort) 是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

function selectSort(arr){
	let temp = 0 
	let n = arr.length;
	for (var i = 0; i < n-1; i++) {
		let min = i;
		for (var j = i+1; j < n; j++) {
			if (arr[j] < arr[min]) {
				min = j
			}
		}
		if (min != i) {
			temp = arr[min]
			arr[min] = arr[i]
			arr[i] = temp
		}
	}
	return arr
}

三：插入排序
插入排序（Insertion-Sort） 的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

function insertSort(arr){
	let temp = 0;
	for (var i = 1; i < arr.length; i++) {
		if (arr[i] < arr[i-1]) {
			temp = arr[i]
			for (var j = i-1; arr[j] > temp; j--) {
				arr[j+1] = arr[j]
			}
			arr[j+1] = temp;
		}
	}
	return arr;
}

四：希尔排序
希尔排序是希尔（Donald Shell） 于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

function shellSort(arr){
	let temp = 0
	let gap = arr.length;
	while(gap > 1){
		gap = Math.floor(gap/3)+1
		for (var i = gap; i < arr.length; i++) {
			if (arr[i] < arr[i-gap]) {
				temp = arr[i]
				for (var j = i-gap; arr[j] > temp; j-=gap) {
					arr[j+gap]=arr[j];
				}
				arr[j+gap]=temp
			}
		}
	}

	return arr
}

五：归并排序
和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。
归并排序 是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

function mergeSort(arr){
	let len = arr.length
    if (len < 2) {
        return arr
    }
	let middle = Math.floor(len/2) 
	let leftArr = arr.slice(0,middle);
	let rightArr = arr.slice(middle,len);
	let mergeSortLeft = mergeSort(leftArr)
    let mergeSortRight = mergeSort(rightArr)
    //合并
    return merging(mergeSortLeft,mergeSortRight)
	
}
function merging(leftArr,rightArr){
	const result = [];

    while (leftArr.length && rightArr.length) {
        if (leftArr[0] <= rightArr[0]) {
            result.push(leftArr.shift()); 
        } else {
            result.push(rightArr.shift());
        }
    }
    while (leftArr.length) result.push(leftArr.shift());

    while (rightArr.length) result.push(rightArr.shift());

    return result;


}

六：快速排序
快速排序 的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。选择两个哨兵。

function quickSort(nums,begin,end){
	if(begin > end){
		console.log("当前排序结果",nums)
		return;
	}
	let temp = nums[begin];
	let i = begin;
	let j = end;
	while(i != j){
		while(nums[j] >= temp && i < j){
			j --;
		}

		while(nums[i] <= temp  && i < j){
			i ++;
		}
		console.log("比较结果",i,j)
		if(j > i){
			let tmp = nums[j];
			nums[j] = nums[i];
			nums[i] = tmp;
		}
	}
	nums[begin] = nums[i];
	nums[i] = temp;
	quickSortTest(nums,begin,i-1)
	quickSortTest(nums,i+1,end)
}

八：堆排序
堆排序（Heapsort） 是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

function heapSort(arr){
	var len;
    function buildMaxHeap(arr) {   //建堆
        len = arr.length;
        // [n/2-1]表示的是最后一个有子节点 (本来是n/2（堆从1数起），但是这里arr索引是从0开始，所以-1)
        for (var i = Math.floor(len/2)-1; i>=0; i--) {
            maxHeapify(arr,i);  //对每一个节点（非叶节点），做堆调整
        }
    }
    function maxHeapify(arr, i) {     //堆调整
        var left = 2*i+1,
            right = 2*i+2,
            largest = i;   //i为该子树的根节点
 
        if (left < len && arr[left] > arr[largest]) {
            largest = left;
        }
 
        if (right < len && arr[right] > arr[largest]) {
            largest = right;
        }
 
        if (largest != i) {  //即上面的if中有一个生效了
            swap(arr, i, largest);  //交换最大的为父节点
            maxHeapify(arr, largest);  //交换后，原值arr[i]（往下降了）（索引保存为largest），
            //作为根时，子节点可能比它大，因此要继续调整
        }
    }
    function swap(arr, i, j) {
        var temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }


    buildMaxHeap(arr);
    console.log("建堆后",arr)
    for (var i = arr.length-1; i > 0; i--) {
        swap(arr, 0, i);
        len--;
        console.log("交换后",arr)
        maxHeapify(arr, 0);
        console.log("调整后",arr)

    }

    return arr;


}