数据结构之排序算法

冒泡排序

基本思想：依次与后面元素比较，每轮将大的元素冒泡到后面去，左右两个元素交换
算法时间复杂度都为O(n*n)

function bubbleSort(arr){
	const len = arr.length
	for(let i = 0; i < len; i++){
		//标志位，面向最好的情况的改进
		let flag = false
		for(let j = 0; j < len -i-1;j++){
		  if(arr[j]>arr[j+1]){
		  	[arr[j+1],arr[j]]=[arr[j],arr[j+1]]
		  	flag = true
		  }
		}
		if(flag == false) return arr
	}
	return arr
}

选择排序

基本思想：遍历数组，选择当前范围内元素最小值，将最小值元素与当前范围头部元素交换，放置在头部；再缩小范围对数组进行遍历
算法时间复杂度为O(n*n)

function selectSort(arr){
	const len = arr.length
	let minIndex
	for(let i = 0; i < len-1; i++){
		minIndex = i
		for(let j = i; j < len; j++){
			if(arr[j]<arr[i]){
				minIndex = j
			}
		}
		if(minIndex !== i){ 
			[arr[i],arr[minIndex]] = [arr[minIndex],arr[i]
		}
	}
	return arr
}

插入排序

基本思想：找到元素在其前面有序的序列中的合适位置,即前面元素不大于该元素，后面元素不小于该元素（从后往前,为该元素腾位置）
时间复杂度：最好时为O(n），一般为O（n*n）

function insertSort(arr){
	//temp用来保存当前需要插入的元素
	let temp
	const len = arr.length
	for(i = 1; i < len; i++){
		let j = i
		temp = arr[i]
		while(j>0&&arr[j-1]>temp){
			arr[j] = arr[j-1]
			j--
		}
		arr[j] = temp
	}
	return arr
}

归并排序

分而治之的思想(先分割，再合并）
基本思想：递归分割合并（在每一次合并时排好序），合并采用双指针法

function mergeSort(arr) {
    const len = arr.length
    // 处理边界情况
    if(len <= 1) {
        return arr
    }   
    // 计算分割点
    const mid = Math.floor(len / 2)    
    // 递归分割左子数组，然后合并为有序数组
    const leftArr = mergeSort(arr.slice(0, mid)) 
    // 递归分割右子数组，然后合并为有序数组
    const rightArr = mergeSort(arr.slice(mid,len))  
    // 合并左右两个有序数组
    arr = mergeArr(leftArr, rightArr)  
    // 返回合并后的结果
    return arr
}
  
function mergeArr(arr1, arr2) {  
    // 初始化两个指针，分别指向 arr1 和 arr2
    let i = 0, j = 0   
    // 初始化结果数组
    const res = []    
    // 缓存arr1的长度
    const len1 = arr1.length  
    // 缓存arr2的长度
    const len2 = arr2.length  
    // 合并两个子数组
    while(i < len1 && j < len2) {
        if(arr1[i] < arr2[j]) {
            res.push(arr1[i])
            i++
        } else {
            res.push(arr2[j])
            j++
        }
    }
    // 若其中一个子数组首先被合并完全，则直接拼接另一个子数组的剩余部分
    if(i<len1) {
        return res.concat(arr1.slice(i))
    } else {
        return res.concat(arr2.slice(j))
    }
}

快速排序（阮一峰版）

基本思想：分而治之，递归分割排序
时间复杂度：一般情况与一般情况为O(nlogn)，最坏的情况为O(n*n)

function quickSort(arr){
//递归边界，数组中元素小于等于1
	if(arr.length<=1){
		return arr
	}
	 var left = []
     var reigt = []
     var pivot = arr[0]
      // 遍历数组
      for(i=1;1<arr.length;i++){
            if(arr[i]<pivot){
                    left.push(arr[i])
                }else{
                    righ.push(arr[i])
                }
            }
   return quickSort1(left).concat(pivot,quickSort1(right))
 }