//冒泡排序
// 这里的原理就是循环便利数组,内层循环遍历数组,将里面的第一个元素取出来和第二个数组比较, 然后替换位置, 第二个和第三个比较,
// 比完之后最后一个元素一定是最小的,那么外层的第二次循环减掉一次
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
}