算法

冒泡排序、选择排序

• swift 写法

import Foundation
/**
 *  冒泡排序：
 *      它重复地走访过要排序的元素列，一次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。
 *
 *  选择排序（Selection sort）:
        1）它是一种简单直观的排序算法。
        2）它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
        3）选择排序是不稳定的排序方法。
 *
 *
 */

/// 排序法：冒泡排序、选择排序
struct AortMethod {
    
    
    /// 冒泡排序
    ///
    /// - Parameter array: 数组
    /// - Returns: [Int]
    func bubbleSort(array:[Int]) -> [Int] {
        print("冒泡排序原始数据：\(array)")
        
        if array.count == 0 {
            return [Int]()
        }
        
        var arr = array
        var times = 0
        for i in 0 ..< arr.count - 1 {
            
            for j in 0 ..< arr.count - (i + 1) {
                times += 1
                if arr[j] > arr[j + 1] {    //交换位置
                    
                    //arr.swapAt(i, j + 1)    //系统的方法：交换位置
                    
                    let temp  = arr[j]
                    arr[j] = arr[j + 1]
                    arr[j + 1] = temp
                }
            }
        }
        
        print("冒泡排序后数据：\(arr) , 循环次数：\(times)")

        return arr
    }
    
    /// 选择排序
    ///
    /// - Parameter array: 数组
    /// - Returns: [Int]
    func selectionSort(array:[Int]) -> [Int] {
        print("选择排序原始数据：\(array)")
        
        if array.count == 0 {
            return [Int]()
        }
        
        var times = 0
        var arr = array
        for i in 0 ..< arr.count - 1 {
           
            for j in i + 1 ..< arr.count {
                times += 1
               
                if arr[i] > arr[j] {
                    let temp  = arr[i]
                    arr[i] = arr[j]
                    arr[j] = temp
                }
            }
        }
        print("选择排序后数据：\(arr) , 循环次数：\(times)")

        return arr
    }
        
    func swapDemo(a:inout Int, b: inout Int) {
        let temp  = a
        a = b
        b = temp
    }
}

• OC 写法

    //冒泡
    NSMutableArray *array = [NSMutableArray arrayWithArray:@[@"98",@"75",@"89",@"53",@"67",@"92"]];
    for (int i = 0 ; i < array.count-1; i ++) {
        for (int j = 0 ; j < array.count - 1 - i ; j ++) {
            if ([array[j] intValue] > [array[j+1] intValue]) {
                // 开始交换数据
                NSString *temp = array[j];

                array[j] = array[j+1];

                array[j+1] = temp;

            }
        }

    }
    
    //选择
    for (int i = 0; i < array.count - 1;  i ++) {
       
        for (int j = i+1; j < array.count; j++) {
            
            // if里面的 '>' '<' 条件决定了排序的 升降
            if ([array[i] intValue] > [array[j] intValue]) {
                NSString *temp = array[j];
                array[j] = array[i];
                array[i] = temp;
            }
        }
    }
    
    NSLog(@"%@",array);

斐波那契算法【后一项等于前两项之和】

import Foundation

/**
 a0 = 0
 a1 = 1
 a2 = a1 + a0
 a3 = a2 + a1
 a4 = a3 + a2
 a5 = a4 + a3
 ...
 
 */
/// MARK: - 斐波那契算法【后一项等于前两项之和】
struct Algorithm {
    
    //后一项等于前两项之和[递归法]
    func add(_ n: Int) -> Int {
        guard n != 0,n != 1 else {
            return n
        }
        
        return add(n - 1) + add(n - 2)
    }
    
    //后一项等于前两项之和[数组法]
    func add_02(_ n: Int) -> Int {
        if n == 0 {
            return 0
        }
        
        if n == 1 {
            return 1
        }
        
        var array = [Int](repeating: 0, count: n + 1 )
        array[0] = 0
        array[1] = 1
        
        for i in 2...n {
            print("i = \(i)")
            array[i] = array[i - 1] + array[i - 2]
        }
        return array[n]
        
    }
    
    //后一项等于前两项之和[中间变量交换法]
    func add_03(_ n: Int) -> Int {
        var a0 = 0
        var a1 = 1
        var an = 0
        
        var temp = 0
        for _ in 2...n {
            temp =  a1 + a0
            
            a0 = a1     //顺序不能换
            a1 = temp
            
        }
        an = temp
        return an
    }
}