1.选择排序

工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素
通过自定义的最小值元素的下标，在内层循环中通过下标进行比较，查找过程中不移动数位置, 如果发现比自定义最小值元素下标还要小的值，则将该值的下标赋值给自定义的最小值元素下标。在一次内层循环结束后，将最小值元素交换至数组左端。

  1. ///选择排序
  2. func sortBySelection<T: Comparable>(_ a: [T]) -> [T] {
  3.     let maxLenth = a.count
  4.     var temp:[T] = a
  5.     for i in 0..<maxLenth {
  6.         var tempI = temp[i]
  7.         var minIndex = i
  8.         for j in i+1..<maxLenth {
  9.             let tempJ = temp[j]
  10.             if(tempI > tempJ){
  11.                 ///挑出最小值 --- 交换
  12.                 minIndex = j
  13.                 tempI = tempJ
  14.             }
  15.         }
  16.         temp.swapAt(i, minIndex)
  17.     }
  18.     return temp
  19. }

2.冒泡排序

算法描述

  • 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 重复步骤1~3，直到排序完成。

从第一个数开始，依次往后进行相邻两个数之间的比较，如果前面的数比后面的数大就交换这两个数的位置，如果前面的数较小或两者一样大，就不作处理。

  1. //冒泡排序
  2. func sortByBubbling<T: Comparable>(_ a: [T]) -> [T] {
  3.     let maxLenth = a.count
  4.     var temp:[T] = a
  5.     for i in 1..<maxLenth {
  6.         for j in (0...i).reversed() {
  7.             if((j >= 1) && (temp[j] < temp[j-1])){
  8.                 ///左右元素交换
  9.                 temp.swapAt(j, j-1)
  10.             }else{
  11.                 break
  12.             }
  13.         }
  14.     }
  15.     return temp
  16. }