作为一个程序员,你怎么能不了解冒泡算法呢?
下面向大家介绍六中排序算法,并提供javascript实现,以及简单分析算法复杂度。
1. 简单排序方法
1.1 冒泡排序
总体描述:
相邻元素进行比较,每次选取最大的元素,进行下一次比较,因此可以将最大的元素像冒泡一样,从某一位置,到达最顶端
算法简单描述:
假设:共有n个元素
进行(n-1)次循环,第i(从1开始计数)次循环获得第i大的元素,放在数组第(n-i)(数组从0开始计数)位
每次循环都从第一个元素开始,比较当前元素与其后一个元素的大小关系,如果后一个元素小于当前元素,则说明,当前元素较大,互换位置,即将(0~n-i区间最大的数放在n-i位),并将当前元素指向下一个位置,直到当前位置指向0,循环结束
完整代码:
function bubbleSort(originArr) { /* 数组副本 */ var cloneArr = originArr.concat(); /* 用于交换数据 */ var temp; /* 数组长度 */ var len = cloneArr.length; /* 每次选择出最大的元素 */ /* 通过比较相邻元素,将较大的元素放在后面,将较大的数继续进行比较 */ for (var i = 0; i < len - 1; ++i) { // 需要执行len-1次 for (var j = 0; j < len - i; ++j) { // 需要执行len-i-1次 // 如果当前元素大于下一个元素,互换两个元素 if (cloneArr[j] > cloneArr[j + 1]) { // 执行(1 + 2 + ... + n-1)算法复杂度为O(n^2) temp = cloneArr[j]; cloneArr[j] = cloneArr[j + 1]; cloneArr[j + 1] = temp; } } } return cloneArr; }
1.2 选择排序
总体描述:
每次选择最小的元素,放在相应的位置上
算法简单描述:
假设:共有n个元素
进行(n-1)次循环,第i(从1开始计数)次循环获得第i小的元素,放在数组第(i-1)(数组从0开始计数)位,第i次循环,从数组第(i-1)位开始,将该位置元素与其后所有元素进行比较,获取较小元素索引,循环结束之后,将当前元素与最小索引位置元素位置互换,当前位置向前移动,进行下一轮循环,直到当前位置指向(n-1)
完整代码:
function selectionSort(originArr) { /* 数组副本 */ var cloneArr = originArr.concat(); /* 用于交换数据 */ var temp; /* 存放最小元素索引 */ var minIndex = 0; /* 数组长度 */ var len = cloneArr.length; /* 从第一个位置开始,比较当前位置和后面所有元素,获取最小元素后面的位置 */ for (var i = 0; i < len - 1; ++i) { // 需要执行len-1次 minIndex = i; // 获取最小元素位置 for (var j = i + 1; j < len; ++j) { // 需要执行len-i-1次 if (cloneArr[minIndex] > cloneArr[j]) { // 执行(1 + 2 + ... + n-1)算法复杂度为O(n^2) minIndex = j; } } // 如果最小元素所在索引,不是当前位置,交换元素 if (minIndex !== i) { temp = cloneArr[i]; cloneArr[i] = cloneArr[minIndex]; cloneArr[minIndex] = temp; } } return cloneArr; }
1.3 插入排序
总体描述:
将数组分为前后两部分,前一部分是已排序的元素集合,后一部分是未排序的元素集合。每次选中未排序的第一个数组,插入到已排序集合中的合适的位置
算法简单描述:
假设:共有n个元素
从第2个元素开始,进行(n-1)次循环,第i次循环,将第i个元素插入到之前位置(1~i-1)中,将当前元素依次后面元素进行比较。比较元素起始值为当前元素前一位置元素,如果当前元素小于比较元素,比较元素向数组后面移动,当前元素继续与下一个元素进行比较,直到比较元素位置为0或者当前元素大于比较元素,将元素插入当前比较位置
完整代码:
function insertSort(originArr) { /* 数组副本 */ var cloneArr = originArr.concat(); /* 用于交换数据 */ var temp; /* 数组长度 */ var len = cloneArr.length; /* 循环数组中的每一个元素 */ for (var i = 1; i < len; ++i) { // 需要执行len-1次 // 记录要插入的值 temp = cloneArr[i]; // 找到合适的位置插入 for (var j = i - 1; j >= 0; --j) { // 需要执行i次 if (temp < cloneArr[j]) { // 执行(1 + 2 + ... + n-1)算法复杂度为O(n^2) // 右移已排序数组 cloneArr[j + 1] = cloneArr[j]; } else { break; } } cloneArr[j + 1] = temp; } return cloneArr; }
2. 高级排序算法
2.1 希尔排序
总体描述:
希尔排序就是插入排序的优化,插入排序,每次将当前元素与之前的每一个元素进行比较,然后插入,希尔排序,相当于先按照一定步长,将数组进行分组,对每一组进行插入排序,这样就可以大幅度的调整数据的分布情况,最后执行一次快速排序进行微调
算法简单描述:
对于间隔数组中的每个元素gap,将数组元素根据gap分为gap组,对于每组进行插入排序
完整代码:
function shellSort(originArr) { /* 数组副本 */ var cloneArr = originArr.concat(); /* 用于交换数据 */ var temp; /* 数组长度 */ var len = cloneArr.length; /* 间隔数组 */ var gap = []; /* 动态创建间隔数组 */ for (var i = Math.floor(len / 2); i > 0;) { gap.push(i); i = Math.floor(i / 2); } /* 使用间隔数组中的每一个元素,选择数组中的元素,进行快速排序 */ /* 方法1: 对每一个间隔的每一个分组进行快速排序 */ /*for (var i = 0, gapLen = gap.length; i < gapLen; ++i) { // 分为gap[i]组分别进行排序 for (var j = 0; j < gap[i]; ++j) { // 第j组进行排序 for (var k = j + gap[i]; k < len; k = k + gap[i]) { temp = cloneArr[k]; while (k - gap[i] >= 0 && cloneArr[k - gap[i]] > temp) { cloneArr[k] = cloneArr[k - gap[i]]; k = k - gap[i]; } cloneArr[k] = temp; } } }*/ /* 方法2: 对于每一个间隔,从间隔位置开始,对其后每一个元素进行快速排序,保证前面的已经排好序 */ for (var i = 0, gapLen = gap.length; i < gapLen; ++i) { for (var j = gap[i]; j < len; ++j) { temp = cloneArr[j]; var k = j; while (k - gap[i] >= 0 && cloneArr[k - gap[i]] > temp) { cloneArr[k] = cloneArr[k - gap[i]]; k -= gap[i]; } cloneArr[k] = temp; }
// 最坏情况O(n(logn)^2) 平均情况O(n(logn)^2) } return cloneArr; }
2.2 快速排序
总体描述:
每次选取一个基准值,将数组中其他的元素和它进行比较,大于则移到数组右边,小于则移到左边。然后分类出来的数组继续进行上述操作。
算法简单描述:
选择数组第一位元素位基准值,创建两个新数组,分别存放小于基准值和大于基准值的元素。然后这两个新数组递归进行上述操作,直到数组为空。然后将左右数组和基准值进行拼接
完整代码:
function quickSort(originArr) { /* 如果数组为空,直接返回 */ if (originArr.length === 0) { return []; } /* 基准值 */ var pivot = originArr[0]; /* 分别存放大于小于数组 */ var lesser = []; var greater = []; /* 小于基准值,存放到lesser数组中,否则存放到greater数组中 */ for (var i = 1; i < originArr.length; ++i) { if (originArr[i] < pivot) { lesser.push(originArr[i]); } else { greater.push(originArr[i]); }
// 最坏情况O(n^2) 平均情况O(nlogn) } /* 将数组拼接后返回 */ return quickSort(lesser).concat(pivot, quickSort(greater)); }
2.3 归并排序
总体描述:
自顶向下:先通过递归分解数组,再合并数组
算法简单描述:
分解数组:如果数组长度不为1,从中间将数组分为两部分,继续分解
合并数组:将分解的数组融合,创建一个新数组,用于存放融合的数组元素。创建指针分别指向两个数组的首位,比较当前指针指向位置元素的大小,将较小的元素插入新数组中,指针向后移动,直到有一个数组元素全部移出。最后检查两个数组,将未移出的元素追加到新数组中,最后存放已排序的数组根据对应位置存入待排序数组中
完整代码:
function mergeSort(originArr) { /* 数组副本 */ var cloneArr = originArr.concat(); /* 调用归并排序 */ doMergeSort(cloneArr, 0, cloneArr.length - 1); return cloneArr; } /* 向下分解数组,递归调用 */ function doMergeSort(arr, low, high) { if (low < high) { var mid = low + Math.floor((high - low) / 2); doMergeSort(arr, low, mid); doMergeSort(arr, mid + 1, high); merge(arr, low, mid, high);
// 最坏情况O(nlogn) 平均情况O(nlogn) } } /* 数组融合 */ function merge(arr, low, mid, high) { var p_low = low; var p_high = mid + 1; var sortArr = []; /* 比较左右部分元素,将较小的元素存放在sortArr前面 */ while (p_low <= mid && p_high <= high) { if (arr[p_low] > arr[p_high]) { sortArr.push(arr[p_high++]); } else { sortArr.push(arr[p_low++]); } } /* 将两部分可能剩余的元素复制到数组中 */ while (p_high <= high) { sortArr.push(arr[p_high++]); } while (p_low <= mid) { sortArr.push(arr[p_low++]); } /* 将已排序的数组复制到原数组对应位置 */ for (var i = low; i < high + 1; i++) { arr[i] = sortArr[i - low]; } }
3. 最终测试结果
100000数组测试: