Swift的排序算法总结

下面让我们一起来见识一下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的排序算法就总结到这里。

如果大家觉得这篇博文整理得不错，就给点个赞吧。 如果在再哪里整理得有疏忽的地方，还希望各位博友的指点。

感谢各位博友对这篇文章的支持哦！！！ 谢谢。