排序算法

1. BubbleSort

• 基本思想：依次比较相邻两个数，较大的数下沉，较小的数冒起来。
• 优化： 设置flag 排好序后终止多余的循环
• 平均时间复杂度：O(n2)

	let temp
    let flag
    var arr = [20, 17, 13, 28, 14, 23, 15, 42]
    for (let i = 0; i < arr.length; i++) {
    // 只需要循环
      flag = true
      for (let j = arr.length - 1; j > i; j--) {
      	// 从后往前比较，每次最小值会被冒泡到数组最前面
        // console.log(j)
        if ( arr[j] < arr[j-1]) {
          temp = arr[j]
          arr[j] = arr[j-1]
          arr[j-1] = temp
          flag = false
        }
      }
      if (flag) {
        break
      }
    }
    console.log(arr)

2. SelectionSort

• 基本思想：第一次遍历找到最小的数与第一个元素交换，依次类推…。
• 平均时间复杂度：O(n2)

	let temp
    var arr = [20, 17, 13, 28, 14, 23, 15, 42]
    for (let i = 0; i < arr.length; i++) {
      console.log(i + '----------' , arr)
      for (let j = i + 1; j < arr.length; j++) {
        if ( arr[j] < arr[i]) {
          temp = arr[i]
          arr[i] = arr[j]
          arr[j] = temp
        }
      }
    }
    console.log(arr)

3. InsertionSort

• 基本思想：假设前n-1个已经排好序了，将第n个从后往前比较，遇到比自己大的就交换位置，插入到数组中，使得前n个是排好序的，以此类推
• 平均时间复杂度：O(n2)

	let temp
    var arr = [20, 17, 13, 28, 14, 23, 15, 42]
    for (let i = 0; i < arr.length - 1; i++) {
      for (let j = i + 1; j > 0; j--) {
        if ( arr[j] < arr[j-1]) {
          temp = arr[j]
          arr[j] = arr[j-1]
          arr[j-1] = temp
        } else {
          break
        }
      }
    }
    console.log(arr)

4. Shell Sort

• 基本思想：
  在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。
  然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。
• 平均时间复杂度：

	let temp
    var arr = [10, 8, 3, 2, 5, 9, 4, 7, 35, 46, 6]
    var incre = [7, 3, 1]
    for (let k = 0; k < incre.length; k++) {
      let step = incre[k]
      for (let i = step; i < arr.length; i++) {
        for (let j = i; j >= step; j-=step) {
          if(arr[j] < arr[j-step]) {
            temp = arr[j]
            arr[j] = arr[j-step]
            arr[j-step] = temp
          }
        }
      }
    }
    console.log(arr)

5. Quicksort

• 基本思想：
  先从数列中取出一个数作为key值；
  将比这个数小的数全部放在它的左边，大于或等于它的数全部放在它的右边；
  对左右两个小数列重复第二步，直至各区间只有1个数。
• 平均时间复杂度：O(N*logN)

	// 递归
	var arr = [10, 8, 3, 2, 5, 9, 4, 7, 35, 46, 6]
    function quickSort(arr) {
      let smallerArr = []
      let greaterArr = []
      let key= arr[0]
      if(arr.length === 0) {
        return []
      }
      for (let i = 1; i < arr.length; i++) {
        if(arr[i] < key) {
          smallerArr.push(arr[i])
        } else {
          greaterArr.push(arr[i])
        }
      }
      return quickSort(smallerArr).concat([key], quickSort(greaterArr))
    }
    console.log(quickSort(arr))

	// 挖坑填数
	var arr = [10, 8, 3, 2, 5, 9, 4, 7, 35, 46, 6]
    function quickSort(arr, l, r) {
      if(l>=r) {
        return
      }
      // debugger
      let i = l
      let j = r
	  // 将每一轮比较的数保存在key里面
      let key = arr[l]
      while(i < j) {
        while(i< j && arr[j] >= key) {
          j--
        }
        if(i < j) {
          arr[i] =  arr[j]
          i++
        }
        while(i<j && arr[i] < key) {
          i++
        }
        if(i<j) {
          arr[j] = arr[i]
          j--
        }
      }
      // i == j 最终 key左边都比key小，右边都比key大
      arr[i] = key
      quickSort(arr, 0, i-1)
      quickSort(arr, i+1, r)
    }
    quickSort(arr, 0, arr.length -1)
    console.log(arr)

6. Mergesort

• 基本思想：
  将数列分为若干个小数列，考虑将有序数列合并
• 平均时间复杂度：O(NlogN)
  归并排序的效率是比较高的，设数列长为N，将数列分开成小数列一共要logN步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(N*logN)。

	var arr = [36,20,17,13,28,14,23,15]
    function mergeArray(a,first,middle,last) {
      let i = first
      let j = middle
      let temp = []

      while(i<= middle - 1 && j<=last) {
        if(a[i] < a[j]) {
          temp.push(a[i++])
        } else {
          temp.push(a[j++])
        }
      }
      while(i<= middle - 1) {
        temp.push(a[i++])
      }
      while( j<=last) {
        temp.push(a[j++])
      }
      for (let k = 0; k < temp.length; k++) {
        arr[first + k] = temp[k]
      }
    }
    function mergeSort(arr, first, last ) {
      if(first < last) {
        let middle
        if (Math.round(last + first + 1) % 2 === 0) {
          middle = Math.round(last + first + 1) / 2
        } else {
          middle = Math.round(last + first ) / 2
        }
        mergeSort(arr, first, middle - 1)
        mergeSort(arr, middle, last)
        mergeArray(arr, first, middle, last)
      }
      return arr
    }
    console.log(mergeSort(arr, 0, arr.length - 1))