排序算法

## 冒泡排序

冒泡排序，
。


```

/**
 * 冒泡排序：
 * 思想：当前项和后一样进行比较，如果当前项大于后一项，两者交换位置
 * 平均的时间复杂度为：O( n^2 )
 */

var originArr = [199, 34, 29, 432, 123, 20, 10, 9, 8]
function sort (array, type) {
  //type 0: 升序  1：降序   不传默认是升序
  //使用双循环去遍历数组，第一个循环取 array 的一个数据，第二个循环拿上个循环数据的后面一个数据，两个数据进行比较。
  for (var i = 0; i < array.length; i++) {
    for (var j = i + 1; j < array.length; j++) {
      if (array[i] > array[j]) {
        //如果 array[i] > <array[j] ，就声明一个缓存遍历 num 存放大的数据，然后把两个数据的下标进行更换，达到升序排序的效果。
        var num = array[i];
        array[i] = array[j];
        array[j] = num;
      }
    }
  }
  //return 根据需要可写可不写。
  if (type) {
    array.reverse()
  }
  return array;
}
var currentArr = sort(originArr, 0);
console.log(currentArr)
```







## 快速排序

```
/**
 * 快速排序（分治法）
 * 思想：(1)组中选定一个基数，然后把数组中的每一项与此基数做比较;
 *      (2)小的放入一个新数组，大的放入另外一个新数组。
 *      (3)再对左右区间重复第二步，直到各区间只有一个数.
 * 平均的时间复杂度为:O(nlogn)
 * 
 */

var originArr = [199, 34, 432, 29, 123, 8]

function sortQuickArr (arr) {
  if (arr.length <= 1) {

    return arr
  }

  var baseIndex = Math.floor(arr.length / 2)
  var baseData = arr.splice(baseIndex, 1)[0]
  var leftData = []
  var rightData = []

  for (var i = 0; i < arr.length; i++) {
    if (arr[i] < baseData) {
      leftData.push(arr[i])
    } else {
      rightData.push(arr[i])
    }
  }

  return sortQuickArr(leftData).concat([baseData], sortQuickArr(rightData));
}
sortQuickArr(originArr)
console.log(sortQuickArr(originArr))

```



## 插入排序



```
/**
 * 插入排序
 * 思想：把一个元素，在一个已经是排好序的有序表中，找到合适的位置，并插入，从而得到的还是一个有序的表
 *      期间，可以使用折半查找，也可以使用最原始的逐一比对方法。
 * 平均的时间复杂度为O( n^2 )
 */

var originArr = [199, 34, 29, 432, 123, 20, 10, 9, 8]

function getArr (arr) {
  for (let i = 0; i < arr.length; i++) {
    let min = arr[i]
    for (let j = i + 1; j < arr.length; j++) {
      if (min > arr[j]) {
        [min, arr[j]] = [arr[j], min]//交换两个元素的位置
      }
    }
    arr[i] = min
  }
  return arr
}
getArr(originArr)
```



## 简单选择排序


```
/**
 * 简单选择排序
 * 思想：从一组元素中，选出最小的放在第一个位置，然后再从剩下的元素中，选出最小的，放在第二个位置上。
 * 
 * 时间复杂度：O（n^2）
 * 
 */

var originArr = [12, 43, 23, 542, 214, 5, 3, 32, 23]

function getArr (arr) {
  var arrLength = arr.length;

  for (let i = 0; i < arrLength - 1; i++) {
    let num = i
    for (var j = i + 1; j < arrLength; j++) {
      if (arr[i] > arr[j]) {//寻找最小值
        num = j//保存最小值的索引
      }
    }

    if (num != i) {
      let temp = arr[i];
      arr[i] = arr[num];
      arr[num] = temp;
    }
  }
  return arr


}
getArr(originArr)

result:

[3, 23, 12, 43, 32, 5, 23, 214, 542]
```


### 希尔排序


```
var originArr = [12, 43, 23, 542, 214, 5, 3, 32, 23]
function getArr (arr) {
  var len = arr.length,
    temp,
    footLang = 1;
  while (footLang < len / 3) {
    footLang = footLang * 3 + 1;
  }
  for (footLang; footLang > 0; footLang = Math.floor(footLang / 3)) {
    for (var i = footLang; i < len; i++) {
      temp = arr[i];
      for (var j = i - footLang; j >= 0 && arr[j] > temp; j -= footLang) {
        arr[j + footLang] = arr[j];
      }
      arr[j + footLang] = temp;
    }
  }
  return arr;
}

getArr(originArr)


```
发现一篇好文章，推荐文章：
http://louiszhai.github.io/2016/12/23/sort/#%E5%B8%8C%E5%B0%94%E6%8E%92%E5%BA%8F
复制代码