简单算法

数组反序

//遍历交换
let count = list.count / 2
for idx in 0..<count {
    list.swapAt(idx, list.count - 1 - idx)
}

//遍历增加删除
for index in 0..<list.count - 1 {
    list.insert(list[0], at: list.count - index)       
    list.remove(at: 0)
}

//新数组
var newList = [Int]()
for idx in 0..<list.count {
    newList.insert(list[idx], at: 0)
}

数组去重

//通过字典去重
var originArray = [1, 2, 3, 3, 4, 1, 5]
var transDict = [Int: Int]()
_ = originArray.map { transDict[$0] = $0 }
let _ = transDict.keys    

//通过集合转换去重
var transSet = Set(originArray)
let _ = Array(transSet)

//数组自身遍历去重
for i in 0..<originArray.count {
    var j = originArray.count - 1
    while j > i {
        if originArray[j] == originArray[i] {
            originArray.remove(at: j)
        }
        j -= 1
    }
}

冒泡

//重复的访问要排序的元素，依次比较相邻两个元素，
//如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，排序完成

var originArray = [2,7,5,1,4,6,9,0,8,3]
let count = originArray.count // 10
for i in 0..<count - 1 {
    for j in 0..<(count - 1 - i) {  //将筛选出的数据放置在末尾
        if originArray[j] > originArray[j + 1] { //控制升序还是降序
            let temp = originArray[j + 1]
            originArray[j + 1] = originArray[j]
            originArray[j] = temp
        }
    }
}

选择排序

//每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置

var originArray = [2,7,5,1,4,6,9,0,8,3]
let count = originArray.count
var min:Int!
for i in 0..<count - 1 {
    min = i
    for j in (i + 1)..<count {
        if originArray[min] > originArray[j] {//选择min还是max
            min = j
        }
    }
    if min != i {
        let temp = originArray[min]
        originArray[min] = originArray[i]
        originArray[i] = temp
    }
}

插入排序

//每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。

var originArray = [2,7,5,1,4,6,9,0,8,3]
let count = originArray.count

//不太贴合插入的思路
for i in 1..<count {
    var j = i
    while j > 0 && (originArray[j] < originArray[j - 1]) {
    //控制升序还是降序，依次与前一位比较，根据结果是否移动
        originArray.swapAt(j + 1, j)
        j -= 1
    }
}

//更新方法
for i in 1..<count {
    if originArray[i] < originArray[i - 1] {
        let temp = originArray[i]
        var j = i - 1
        while j >= 0 && originArray[j] > temp {
            originArray[j + 1] = originArray[j]
            j -= 1
        }
        originArray[j + 1] = temp
    }
}

希尔排序

//将相距某个“增量”的元素组成子序列，对子序列进行插入排序，实现跳跃式移动，提高排序效率。
//一般使用 increment = increment / 3 + 1 
//或者     increment = increment / 2    选取增量

var increment = count
repeat {
    increment = increment / 2
    for i in increment..<count {    
        if originArray[i] < originArray[i - increment] {
            let temp = originArray[i]
            var j = i - increment
            while j >= 0 && temp < originArray[j] {
                originArray[j + increment] = originArray[j]
                j -= increment
            }
            originArray[j + increment] = temp 
        }
    }
} while increment > 1

快速排序

//通过一辞排序将待排序列分割成独立的两部分，
//其中一部分记录的元素均比另一部分记录的元素值小，则可分别对这两部分继续进行排序，
//以达到整个序列有序的目的 

func quickSort(list: inout [Int], low: Int, high: Int) {
    if low < high {
        let pivot = partition(list: &list, low: low, high: high)
        quickSort(list: &list, low: low, high: pivot - 1)
        quickSort(list: &list, low: pivot + 1, high: high)
    }
}

//分隔方法，快排核心
func partition(list: inout [Int], low: Int, high: Int) -> Int {
    let key = list[low]
    var inHigh = high
    var inLow = low
    
    while inLow < inHigh {
        while (inLow < inHigh) && (list[inHigh] >= key){
            inHigh -= 1
        }
        list.swapAt(inLow, inHigh)
        while (inLow < inHigh) && (list[inLow] <= key) {
            inLow += 1
        }
        list.swapAt(inLow, inHigh)
    }
    return inLow
}