javascript排序算法对比

 时间复杂度看运行情况，空间复杂度看占用的空间

 冒泡排序：

export default (arr) => {
  // 冒泡排序
  for (let i = arr.length - 1, tmp; i > 0; i--) {
    for (let j = 0; j < i; j++) {
      tmp = arr[j]
      if (tmp > arr[j + 1]) {
        arr[j] = arr[j + 1]
        arr[j + 1] = tmp
      }
    }
  }
  return arr
}

　　选择排序：

//选择排序
export default (arr) => {
  // 选择排序
  for (let i = 0, len = arr.length, min; i < len; i++) {
    min = arr[i]
    for (let j = i + 1; j < len; j++) {
      if (arr[j] < min) {
        let c = min
        min = arr[j]
        arr[j] = c
      }
    }
    arr[i] = min
  }
  return arr
}

 常规做法：

export default (arr) => {
  // 如果数组长度小于2返回0
  if (arr.length < 2) {
    return 0
  }
  // 排序
  arr.sort()
  // 用它来保存相邻元素的最大差值
  let max = 0
  for (let i = 0, len = arr.length - 1, tmp; i < len; i++) {
    tmp = arr[i + 1] - arr[i]
    if (tmp > max) {
      max = tmp
    }
  }
  return max
}

export default (arr) => {
  if (arr.length < 2) {
    return 0
  }
  let max = 0
  let len = arr.length - 1
  let space
  for (let i = len, tmp; i > 0; i--) {
    for (let j = 0; j < i; j++) {
      tmp = arr[j]
      if (tmp > arr[j + 1]) {
        arr[j] = arr[j + 1]
        arr[j + 1] = tmp
      }
    }
    if (i < len) {
      space = arr[i + 1] - arr[i]
      if (space > max) {
        max = space
      }
    }
  }
  return Math.max(max, arr[1] - arr[0])
}

export default (arr) => {
  // 进行升序排序
  arr.sort((a, b) => a - b)
  // 声明一个空数组用来存储奇偶排序后的数组
  let r = []
  // 记录奇数、偶数位下标
  let odd = 1
  let even = 0
  // 对数组进行遍历
  arr.forEach(item => {
    if (item % 2 === 1) {
      r[odd] = item
      odd += 2
    } else {
      r[even] = item
      even += 2
    }
  })
  return r
}

export default (arr,k)=>{
  arr.sort((a,b)=>b-a)[k-1]
}

export default (arr, k) => {
  let len = arr.length - 1
  for (let i = len, tmp; i > len - k; i--) {
    for (let j = 0; j < i; j++) {
      if (arr[j] > arr[j + 1]) {
        tmp = arr[j]
        arr[j] = arr[j + 1]
        arr[j + 1] = tmp
      }
    }
  }
  // arr[len+1-k]
  return arr[len - (k - 1)]
}

export default (arr) => {
  // 过滤掉非正整数
  arr = arr.filter(item => item > 0)
  // 正整数数组是不是为空
  if (arr.length) {
    // 升序，目的：方便从左到右取最小值arr[0]
    arr.sort((a, b) => a - b)
    // 如果第一个元素不为1，返回1
    if (arr[0] !== 1) {
      return 1
    } else {
      // 从左边开始遍历，只要下一个元素和当前元素差值》1说明当前元素的下一个值（+1）
      for (let i = 0, len = arr.length - 1; i < len; i++) {
        if (arr[i + 1] - arr[i] > 1) {
          return arr[i] + 1
        }
      }
      // 如果数组是连续的正整数【1,2,3,4,5,6】
      return arr.pop() + 1
    }
  } else {
    return 1
  }
}

export default (arr) => {
  arr = arr.filter(item => item > 0)
  // 实现选择排序，先拿到最小值，如果第一个元素不是1直接返回1，如果是1，就要比相邻元素差值
  for (let i = 0, len = arr.length, min; i < len; i++) {
    min = arr[i]
    for (let j = i + 1; j < len; j++) {
      if (arr[j] < min) {
        let c = min
        min = arr[j]
        arr[j] = c
      }
    }
    arr[i] = min
    if (i > 0) {
      if (arr[i] - arr[i - 1] > 1) {
        return arr[i - 1] + 1
      }
    } else {
      if (min !== 1) {
        return 1
      }
    }
  }
  return arr.length ? arr.pop() + 1 : 1
}

 递归：

export default (str) => {
  // 保存所有符合条件的IP地址
  let r = []
  // 分四步递归处理ip分段
  let search = (cur, sub) => {
    // 边界条件
    if (cur.length === 4 && cur.join('') === str) {
      r.push(cur.join('.'))
    } else {
      // 正常的处理过程
      for (let i = 0, len = Math.min(3, sub.length), tmp; i < len; i++) {
        tmp = sub.substr(0, i + 1)
        if (tmp < 256) {
          search(cur.concat([tmp]), sub.substr(i + 1))
        }
      }
    }
  }
  search([], str)
  return r
}

　　拆分单词：

export default (str, words) => {
  // 保存结果
  let result = []
  // 记录数组的长度，做边界条件计算
  let num = words.length
  // 递归函数体
  let range = (r, _arr) => {
    if (r.length === num) {
      result.push(r)
    } else {
      _arr.forEach((item, idx) => {
        let tmp = [].concat(_arr)
        tmp.splice(idx, 1)
        range(r.concat(item), tmp)
      })
    }
  }
  range([], words)
  // [0, 9, -1] filter 之后[0,9]
  return result.map(item => {
    return str.indexOf(item.join(''))
  }).filter(item => item !== -1).sort()
}

　　棒球求和

export default (arr)=>{
  //用数组实现堆栈结构 pop push
  let result=[]
  //上一轮的数据
  let pre1
  //上上轮的数据
  let pre2
  //对数组进行遍历，遍历的目的是处理得分
  arr.forEach(item=>{
    switch(item){
      case 'C':
       if(result.length){
         result.pop()
       }
      break
      case 'D':
       pre1=result.pop()
       result.push(pre1,pre1*2)
      break

      case '+':
        pre1=result.pop()
        pre2=result.pop(pre2,pre1,pre2+pre1)

        break
      default:
        result.push(item*1)
    }
  })
  return  result.reduce((total,num)=>{return total+num})
}

export default (arr)=>{
  let result=[]
  let reg=/1{2,}/g
  //把二维数组重新表达，把相邻的1提取出来（起始点+截止点）
 arr= arr.map(item=>{
   let str=item.join('')
   let r=reg.exec(str)
   let rs=[]
   while(r){
     rs.push([r.index,r.index + r[0].length-1]) //起始位置和结尾位置
     r=reg.exec(str)
   }
   return rs
  })
  //通过递归计算相邻的矩阵
  let maxRect=(arr,result,n=1)=>{
    //弹出第一行
    let top=arr.pop()
    //弹出第二行
    let next=arr.pop()
    //记录第一行的每一个起始点和截止点  
    let tt
    //记录第二行的每一个起始点和截止点
    let nn
    //记录交叉的起始索引
    let start
    //记录交叉的截止位置
    let end
    let width=1
    let maxWidth=1
    n++
    for(let i=0,il=top.length;i<il;i++){
      tt=top[i]
      for(let j=0,jl=next.length;j<jl;j++){
        nn=next[j]
        width=Math.min(tt[1],nn[1])-Math.max(tt[0],nn[0])
        if(width>maxWidth){
          maxWidth=width
          start=Math.max(tt[0],nn[0])
          end =Math.min(tt[1],nn[1])
        }
      }
    }
    //如果没有找到交叉点
    if(start===undefined||end===undefined){
     if(n<3){
       return false
     }else{
       width=rop[0][1]-top[0][0]+1
       if(width>1){
         result.push((n-1)*width)
       }
     }
    }else{
      arr.push([[start,end]])
      maxRect(arr,result,n++)
    }
  }
  while(arr.length>1){
    maxRect([].concat(arr),result)
    arr.pop()
  }
  //取最大值
  let max=0
  let item=result.pop()
  while(item){
    if(item> max){
      max>=item
    }
    item=result.pop()
  }
  return max>0?max:-1
}