ios - 算法

• 一：斐波那契数列

oc写法：

- (NSArray *)fibonacci:(int)n

{
    if (n<2) {
        return @[];
    }
    
    NSMutableArray *muArr = @[@(0),@(1)].mutableCopy;
    
    for (int i = 2; i < n; i++) {
        
        int fib1 = [muArr[i - 2] intValue];
        int fib2 = [muArr[i - 1] intValue];
        
        if (fib1 + fib2 > UINT8_MAX) {
            break;
        }
        [muArr addObject:@(fib1 + fib2)];
    }
    return muArr;
}

swift写法：

func fibonacci(_ n: Int) -> NSArray {
        var arr:[Int] = [0,1]
        for i in 2..<n {
            let fib1 = arr[i - 2]
            let fib2 = arr[i - 1]
            if fib1 + fib2 > UINT8_MAX {
                break
            }
            arr.append(fib1 + fib2)
        }
        return arr as NSArray
    }

• 二：快速排序

oc写法：

NSMutableArray *muarr = @[@1,@2,@9,@10,@3].mutableCopy;

- (void)quickSortArr:(NSMutableArray *)muArr leftIndex:(NSInteger)left rightIndex:(NSInteger)right{
    
    if (left > right) {
        return;
    }
    
    NSInteger i = left;
    NSInteger j = right;
    NSInteger key = [muArr[left] intValue];
    
    while (i < j) {
        
        while (i < j && [muArr[j] intValue] >= key) {
            j--;
        }
        muArr[i] = muArr[j];
        
        while (i < j && [muArr[i] intValue] <= key) {
            i++;
        }
        muArr[j] = muArr[i];
        
    }
    
    muArr[i] = @(key);
    [self quickSortArr:muArr leftIndex:left rightIndex: i - 1];
    [self quickSortArr:muArr leftIndex: i + 1 rightIndex:right];
}

swift写法：

private func quickSort(arr: inout Array<Int>, leftIndex: NSInteger, rightIndex: NSInteger){
        if leftIndex > rightIndex{
            return
        }
        
        var i = leftIndex
        var j = rightIndex
        let key = arr[leftIndex]
        
        while i < j {
            while (i < j && arr[j] >= key) {
                j -= 1
            }
            arr[i] = arr[j]
            while (i < j && arr[i] <= key) {
                i += 1
            }
            arr[j] = arr[i]
        }
        arr[i] = key
    self.quickSort(arr: &arr, leftIndex: leftIndex, rightIndex: i - 1)
    self.quickSort(arr: &arr, leftIndex: i + 1, rightIndex: rightIndex)
    }

• 三：字符串反转

oc写法

char ch[] = "hello word";
    [self charReverse:ch];
    printf("%s",ch);


- (void)charReverse:(char*) cha{
    
    //指向第一个字符
    char* begin = cha;
    //指向最后一个字符
    char* end = cha + strlen(cha) - 1;
    while (begin < end){
        //交换，移动指针
        char temp = *begin;
        *(begin++) = *end;
        *(end--) = temp;
    }
}

swift 写法

let str = self.charReverse("hello word")
        print(str)


func charReverse(_ str: String) -> String {
        var chars = str.cString(using: String.Encoding.utf8)!
        var begin = 0
        var end = str.count - 1
        
        while begin < end {
            let char = chars[begin]
            chars[begin] = chars[end]
            chars[end] = char
            begin += 1
            end -= 1
        }
        return String.init(utf8String: chars)!
    }