2. 程式人生 > >Objective-C實現常用的4種排序演算法

Objective-C實現常用的4種排序演算法

阿新 • • 發佈：2019-02-19

OC實現的4種排序又來了！

4種排序分別是：快速排序、氣泡排序、選擇排序、插入排序，其他的我就不寫了，因為OC裡的陣列中不能存放基本資料型別，如int不能存放，只能放物件，所以所有的資料我用了NSNumber型別，一開始我直接用>、=、<來比較結果排序後還是亂七八糟，後來想起來不能這麼比較，物件的比較，可以用compare方法，結果與NSComparisonResult這個列舉型別的資料比較大小就可以了。或者取NSNumber 的intValue，在用>、=、<進行比較，第一個方法中有些兩種方式的語句，後來的類似就不寫了。

1、快速排序

#pragma - mark 快速排序
+ (void)quickSort:(NSMutableArray *)array low:(int)low high:(int)high
{
    if(array == nil || array.count == 0){
        return;
    }
    if (low >= high) {
        return;
    }
    
    //取中值
    int middle = low + (high - low)/2;
    NSNumber *prmt = array[middle];
    int i = low;
    int j = high;
    
    //開始排序，使得left<prmt 同時right>prmt
    while (i <= j) {
//        while ([array[i] compare:prmt] == NSOrderedAscending) {  該行與下一行作用相同
        while ([array[i] intValue] < [prmt intValue]) {
            i++;
        }
//        while ([array[j] compare:prmt] == NSOrderedDescending) { 該行與下一行作用相同
        while ([array[j] intValue] > [prmt intValue]) {
            j--;
        }
        
        if(i <= j){
            [array exchangeObjectAtIndex:i withObjectAtIndex:j];
            i++;
            j--;
        }
        
        printf("排序中:");
        [self printArray:array];
    }
    
    if (low < j) {
        [self quickSort:array low:low high:j];
    }
    if (high > i) {
        [self quickSort:array low:i high:high];
    }
}
快速排序的過程如下： 
排序前:9 2 10 7 3 7 4 
排序中:4 2 10 7 3 7 9 
排序中:4 2 7 7 3 10 9 
排序中:4 2 7 3 7 10 9 
排序中:2 4 7 3 7 10 9 
排序中:2 4 3 7 7 10 9 
排序中:2 3 4 7 7 10 9 
排序中:2 3 4 7 7 9 10 
排序中:2 3 4 7 7 9 10 
排序後:2 3 4 7 7 9 10
2、氣泡排序 
#pragma - mark 氣泡排序
+ (void)buddleSort:(NSMutableArray *)array
{
    if(array == nil || array.count == 0){
        return;
    }
    
    for (int i = 1; i < array.count; i++) {
        for (int j = 0; j < array.count - i; j++) {
            if ([array[j] compare:array[j+1]] == NSOrderedDescending) {
                [array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
            }
            
            printf("排序中:");
            [self printArray:array];
        }
    }

}
氣泡排序的過程如下： 
排序前:9 2 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 9 7 10 3 7 4 
排序中:2 9 7 3 10 7 4 
排序中:2 9 7 3 7 10 4 
排序中:2 9 7 3 7 4 10 
排序中:2 9 7 3 7 4 10 
排序中:2 7 9 3 7 4 10 
排序中:2 7 3 9 7 4 10 
排序中:2 7 3 7 9 4 10 
排序中:2 7 3 7 4 9 10 
排序中:2 7 3 7 4 9 10 
排序中:2 3 7 7 4 9 10 
排序中:2 3 7 7 4 9 10 
排序中:2 3 7 4 7 9 10 
排序中:2 3 7 4 7 9 10 
排序中:2 3 7 4 7 9 10 
排序中:2 3 4 7 7 9 10 
排序中:2 3 4 7 7 9 10 
排序中:2 3 4 7 7 9 10 
排序中:2 3 4 7 7 9 10 
排序後:2 3 4 7 7 9 10
3、選擇排序 
+ (void)selectSort:(NSMutableArray *)array
{
    if(array == nil || array.count == 0){
        return;
    }
    
    int min_index;
    for (int i = 0; i < array.count; i++) {
        min_index = i;
        for (int j = i + 1; j<array.count; j++) {
            if ([array[j] compare:array[min_index]] == NSOrderedAscending) {
                [array exchangeObjectAtIndex:j withObjectAtIndex:min_index];
            }
            
            printf("排序中:");
            [self printArray:array];
        }
    }
}
選擇排序的過程如下： 
排序前:9 2 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 9 10 7 3 7 4 
排序中:2 7 10 9 3 7 4 
排序中:2 3 10 9 7 7 4 
排序中:2 3 10 9 7 7 4 
排序中:2 3 10 9 7 7 4 
排序中:2 3 9 10 7 7 4 
排序中:2 3 7 10 9 7 4 
排序中:2 3 7 10 9 7 4 
排序中:2 3 4 10 9 7 7 
排序中:2 3 4 9 10 7 7 
排序中:2 3 4 7 10 9 7 
排序中:2 3 4 7 10 9 7 
排序中:2 3 4 7 9 10 7 
排序中:2 3 4 7 7 10 9 
排序中:2 3 4 7 7 9 10 
排序後:2 3 4 7 7 9 10
4、插入排序 
#pragma - mark 插入排序
+ (void)inserSort:(NSMutableArray *)array
{
    if(array == nil || array.count == 0){
        return;
    }
    
    for (int i = 0; i < array.count; i++) {
        NSNumber *temp = array[i];
        int j = i-1;
        
        while (j >= 0 && [array[j] compare:temp] == NSOrderedDescending) {
            [array replaceObjectAtIndex:j+1 withObject:array[j]];
            j--;
            
            printf("排序中:");
            [self printArray:array];
        }
        
        [array replaceObjectAtIndex:j+1 withObject:temp];
    }
}
插入排序的過程如下： 
排序前:9 2 10 7 3 7 4 
排序中:9 9 10 7 3 7 4 
排序中:2 9 10 10 3 7 4 
排序中:2 9 9 10 3 7 4 
排序中:2 7 9 10 10 7 4 
排序中:2 7 9 9 10 7 4 
排序中:2 7 7 9 10 7 4 
排序中:2 3 7 9 10 10 4 
排序中:2 3 7 9 9 10 4 
排序中:2 3 7 7 9 10 10 
排序中:2 3 7 7 9 9 10 
排序中:2 3 7 7 7 9 10 
排序中:2 3 7 7 7 9 10 
排序後:2 3 4 7 7 9 10
另外，類的程式碼也附上吧！ 
//
//  SortUtil.h
//  SortUtil
//
//  Created by Mac on 14-4-17.
//  Copyright (c) 2014年 KnightKing. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface SortUtil : NSObject

//快速排序
+ (void)quickSort:(NSMutableArray *)array low:(int)low high:(int)high;

//氣泡排序
+ (void)buddleSort:(NSMutableArray *)array;

//選擇排序
+ (void)selectSort:(NSMutableArray *)array;

//插入排序
+ (void)inserSort:(NSMutableArray *)array;

//列印陣列
+ (void)printArray:(NSArray *)array;

@end


//
//  SortUtil.m
//  SortUtil
//
//  Created by Mac on 14-4-17.
//  Copyright (c) 2014年 KnightKing. All rights reserved.
//

#import "SortUtil.h"

@implementation SortUtil

#pragma - mark 快速排序
+ (void)quickSort:(NSMutableArray *)array low:(int)low high:(int)high
{
    if(array == nil || array.count == 0){
        return;
    }
    if (low >= high) {
        return;
    }
    
    //取中值
    int middle = low + (high - low)/2;
    NSNumber *prmt = array[middle];
    int i = low;
    int j = high;
    
    //開始排序，使得left<prmt 同時right>prmt
    while (i <= j) {
//        while ([array[i] compare:prmt] == NSOrderedAscending) {  該行與下一行作用相同
        while ([array[i] intValue] < [prmt intValue]) {
            i++;
        }
//        while ([array[j] compare:prmt] == NSOrderedDescending) { 該行與下一行作用相同
        while ([array[j] intValue] > [prmt intValue]) {
            j--;
        }
        
        if(i <= j){
            [array exchangeObjectAtIndex:i withObjectAtIndex:j];
            i++;
            j--;
        }
        
        printf("排序中:");
        [self printArray:array];
    }
    
    if (low < j) {
        [self quickSort:array low:low high:j];
    }
    if (high > i) {
        [self quickSort:array low:i high:high];
    }
}

#pragma - mark 氣泡排序
+ (void)buddleSort:(NSMutableArray *)array
{
    if(array == nil || array.count == 0){
        return;
    }
    
    for (int i = 1; i < array.count; i++) {
        for (int j = 0; j < array.count - i; j++) {
            if ([array[j] compare:array[j+1]] == NSOrderedDescending) {
                [array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
            }
            
            printf("排序中:");
            [self printArray:array];
        }
    }

}

#pragma - mark 選擇排序
+ (void)selectSort:(NSMutableArray *)array
{
    if(array == nil || array.count == 0){
        return;
    }
    
    int min_index;
    for (int i = 0; i < array.count; i++) {
        min_index = i;
        for (int j = i + 1; j<array.count; j++) {
            if ([array[j] compare:array[min_index]] == NSOrderedAscending) {
                [array exchangeObjectAtIndex:j withObjectAtIndex:min_index];
            }
            
            printf("排序中:");
            [self printArray:array];
        }
    }
}

#pragma - mark 插入排序
+ (void)inserSort:(NSMutableArray *)array
{
    if(array == nil || array.count == 0){
        return;
    }
    
    for (int i = 0; i < array.count; i++) {
        NSNumber *temp = array[i];
        int j = i-1;
        
        while (j >= 0 && [array[j] compare:temp] == NSOrderedDescending) {
            [array replaceObjectAtIndex:j+1 withObject:array[j]];
            j--;
            
            printf("排序中:");
            [self printArray:array];
        }
        
        [array replaceObjectAtIndex:j+1 withObject:temp];
    }
}

+ (void)printArray:(NSArray *)array
{
    for(NSNumber *number in array) {
        printf("%d ",[number intValue]);
    }
    
    printf("\n");
}

@end

呼叫我就寫在了app啟動的方法裡： 
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
    // Override point for customization after application launch.
    self.window.backgroundColor = [UIColor whiteColor];
    [self.window makeKeyAndVisible];
    
    NSMutableArray *array = [NSMutableArray arrayWithObjects:@9,@2,@10,@7,@3,@7,@4,nil];
    
    printf("排序前:");
    [SortUtil printArray:array];
    //快速排序
//    [SortUtil quickSort:array low:0 high:6];
    //氣泡排序
//    [SortUtil buddleSort:array];
    //選擇排序
//    [SortUtil selectSort:array];
    //插入排序
    [SortUtil inserSort:array];
    
    printf("排序後:");
    [SortUtil printArray:array];
    
    return YES;
}


相關推薦

Objective-C實現常用的4種排序演算法

OC實現的4種排序又來了！ 4種排序分別是：快速排序、氣泡排序、選擇排序、插入排序，其他的我就不寫了，因為OC裡的陣列中不能存放基本資料型別，如int不能存放，只能放物件，所以所有的資料我用了NSNumber型別，一開始我直接用>、=、<來比較結果排序後還是亂七

C#常用8種排序演算法實現以及原理簡介

public static class SortExtention    {        #region 氣泡排序        /*         * 已知一組無序資料a[1]、a[2]、……a[n]，需將其按升序排列。首先比較a[1]與a[2]的值，若a[1]大於a[

[answerer的演算法課堂]簡單描述4種排序演算法（C語言實現）

[answerer的演算法課堂]簡單描述4種排序演算法（C語言實現） 這是我第一次寫文章，想要記錄自己的學習生活，寫得不好請包涵or指導，本來想一口氣寫好多種，後來發現，寫太多的話反而可讀性不強，而且，我文筆，知識有限吶。慢慢來吧 目錄 名稱氣泡排序直接選擇排序直接插入排序希爾排序 時間複雜度 O(

用objective-c 實現常用演算法（冒泡、選擇、快速、插入）

原文網址：http://www.360doc.com/content/14/0508/15/11029609_375813213.shtml 研究了下用oc實現常用的演算法，參考了一些資料後自己用程式碼檢驗了下，以下程式碼均測試可用。其中arr引數是一個可變陣列，其中存

python實現的八種排序演算法

1.快速排序 排序思想： 1.從數列中挑出一個元素，稱為"基準"（pivot） 2.重新排序數列，所有比基準值小的元素放在基準前面，比基準大的元素放在基準後面。在這個分割槽結束之後，該基準就處於數列的中間位置，這就是分割槽操作。 3.遞迴地把小於基準的子數列和大於基準的子數列排序

常見的4種排序演算法

1、氣泡排序 最簡單的一種排序演算法。先從陣列中找到最大值(或最小值)並放到陣列最左端(或最右端)，然後在剩下的數字中找到次大值(或次小值)，以此類推，直到陣列有序排列。演算法的時間複雜度為O(n^2)。 // 氣泡排序 void BubbleSort(int arr[], int length)

Java常用八種排序演算法

直接插入排序/** * 1.直接插入排序（穩定） * 原理：將陣列分為無序區和有序區兩個區，然後不斷將無序區的第一個元素按大小順序插入到有序區中去，最終將所有無序區元素都移動到有序區完成排序。 * 要點：設立哨兵，作為臨時儲存和判斷陣列邊界之用。 * */ publ

android中常用5種排序演算法

在android中會經常使用一些演算法來實現一些複雜的邏輯; 在這片博文中主要介紹五種演算法: 1.選擇排序; 2.插入排序; 3.快速排序; 4.合併排序; 5.堆排序; 在看下面之前,需要注意:有的

常用幾種排序演算法的時間複雜度和空間複雜度

 常用的排序演算法的時間複雜度和空間複雜度 排序法  最差時間分析 平均時間複雜度  穩定度  空間複雜度  氣泡排序 O(n2) O(n2)  穩定  O(

Java常用的八種排序演算法與程式碼實現（三）：桶排序、計數排序、基數排序

三種線性排序演算法：桶排序、計數排序、基數排序 線性排序演算法（Linear Sort）：這些排序演算法的時間複雜度是線性的O(n)，是非比較的排序演算法 桶排序（Bucket Sort） 　　將要排序的資料分到幾個有序的桶裡，每個桶裡的資料再單獨進行排序，桶內排完序之後，再把桶裡的

Java常用的八種排序演算法與程式碼實現（二）：歸併排序法、快速排序法

注：這裡給出的程式碼方案都是通過遞迴完成的 －－－ 歸併排序（Merge Sort）： 　　分而治之，遞迴實現 　　如果需要排序一個數組，我們先把陣列從中間分成前後兩部分，然後對前後兩部分進行分別排序，再將排好序的數組合並在一起，這樣整個陣列就有序了 　　歸併排序是穩定的排序演算法，時間

C語言實現六種排序演算法

C語言實現六種排序演算法 C語言實現六種排序演算法 氣泡排序 插入排序 歸併排序 快速排序 希爾排序

[原始碼和文件分享]基於C++的9種排序演算法的實現與比較

一、使用說明 1.1 專案簡介 隨機函式產生10000個隨機數，用快速排序，直接插入排序，氣泡排序，直接選擇排序的排序方法排序，並統計每種排序所花費的排序時間和交換次數。其中，隨機數的個數由使用者定義，系統產生隨機數，並且顯示他們的比較次數，排序演算法包括氣泡排序，直接選擇排序，直接插入排序

【資料結構】十一種排序演算法C++實現

   練習了十一種排序演算法的C++實現：以下依次為，冒泡、選擇、希爾、插入、二路歸併、快排、堆排序、計數排序、基數排序、桶排序，可建立sort.h和main.cpp將程式碼放入即可執行。如有錯誤，請指出更正，謝謝交流。 // sort.h # include <

Java常用的八種排序演算法與程式碼實現（一）：氣泡排序法、插入排序法、選擇排序法

這三種排序演算法適合小規模資料排序 －－－ 　　共同點：基於比較，時間複雜度均為O(n2)，空間複雜度均為O(1)（原地排序演算法） 　　不同點：插入排序和氣泡排序是穩定的排序演算法，選擇排序不是 －－－ 　　穩定排序演算法：可以保持數值相等的兩個物件，在排序之

Java常用的八種排序演算法與程式碼實現(一)

本文需要5分鐘左右閱讀完成，建議收藏以後閱讀，裡面都是乾貨，可以親自試驗一下，如果覺得好用可以幫忙點贊轉發一下，謝謝！交流學習java大資料可以加群460570824。 1.直接插入排序 經常碰到這樣一類排序問題：把新的資料插入到已經排好的資料列中。 將第一個數和第二個數

用C++實現七種排序演算法，可選擇排序方法，簡單易懂。

       最近學習演算法，先從簡答的開始學起，用C++做了一個實現七種排序演算法的介面，可選擇想要用的選擇演算法，不過，由於時間倉促，沒有來得及優化和程式碼註釋，後期還會加上程式碼註釋，隨便優化一下程式碼，提高執行效率； /***********************

C/C++的八種排序演算法及實現

  最近看排序演算法的書籍，記錄下自己的心得和總結。關於幾種常見排序的原理和實現。（快速排序借了別人的步驟描述，可以很清晰的理解每一趟怎麼跑的） 首先說下穩定排序和非穩定排序，簡單地說就是所有相等的數

一遍記住Java常用的八種排序演算法與程式碼實現

1.直接插入排序 經常碰到這樣一類排序問題：把新的資料插入到已經排好的資料列中。 將第一個數和第二個數排序，然後構成一個有序序列將第三個數插入進去，構成一個新的有序序列。對第四個數、第五個數……直到最後一個數，重複第二步。 如何寫寫成程式碼： 首先設定插入次數，即迴圈

常用的八種排序演算法與Java程式碼實現

1.直接插入排序 經常碰到這樣一類排序問題：把新的資料插入到已經排好的資料列中。 將第一個數和第二個數排序，然後構成一個有序序列 將第三個數插入進去，構成一個新的有序序列。 對第四個數、第五個數……直到最後一個數，重複第二步。