常见的排序算法
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
常见的内部排序算法有：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序等。
冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法描述
1、比较相邻的元素。如果第一个比第二个大，就交换它们两个
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
3、针对所有的元素重复以上的步骤，除了最后一个
4、重复步骤1~3，直到排序完成
代码实现
// 冒泡排序
func bubbleSort(array: [Int]) -> [Int] {
var sortArray = array
for i in 0..<sortArray.count {
for j in 0..<sortArray.count - 1 - i {
if sortArray[j] > sortArray[j + 1] {
let temp = sortArray[j]
sortArray[j] = sortArray[j + 1]
sortArray[j + 1] = temp
}
}
}
return sortArray
}
print(bubbleSort(array: [3,0,7,5,9,2,1,4])) // [0, 1, 2, 3, 4, 5, 7, 9]
选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
1、初始状态：无序区为R[1..n]，有序区为空；
2、第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
3、n-1趟结束，数组有序化了。
代码实现
// 选择排序
func selectionSort(array: [Int]) -> [Int] {
var sortArray = array
for i in 0..<sortArray.count {
var minValueIndex = i
for j in (minValueIndex + 1)..<sortArray.count {
if sortArray[minValueIndex] > sortArray[j] { // 得到最小值位置
minValueIndex = j
}
}
// 与最小值进行交换
let temp = sortArray[i]
sortArray[i] = sortArray[minValueIndex]
sortArray[minValueIndex] = temp
}
return sortArray
}
print(selectionSort(array: [3,0,7,5,9,2,1,4])) // [0, 1, 2, 3, 4, 5, 7, 9]
插入排序
插入排序（Insertion-Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
算法描述
1、从第一个元素开始，该元素可以认为已经被排序
2、取出下一个元素，在已经排序的元素序列中从后向前扫描
3、如果该元素（已排序）大于新元素，将该元素移到下一位置
4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5、将新元素插入到该位置后
6、重复步骤2~5
代码实现
// 插入排序
func insertSort(array: [Int]) -> [Int] {
var sortArray = array
for i in 1..<sortArray.count {
let value = sortArray[i] // 最小值
var j = i - 1
while (j >= 0 && sortArray[j] > value) { // 由后向前比较
sortArray[j+1] = sortArray[j]
j -= 1
}
sortArray[j+1] = value
}
return sortArray
}
希尔排序
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
希尔排序的提出，主要基于以下两点：
- 1、插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
- 2、但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位
算法描述
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
1、选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2、按增量序列个数k，对序列进行k 趟排序；
3、每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
代码实现
func shellSort(array: [Int]) -> [Int] {
var sortArray = array
var gap = sortArray.count / 2 // 数组的一半
while gap > 0 {
var i = 0
while i < sortArray.count { // 遍历整个数组
var j = i
while j < sortArray.count - gap {
if sortArray[j] > sortArray[j + gap] { // 前面的值大于后面的值
// 交换值
let temp = sortArray[j]
sortArray[j] = sortArray [j + gap]
sortArray[j + gap] = temp
}
j += gap
}
i += 1
}
gap /= 2 // 每次减半
}
return sortArray
}
归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
算法描述
- 申请空间，创建两个数组，长度分别为两个有序数组的长度
- 设定两个指针，最初位置分别为两个已经排序序列的起始位置
- 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
- 重复步骤3直到某一指针达到序列尾
- 将另一序列剩下的所有元素直接复制到合并序列尾
代码实现
// 归并排序
func mergeSort(array: [Int]) -> [Int] {
var sortArray = array
let arrayCount = sortArray.count
if arrayCount < 2 { return sortArray }
let sortArrayMiddleIndex = arrayCount / 2 - 1
// 分为左右两个数组
let leftArray = Array(sortArray[0...sortArrayMiddleIndex])
let rightArray = Array(sortArray[(sortArrayMiddleIndex + 1)...(arrayCount - 1)])
// 合并左右两个数组
sortArray = mergeArray(leftArray: mergeSort(array: leftArray), rightArray: mergeSort(array: rightArray))
return sortArray
}
func mergeArray(leftArray: [Int], rightArray: [Int]) -> [Int] {
var mergedArray: [Int] = []
let minArray = leftArray.count < rightArray.count ? leftArray : rightArray
let maxArray = leftArray.count < rightArray.count ? rightArray : leftArray
var minIndex = 0, maxIndex = 0 // 老哥数组的起始位置
while minIndex < minArray.count {
if maxIndex >= maxArray.count {
mergedArray.append(minArray[minIndex])
minIndex += 1
continue
}
// 比较两个数组中的元素，小的元素先添加到数组
if minArray[minIndex] < maxArray[maxIndex] {
mergedArray.append(minArray[minIndex])
minIndex += 1
} else {
mergedArray.append(maxArray[maxIndex])
maxIndex += 1
}
}
while minIndex < minArray.count {
mergedArray.append(maxArray[minIndex])
minIndex += 1
}
while maxIndex < maxArray.count {
mergedArray.append(maxArray[maxIndex])
maxIndex += 1
}
return mergedArray
}
快速排序
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
直观图
算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
1、从数列中挑出一个元素，称为 “基准”（pivot）；
2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
代码实现
func quickSort(array: [Int]) -> [Int] {
guard array.count > 1 else {
return array
}
var sortArray = array
// 快排
quickSortMethod(sortArray: &sortArray, leftIndex: 0, rightIndex: sortArray.count - 1)
return sortArray
}
// 快速排序
func quickSortMethod(sortArray: inout [Int], leftIndex: Int, rightIndex: Int) {
var left = leftIndex, right = rightIndex, baseLineIndex = 0
if left < right {
baseLineIndex = partition(array: &sortArray, leftIndex: leftIndex, rightIndex: rightIndex)
quickSortMethod(sortArray: &sortArray, leftIndex: leftIndex, rightIndex: baseLineIndex - 1) // 左边
quickSortMethod(sortArray: &sortArray, leftIndex: baseLineIndex + 1, rightIndex: rightIndex)
}
}
// 基准位置
func partition(array: inout [Int], leftIndex: Int, rightIndex: Int) -> Int {
var pivot = leftIndex, index = pivot + 1
var i = index
while i <= rightIndex {
if array[i] < array[pivot] {
swap(array: &array, leftIndex: i, rightIndex: index)
index += 1
}
i += 1
}
swap(array: &array, leftIndex: pivot, rightIndex: index - 1)
return index - 1
}
// 交换值
func swap(array: inout [Int], leftIndex: Int, rightIndex: Int) {
let temp = array[leftIndex]
array[leftIndex] = array[rightIndex]
array[rightIndex] = temp
}
堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
算法描述
1、将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
2、将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
3、由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
代码实现
var length: Int = 0
func heapSort(array: [Int]) -> [Int] {
guard array.count > 1 else {
return array
}
var sortArray = array
createMaxHeap(array: &sortArray)
var index = sortArray.count - 1 // 最后元素位置
while index > 0 {
swap(array: &sortArray, leftIndex: 0, rightIndex: index)
length -= 1
heapify(array: &sortArray, index: 0)
index -= 1
}
return sortArray
}
// 创建大顶堆
func createMaxHeap(array: inout [Int]) {
length = array.count
var i = length / 2 // 根结点位置
while i >= 0 {
heapify(array: &array, index: i)
i -= 1
}
}
// 堆化
func heapify(array: inout [Int], index: Int) {
let left = 2 * index + 1 // 左子节点
let right = 2 * index + 2 // 右子节点
var largest = index
// 找到最大值位置
if left < length && array[left] > array[largest] {
largest = left
}
if right < length && array[right] > array[largest] {
largest = right
}
// 前后值不一样，进行交互
if largest != index {
swap(array: &array, leftIndex: index, rightIndex: largest)
heapify(array: &array, index: largest)
}
}
func swap(array: inout [Int], leftIndex: Int, rightIndex: Int) {
let temp = array[leftIndex]
array[leftIndex] = array[rightIndex]
array[rightIndex] = temp
}
计数排序
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
算法描述
1、找出待排序的数组中最大和最小的元素；
2、统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
3、对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
4、反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
代码实现
func countingSort(array: [Int]) -> [Int] {
guard !array.isEmpty else {
return array
}
var maxValue = array[0] // 最大值
var minValue = array[0] // 最小值
// 找到数组中的最大值和最小值
for item in array {
maxValue = maxValue < item ? item : maxValue
minValue = minValue < item ? minValue : item
}
// 创建一个元素个数为 max-min 的数组
var list: [Int] = Array(repeating: 0, count: maxValue - minValue + 1)
// 遍历计数
for item in array {
let a = item - minValue
let count = list[a] + 1
list[a] = count
}
// 返回结果
var resultList:[Int] = Array()
for (index,item) in list.enumerated() {
if item == 0 { //当前值没有计数，直接进入下个元素
continue
}
for _ in 0..<item { //计数为3，即遍历3次添加数值
let num = index + minValue
resultList.append(num)
}
}
return resultList
}
桶排序
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，需要做到这两点：
- 在额外空间充足的情况下，尽量增大桶的数量
- 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
算法描述
- 设置固定数量的空桶
- 把数据放到对应的桶中
- 对每个不为空的桶中数据进行排序
- 拼接不为空的桶中数据，得到结果
代码实现
var bucket = 5
func bucketSort(array: [Int]) -> [Int] {
guard !array.isEmpty else {
return array
}
var max: Int = array[0] // 最大值
var min: Int = array[0] // 最小值
for item in array {
//找出最大值
max = max < item ? item : max
//找出最小值
min = min < item ? min : item
}
// 获取桶的个数
let buckets = bucketCount(min: min, max: max, arr: array)
var bucketList: [[Int]] = Array() // 二维数组
for _ in 0..<buckets {
bucketList.append([Int]())
}
// 将数据分配到各个桶中
for item in array {
let index = (item - min) / bucket
var items = bucketList[index]
items.append(item)
bucketList[index] = items
}
// 对每个桶进行排序，这里使用了插入排序
var resultList: [Int] = []
for items in bucketList {
let sorts = insertSorting(array: items)
resultList += sorts
}
return resultList
}
// 获取桶的个数
func bucketCount(min: Int, max: Int, arr: [Int]) -> Int {
let num1 = (max - min + 1) / bucket
let num2 = (max - min + 1) % 5 > 0 ? 1 : 0
return num1 + num2
}
// 插入排序
func insertSorting(array: [Int]) -> [Int]{
var sortArray = array
for i in 0..<sortArray.count {
for j in stride(from: i, to: 0, by: -1) {
if sortArray[j] < sortArray[j-1]{
sortArray.swapAt(j, j-1)
}
}
}
return sortArray
}
基数排序
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。
- 将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零
- 从最低位开始，依次进行一次排序
- 从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列
代码实现
var data: [Int] = Array()
func radixSort(array: [Int]) -> [Int] {
data = array
recursiveSort(num: 1)
return data
}
// 递归
func recursiveSort(num: Int) {
let mode = num * 10
var buckets = [[Int]]()
for _ in 0..<10 {
buckets.append([Int]())
}
// 判断递归是否结束,默认结束，
// 当取余的所有值都为0的时候证明已经遍历到了最高位，递归结束
var end = true
for item in data {
let temp = (item % mode) / num
if temp != 0{
end = false
}
var tempArr = buckets[temp]
tempArr.append(item)
buckets[temp] = tempArr
}
if end {
return
}
// 取出结果
data.removeAll()
for item in buckets {
data += item
}
recursiveSort(num: mode)
}
