数组的几种排序

//冒泡排序
// 这里的原理就是循环便利数组，内层循环遍历数组，将里面的第一个元素取出来和第二个数组比较， 然后替换位置， 第二个和第三个比较， 
// 比完之后最后一个元素一定是最小的，那么外层的第二次循环减掉一次
function bubbleSort(array) {
  var len = array.length 
  for (let outer = len; outer > 1; outer--) {
    for (let i = 0; i <= outer; i++) {
     if(array[i] > array[i + 1]) {
      let temp = array[i]
      array[i] = array[i + 1]
      array[i + 1] = temp
     }
    }
  }
  return array
}


// 使用ES6进行简化 ， 解构赋值
function bubbleSort(array) {
  var len = array.length 
  for (let outer = len; outer > 1; outer--) {
    for (let i = 0; i <= outer; i++) {
     if(array[i] > array[i + 1]) {
        [array[i] , array[i + 1]] = [array[i + 1] , array[i]]
     }
    }
  }
  return array
}

// 另外一种方法， 不容易绕晕
function bubbleSort(array) {
  var array1 = []
  while(array.length > 0) {
    for (let i = 0; i < array.length; i++) {
      if(array[i] > array[i + 1]) {
        [array[i] , array[i + 1]] = [array[i + 1] , array[i]]
      }
    }
    array1.unshift(array.pop())
  }
  return array1
}

 

 

// 选择排序
// 这里的原理就是 循环遍历数组， 每一次遍历将数组， 将里面的第一个元素分别与其他的元素进行比较， 
// 最小的一个放在第一个位置， 接下来的从第二个元素开始与其他元素进行比较
var array = [3, 1, 7, 0, 20, 10]

var selectSort = function(array) {
  let len = array.length
  //  j < len - 1 , 聚过前面的排序， 最后一个了是走大的，不用比较了
  for (let j = 0; j < len -1; j++) {
    for (let i = j; i < len; i++) {
      if(array[j] > array[i]) {
       let temp = array[j]
       array[j] = array[i]
       array[i] = temp
      }
     }
  }
  return array  
}
 
var selectSort = function(array) {
  var array1 = []
  while(array.length > 0) {
    for (let i = 0; i < array.length; i++) {
      if(array[0] > array[i]) {
        [array[0], array[i]] =[array[i], array[0]]
      }
    }
    array1.push(array.shift())
  } 
  return array1
}

 

// 插入排序
// 插入排序的工作原理就是将未排序数据，对已排序数据序列从后向前扫描，找到对应的位置并插入，最开始的默认以第一个元素为已排序的
// 插入排序通常采用占位的形式，在从后向前扫描的过程中，需要反复的把已排序的元素逐步向后挪位，为新插入元素提供插入的位置。
 function insertSort() {
  // 
  for (let i = 1; i < array.length; i++) {
    var orderIndex = i - 1   //默认以第一个作为有序序列， 后面的作为无序序列
    var currentElement = array[i] // 无序序列中即将要去和有序中元素进行比较的元素 
    // 当有序序列的下标 大于等于0并且 当 当前有序的元素大于无序中被比较的元素时
    while(orderIndex >= 0 && array[orderIndex] > currentElement) {
      // 将有序的元素往后挪一个位置, 意思就是把  array[orderIndex]  放到  array[orderIndex + 1] 的位置上面
      array[orderIndex + 1] =  array[orderIndex]
      // 然后把有序的下标减一， 然后进如下一次while里面时，就用 currentElement 与有序列表中的前面一个比较，
      // 然后知道与有序列表里面的所有元素都比完了， 就跳出来while 
      orderIndex--
    }
    // 如果那么currentElement 大于 有序中当前比对的 数字， 那就跳出来while， 
    //那么就将  currentElement 插入到有序序列中比currentElement 小的元素后面， 插入就结束了， 换没有排序序列中的下一个人数字进行比较
    array[orderIndex + 1] =  currentElement
  }
  return array
 }  

 
    

 

//快速排序
// 思路是找出一个中间点数字， 然后比这个小的放左边， 大的放右边， 然后分别递归左边和右边的数组， 最后拼在一起
function quickSort(array) {
  let len = array.length
  if(len <= 1) {
    return 
    
  }
  let left = [], right = []


  let datum = array.splice(Math.floor(len / 2), 1)[0]
  for (let i = 0; i < array.length; i++) {
    if(array[i] > datum) {
      right.push(array[i])
    }else {
      left.push(array[i])
    }
  }
  let leftArray = quickSort(left)
  let rightArray = quickSort(right)
  return leftArray.concat(datum, rightArray)
  // return quickSort(left).concat(datum, quickSort(right))
}

 组合排序：

var data = [['白色','黑色','金色','粉红色'], ['16G','32G','64G','128G'], ['移动','联通','电信']]
 

function combine(data, dataIndex = 0) {
  // 首次调用方法的时候， 把data中第一个元素的 值转换为数组
  // 后续直接用该数组去与后面的元素组合
  if(data.length > 0 && dataIndex === 0) {
    for (let i = 0; i < data[0].length; i++) {
      data[0][i] = [data[0][i]]
    }
  }
  if(data.length < 2){
    return data
  }

  var tempArrTwo = []
  var originArr = data.shift()
  var targetArr = data.shift()
  var targetLen = targetArr.length
  // 循环遍历data 的第一个参数元素， 将其子元素的 与后面一个组合的每一个人元素 合并在一起
  for (let i = 0; i < originArr.length; i++) {
    var tarIndex = 0
    // 当目标数组里面的元素都和 源数组里面的数组合并后，
    // 下一个源组合开始合并
    while(tarIndex < targetLen) {
      var newsubOriginArr = originArr[i].concat(targetArr[tarIndex])
      // 将合并得到的数组都添加到tempArrTwo 中， 在结束之后， 放入data 的首部， 得到一个新的data， 作为参数继续调用方法
      tempArrTwo.push(newsubOriginArr)
      tarIndex += 1
    }
  }
  data.unshift(tempArrTwo)
  dataIndex += 1
  return combine(data, dataIndex)
}
combine(data)

 

// 组合算法
// [a,b,c,d] 进行全排列组合 得到 [a,b,ab,c,ac,bc,abc,d,ad,bd,abd,cd,acd,bcd,abcd]

// 例子：

// 数据源a,b,c

// 1.拿出a，组合数据group为空，插入数据源a元素到组合数据group，此时group=[a]

// 2.拿出b，组合数据group拿出a，a和b组合，得到ab，把数据源b元素、ab插入组合数据group，此时group=[a,b,ab]

// 3.拿出c，组合数据group拿出a、b、ab，分别与c组合，分别得到ac、bc、abc，把数据源c元素、ac、bc、abc插入组合数据group，此时group=[a,b,ab,c,ac,bc,abc]

var data = ['a', 'b', 'c', 'd']
function groupSort(data) {
  var groups = []
  for (let i = 0; i < data.length; i++) {
    // 每次循环data吗都现将元素推入groups中
    groups.push(data[i])
    // 然后用groupsLen 接住 groups 的长度， 避免循环groups 向groups 添加数据改变长度， 使得在data 新拿出来一个元素进行组合时groups 的长度不对
    var groupsLen = groups.length
    for (let j = 0; j < groupsLen - 1; j++) {
      // 循环现有的groups， 将每一个元素与data[i] 拼接在一起， 或者groups 的最后一个元素也是一样的
      // 注意最后一个元素不需要拼接
      groups.push(groups[j] + data[i])
    }
  }
  return groups
}