下面让我们一起来见识一下swift中基于Array的扩展的冒泡排序，选择排序和快速排序吧。
1.冒泡排序
冒泡排序再基础不过了，这里就不再讲其原理了，实在不会可以看下百度百科冒泡排序
既然冒泡排序避免不了数组中两个数据交换，先写一个交换函数
// 交换数组中i和j两个位置的数据
extension Array {
fileprivate mutating func
swap(i:Int,j:Int) {
let temp = self[i]
self[i] = self[j]
self[j] = temp
}
}
下面就是排序了也很简单就不多解释了
//
MARK: - 冒泡排序
/**
* 通过与相邻元素的比较和交换，把小的数交换到最前面。
*/
extension Array where
Element:Comparable {
mutating func bubbleSort() {
for i in 0..<self.count-1 {
for j in (i+1...self.count-1).reversed()
{
// 后者小于前者，交换位置，即小的往上升大的往下沉
if self[j] < self[j-1] {
swap(i: j, j: j-1)
}
}
}
}
}
因为是排序，所以元素必须满足协议是可比较的。
下面快速排序和选择排序也是同样的道理。
2.快速排序
/** 快速排序的算法思想
* 一趟快速排序的算法是：
* 1、设置两个变量i、j，排序开始的时候：i=0，j=N-1；
* 2、以第一个数组元素作为基准数据，赋值给key，即key=A[0]；
* 3、从j开始向前搜索，即由后开始向前搜索(j减1)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
* 4、从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
* 5、重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，
* 使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。
* 另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
*/
extension Array where Element:Comparable {
private mutating func quickPartition(left:Int, right:Int)->Int {
var right = right
var left = left
// 记录哪个是基准数
let base = self[left]
// 记录基准数位置
let baseIndex = left
// 先从右边往左边扫描，找到第一个比base要小的数，但是不能与left相遇
while left < right
&& self[right] >= base {
right = right-1
}
// 再从左边往右边扫描，找到第一个比base还要大的数，但是不能与right相遇
while left < right
&& self[left] <= base {
left = left+1
}
// 交换 左边比base大的数和右边比base小的数
swap(i: left,j: right)
// 交换左边比base大的数和基准数
swap(i: baseIndex,j: left)
// 返回新的基准数
return left
}
/// 快速排序
/// - Parameters:
/// - a: 数组a
/// - left: 左边索引
/// - right: 右边索引
private mutating func quickSort(left: Int, right: Int) {
// 排序完毕，退出递归
if left >= right {
return
}
// 每一趟划分，使左边的比基准小，右边的比基准大，并返回新的基准的位置
let baseIndex = quickPartition(left: left, right: right)
// 判断左边是否排完，没排完递归排左边部分
if baseIndex - 1 > left {
quickSort(left: left, right:
baseIndex - 1)
}
// 判断右边是否排完，没排完递归排右边部分
if baseIndex + 1 < right {
quickSort(left: baseIndex + 1, right:
right)
}
}
mutating func quickSort() {
quickSort(left: 0, right: self.count-1)
}
}
3.选择排序
// MARK: - 选择排序
/** 选择排序算法思想
* 每一趟从前往后查找出值最小的索引（下标），最后通过比较是否需要交换。每一趟都将最小的元素交换到最前面。
* 大致过程
* 6, 4, 9, 7, 5（开始）
* 4, 6, 9, 7, 5（第一趟：将最小的4与6交换，使这一趟最小值4放到最前面）
* 4, 5, 9, 7, 6（第二趟：将最小的5与6交换，使这一趟最小值5放到最前面）
* 4, 5, 6, 7, 9（第三趟：将最小的6与9交换，使这一趟最小值6放到最前面）
* 4, 5, 6, 7, 9（第四趟：不需要交换，排序完成）
*/
extension Array where Element:Comparable {
mutating func selectorSort() {
var min = 0
// 只需要n-1趟即可，到最后一趟只有一个元素，一定是最小的了
for i in 0..<self.count-1 {
// 每一趟的开始，假设该趟的第一个元素是最小的
min = i
// 查找该趟有没有更小的，如果找到更小的，则更新最小值的下标
for j in i+1..<self.count-1 {
if self[j] < self[min] {
min = j
}
}
// 如果该趟的第一个元素不是最小的，说明需要交换
if min != i {
swap(i: min, j: i)
}
}
}
}
Swift的排序算法就总结到这里。
如果大家觉得这篇博文整理得不错，就给点个赞吧。 如果在再哪里整理得有疏忽的地方，还希望各位博友的指点。
感谢各位博友对这篇文章的支持哦！！！ 谢谢。