排序算法初识

Mrowl
83 阅读2分钟

选择排序

选择排序就是将一个数组中的最小数提出来放在首位，然后把剩余的数字接着取出最小值放在首位，一直到全部排完顺序

//首先写一个求数组中最小数下标的函数
let minIndex = (numbers) => {
  let index = 0
  for(let i = 0;i<numbers.length;i++){
    if(numbers[i] < numbers[index]){
      index = i
    }
  }
  return index;
}

//选择排序函数
let sort = (numbers) =>{
  if(numbers.length > 2){  
    let index = minIndex(numbers)
    let min = numbers[index]
    console.log('--------')
    console.log(`min的值:${min}`)
    numbers.splice(index,1)
    console.log(`numbers的值:${numbers}`)
    return [min].concat(sort(numbers))
  }else{
    return numbers[0] < numbers[1] ? numbers :
           numbers.reverse()
  }
}

下面是程序输出过程

选择排序的时间复杂度O(n^2)

快速排序

每次制定一个数组的中间数为基准，以这个数为基准，将比这个数大的数放在左边的数组中，比这个数小的放在右边数组中，然后把这两个数组这样排序，直到最后数组长度位移时不再分，这样就排完顺序了，接下来就将所有的左数组，基准数，右数组连起来就完成了

let quickSort = arr => {
  if (arr.length <= 1) { return arr } 
  console.log('----------')
  console.log(`数组中的数据:${arr}`)
  let pivotIndex = Math.floor(arr.length / 2)
  let pivot = arr.splice(pivotIndex, 1)[0]
  console.log(`基准数:${pivot}`)
  let left = []
  let right = []
  for (let i = 0; i < arr.length; i++){
    if (arr[i] < pivot) { left.push(arr[i])
    } else { right.push(arr[i]) }
  }
  console.log(`left数组:${left}`)
  console.log(`right数组:${right}`)
  return quickSort(left).concat(
         [pivot], quickSort(right) )
}

时间复杂度O(n * log2n)

归并排序

将一组数据分为两组，并自行排好顺序，我们做的就是把这两组数据合起来，合并的过程就是将排好顺序的两数组相比较，谁的首数据小我们就将这个数据提出来push进新数组

//归并操作，连接左右数组
let merge = (a,b) =>{
  if(a.length === 0) return b
  if(b.length === 0) return a
  return a[0] > b[0] ? 
      [b[0]].concat(merge(a,b.slice(1))) :
      [a[0]].concat(merge(a.slice(1),b))
}

let mergeSort = arr =>{
  if(arr.length === 1) return arr
  let left = arr.slice(0,Math.floor(arr.length/2))
  let right = arr.slice(Math.floor(arr.length/2))
  return merge(mergeSort(left),mergeSort(right))
}

时间复杂度为O(n * log2n)

计数排序

将一个数组遍历后，把出现过的数字以及出现的次数记载在一个哈希表中，然后依次打出其中的数字，出现几次打印几次

let countingSort = arr =>{
  let hashTable = {}, max = 0, result =[]
  for(let i = 0;i<arr.length;i++){//遍历数组
    if(!(arr[i] in hashTable)){
      hashTable[arr[i]] = 1
    }else{
      hashTable[arr[i]] += 1
    }
    if(arr[i]>max) max = arr[i]
  }
  for(let i=0;i<=max;i++){//遍历哈希表
    if(i in hashTable){
      for(let j=0;j<hashTable[i];j++){
        result.push(i)
      }
    }
  }
  return result
}

时间复杂度O(n+max)，只需要遍历一次数组和一次哈希表

还有其他排序算法：

avatar
文章
阅读
粉丝