冒泡排序的實現(xiàn)

/**
 冒泡排序?qū)崿F(xiàn)

 @param dataArray 需要排序的數(shù)組
 @return 排序完成的數(shù)組
 */
- (NSArray *)buddleSort:(NSArray <NSNumber *> *)dataArray{
    
    NSMutableArray <NSNumber *> * resultArray = [NSMutableArray arrayWithArray:dataArray];
    
    for (int i = 0; i < [dataArray count] - 1; i ++) {

        for (int j = 0; j < [dataArray count] - 1 - i; j ++) {
            
            if (resultArray[j].integerValue > resultArray[j + 1].integerValue) {
                
                [resultArray exchangeObjectAtIndex:j withObjectAtIndex:j + 1];
                
            }
        }
    }
    
    return resultArray;
}

快速排序的實現(xiàn)

/**
 快速排序

 @param dataArray 需要排序的數(shù)組
 @param leftIndex 左邊的index
 @param rightIndex 右邊的index
 */
- (void)quickSort:(NSMutableArray *)dataArray leftIndex:(NSInteger)leftIndex rightIndex:(NSInteger)rightIndex{
    
    if (leftIndex >= rightIndex) {
        return;
    }
    
    NSInteger i = leftIndex;
    NSInteger j = rightIndex;
    NSInteger key = [dataArray[i] integerValue];
    
    while (i != j) {
        
        //先從右邊找
        while (i < j && [dataArray[j] integerValue] >= key) {
            j --;
        }
        
        //再從左邊找
        while (i < j && [dataArray[i] integerValue] <= key) {
            i ++;
        }
        
        if (i < j) {
            [dataArray exchangeObjectAtIndex:i withObjectAtIndex:j];
        }
    }
    
    [dataArray exchangeObjectAtIndex:leftIndex withObjectAtIndex:j];
    //遞歸剩下的左邊和右邊
    [self quickSort:dataArray leftIndex:leftIndex rightIndex:i - 1];
    [self quickSort:dataArray leftIndex:i + 1 rightIndex:rightIndex];
    
}

兩個有序數(shù)組合并成一個有序數(shù)組的實現(xiàn)(插入排序)

/**
 兩個有序數(shù)組合并

 @param firstArray 第一個數(shù)組
 @param secondArray 第二個數(shù)組
 @return 合并的數(shù)組
 */
- (NSArray *)insertSort:(NSArray *)firstArray secondArray:(NSArray *)secondArray{
    
    NSMutableArray * resuleArray = [NSMutableArray arrayWithCapacity:[firstArray count] + [secondArray count]];
    
    NSInteger i = 0;
    NSInteger j = 0;
    
    while (i < [firstArray count] && j < [secondArray count] ) {
        
        if (firstArray[i] <= secondArray[j]) {
            resuleArray[i + j] = firstArray[i ++];
        }else{
            resuleArray[i + j] = secondArray[j ++];
        }
    }
    
    //保證數(shù)組剩余的部分加入合并后的數(shù)組中
    while (i < [firstArray count]) {
        resuleArray[i + j] = firstArray[i ++];
    }
    
    while (j < [secondArray count]) {
        resuleArray[i + j] = secondArray[j ++];
    }
    
    
    return resuleArray;
}

持續(xù)更新中... 有不對的地方歡迎指正 ??