冒泡排序纸肉、選擇排序

• swift 寫法

import Foundation
/**
 *  冒泡排序：
 *      它重復(fù)地走訪過要排序的元素列践付，一次比較兩個(gè)相鄰的元素，如果他們的順序（如從大到小、首字母從A到Z）錯(cuò)誤就把他們交換過來号胚。走訪元素的工作是重復(fù)地進(jìn)行直到?jīng)]有相鄰元素需要交換愉适，也就是說該元素已經(jīng)排序完成。
 *
 *  選擇排序（Selection sort）:
        1）它是一種簡單直觀的排序算法栗竖。
        2）它的工作原理是每一次從待排序的數(shù)據(jù)元素中選出最惺畲唷（或最大）的一個(gè)元素，存放在序列的起始位置狐肢，直到全部待排序的數(shù)據(jù)元素排完添吗。
        3）選擇排序是不穩(wěn)定的排序方法。
 *
 *
 */

/// 排序法：冒泡排序份名、選擇排序
struct AortMethod {
    
    
    /// 冒泡排序
    ///
    /// - Parameter array: 數(shù)組
    /// - Returns: [Int]
    func bubbleSort(array:[Int]) -> [Int] {
        print("冒泡排序原始數(shù)據(jù)：\(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)    //系統(tǒng)的方法：交換位置
                    
                    let temp  = arr[j]
                    arr[j] = arr[j + 1]
                    arr[j + 1] = temp
                }
            }
        }
        
        print("冒泡排序后數(shù)據(jù)：\(arr) , 循環(huán)次數(shù)：\(times)")

        return arr
    }
    
    /// 選擇排序
    ///
    /// - Parameter array: 數(shù)組
    /// - Returns: [Int]
    func selectionSort(array:[Int]) -> [Int] {
        print("選擇排序原始數(shù)據(jù)：\(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("選擇排序后數(shù)據(jù)：\(arr) , 循環(huán)次數(shù)：\(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]) {
                // 開始交換數(shù)據(jù)
                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);

斐波那契算法【后一項(xiàng)等于前兩項(xiàng)之和】

import Foundation

/**
 a0 = 0
 a1 = 1
 a2 = a1 + a0
 a3 = a2 + a1
 a4 = a3 + a2
 a5 = a4 + a3
 ...
 
 */
/// MARK: - 斐波那契算法【后一項(xiàng)等于前兩項(xiàng)之和】
struct Algorithm {
    
    //后一項(xiàng)等于前兩項(xiàng)之和[遞歸法]
    func add(_ n: Int) -> Int {
        guard n != 0,n != 1 else {
            return n
        }
        
        return add(n - 1) + add(n - 2)
    }
    
    //后一項(xiàng)等于前兩項(xiàng)之和[數(shù)組法]
    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]
        
    }
    
    //后一項(xiàng)等于前兩項(xiàng)之和[中間變量交換法]
    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
    }
}