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

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

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

Swift的排序算法总结的更多相关文章

  1. [Swift]八大排序算法(七):归并排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  2. [Swift]八大排序算法(六):希尔排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  3. [Swift]八大排序算法(四):堆排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  4. [Swift]八大排序算法(三):选择排序 和 简单选择排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  5. [Swift]八大排序算法(二):快速排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  6. [Swift]八大排序算法(一):冒泡排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  7. [Swift]八大排序算法(五):插入排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  8. [Swift]八大排序算法(八):基数排序

    排序分为内部排序和外部排序. 内部排序:是指待排序列完全存放在内存中所进行的排序过程,适合不太大的元素序列. 外部排序:指的是大文件的排序,即待排序的记录存储在外存储器上,待排序的文件无法一次装入内存 ...

  9. JavaScript实现常用的排序算法

    ▓▓▓▓▓▓ 大致介绍 由于最近要考试复习,所以学习js的时间少了 -_-||,考试完还会继续的努力学习,这次用原生的JavaScript实现以前学习的常用的排序算法,有冒泡排序.快速排序.直接插入排 ...

随机推荐

  1. 第一波实习的前端笔记(2)——js.md

    1.如何解决移动端点透问题? $('xx').on('touchend', function(event){ event.preventDefault(); }) 但是,存在滑动页面会触发问题.期待更 ...

  2. Extract QQ from iPhone and analyze it

    QQ is one of the most popular chat App in the world. Now let me show you how to extract QQ from iPho ...

  3. spring2.0包说明【转】

    Spring压缩包目录说明 关键字: sring jar 1. Spring压缩包目录说明 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件. Aspectj是jav ...

  4. guava cache

    适用场景 缓存在很多场景下都是相当有用的.例如,计算或检索一个值的代价很高,并且对同样的输入需要不止一次获取值的时候,就应当考虑使用缓存. Guava Cache与ConcurrentMap很相似,但 ...

  5. xcode5-ios7-如何添加120x120、152x152、76x76图标

    以120x120为例: 添加Icon_120x120.png-->.plist添加Icon files-->App Icons自动变化 1. 2. 3. ================= ...

  6. Python Django之路由系统

    1.初识路由系统 路由系统是用户发请求到URL,然后URL根据路由系统重新指向到函数名的一个对应关系 2.创建project和app django-admin startproject mysite ...

  7. redis info参数详解

    redis 127.0.0.1:6381> info redis_version:2.4.16                                  # Redis 的版本redis ...

  8. OpenSSL命令系列

    1.1 ssl命令系列前言 openssl命令的格式是"openssl command command-options args",command部分有很多种命令,这些命令需要依赖 ...

  9. 实现MFC菜单画笔画圆,并且打钩

    这个是用最简单的方法,移动客户区,圆会不见,所以下一篇我还要改进. 首先新建一个MFC单文件,在资源那里的菜单下,建立画笔,可以弹出红画笔,蓝画笔和绿画笔,,给出ID_RED,ID_BLUE,ID_G ...

  10. DIOCP之EchoServer分析

    constructor TfrmMain.Create(AOwner: TComponent);begin inherited Create(AOwner); sfLogger.setAppender ...