- [1.冒泡排序]
- [2.快速排序]
- [3.选择排序]
- [4.归并排序]
- [5.希尔排序]
排序
在我们的程序中，排序是非常常见的一种需求，提供一些数据元素，把这些数据元素按照一定的规则进行排序。比如查询一些订单，按照订单的日期进行排序；再比如查询一些商品，按照商品的价格进行排序等等。 在java的开发工具包jdk中，已经给我们提供了很多数据结构与算法的实现，比如List，Set，Map，Math等等，都是以API的方式提供，这种方式的好处在于一次编写，多处使用。
1.冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的[排序算法]
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。 走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
冒泡排序的排序原理
- 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
- 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
- 每排序出来一个值，排序的次数-1.即第二轮循环j < arr.length-i
function bubbleSort(arr) {
var num = 0;
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length-i; j++) {
//注意j的循环次数是arr.length-i，因为每冒泡出了一个数这个数就不用再排序了。
if (arr[j] > arr[j + 1]) {
num = arr[j + 1]
arr[j + 1] = arr[j]
arr[j] = num;
}
}
}
return arr;
}
时间复杂度：O(n^2)
2.快速排序
快排，是对冒泡排序的一种优化。对于处理大数据来说，这是一种速度最快的算法。
基本思想：他是一种分而治之的算法，找出一个参考值，通过递归的方式将数据一次分解为包含较小元素和较大元素的不同子序列，重复这个步骤直到所有数据都是有序的
步骤：
1、首先设定一个分界值，通过该分界值将数组分成左右两部分。
2、将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。
3、然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4、重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
代码实现：
function quickSort(arr) {
let left = [],right = [],current = arr[0];
if(arr.length <= 1) return arr;
for(let i=1;i<arr.length;i++) {
//注意这里从1开始循环，因为0号位已经用来做中间值了。
if(arr[i]<current) {
left.push(arr[i])
}
if(arr[i]>current) {
right.push(arr[i])
}
}
return quickSort(left).concat(current,quickSort(right))
}
时间复杂度：O(nlogn)
4.选择排序
基本思想：首先在待排序的序列中选出最大值（或最小值），存放在排序序列的起始位置，然后再从剩余未排序的序列中继续选出最大值（或最小值），放在已排序的队列的末尾，以此类推，直到所有元素排序完成。
步骤：
- 初始状态：无序区为
[1,...,n], 有序区为空 - 第
i（i=1,2,3...n)趟排序时，当前有序区和无需区分别为[1, ...,i-1]和[i,...,n], 该趟排序从无序列表中选出最小（大）的元素，将它与无需区的第一个元素交换 - n-1趟结束后，数组就是有序的了
function selectSort(arr) {
let len = arr.length, minIndex, tem
for(let i=0; i<len-1; i++) {
minIndex = i //最小值下标
for(let j=i+1; j<len; j++) {
if(arr[j] < arr[minIndex]){
// 找出最小值
minIndex = j //更换最小值下标
}
}
// 交换位置
tem = arr[i]
arr[i] = arr[minIndex]
arr[minIndex] = tem
}
return arr
}
时间复杂度：O(n^2);
5.归并排序
归并的含义是将两个或两个以上的有序序列合并成一个有序序列的过程。 基本思想：将若干有序序列逐步归并，最终归并为一个有序序列。
步骤：
第一步：将序列中待排序数字分为若干组，每个数字分为一组。
第二步：将若干组两两合并，保证合并的组都是有序的。
第三步：重复第二步的操作，直到剩下最后一组即为有序数列。 代码实现：
// 归并排序类似于 快排 + 冒泡排序
function merge(left, right) {
// 由于是从中间开始分,故left和right两个数组的长度相差小于等于1。
let tem = []
while (left.length && right.length) {
// 这里类似于冒泡,将小的冒泡出去,剩下的就是大的，大的拼接在后面即可。
if (left[0] < right[0]) {
tem.push(left.shift())
} else {
tem.push(right.shift())
}
}
return tem.concat(left, right)
}
function mergeSort(arr) {
if (arr.length < 2) return arr;
let mid = Math.floor(arr.length / 2), left = arr.slice(0, mid), right = arr.slice(mid)
// 这里类似快排，区别在于这里从中间位置开始分开，而快排从某个值开始分开。
return merge(mergeSort(left), mergeSort(right))
}
时间复杂度：O(nlog(n))
6*.希尔排序
希尔排序是插入排序的一种，也称缩小增量排序，是直接插入排序的一种更加高效的改进版本。 基本思想：把记录按的一定增量分组，对每组使用直接插入排序，随着增量的逐步减少，每组包含的元素越来越多，当增量减少到1时，整个序列被分成一组，排序完成。
步骤：
- 选择一个增量序列t1,t2,t3…tk, 其中ti>tj,tk=1
- 按增量序列个数k,对序列进行k趟排序
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度 代码实现：
function shellSort(arr) {
var len = arr.length;
for(var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
for(var i = gap; i < len;i++) {
var j = i;
var current = arr[i];
while (j - gap >= 0 && current < arr[j - gap]) {
arr[j] = arr[j - gap];
j = j - gap;
}
arr[j] = current;
}
}
return arr;
}
时间复杂度：O(nlogn)
