OC实现的4种排序又来了！

4种排序分别是：快速排序、冒泡排序、选择排序、插入排序，其他的我就不写了，因为OC里的数组中不能存放基本数据类型，如int不能存放，只能放对象，所以所有的数据我用了NSNumber类型，一开始我直接用>、=、<来比较结果排序后还是乱七八糟，后来想起来不能这么比较，对象的比较，可以用compare方法，结果与NSComparisonResult这个枚举类型的数据比较大小就可以了。或者取NSNumber 的intValue，在用>、=、<进行比较，第一个方法中有些两种方式的语句，后来的类似就不写了。

1、快速排序

  1. #pragma - mark 快速排序
  2. + (void)quickSort:(NSMutableArray *)array low:(int)low high:(int)high
  3. {
  4.     if(array == nil || array.count == 0){
  5.         return;
  6.     }
  7.     if (low >= high) {
  8.         return;
  9.     }
  10.  
  11.     //取中值
  12.     int middle = low + (high - low)/2;
  13.     NSNumber *prmt = array[middle];
  14.     int i = low;
  15.     int j = high;
  16.  
  17.     //开始排序，使得left<prmt 同时right>prmt
  18.     while (i <= j) {
  19. //        while ([array[i] compare:prmt] == NSOrderedAscending) {  该行与下一行作用相同
  20.         while ([array[i] intValue] < [prmt intValue]) {
  21.             i++;
  22.         }
  23. //        while ([array[j] compare:prmt] == NSOrderedDescending) { 该行与下一行作用相同
  24.         while ([array[j] intValue] > [prmt intValue]) {
  25.             j--;
  26.         }
  27.  
  28.         if(i <= j){
  29.             [array exchangeObjectAtIndex:i withObjectAtIndex:j];
  30.             i++;
  31.             j--;
  32.         }
  33.  
  34.         printf("排序中:");
  35.         [self printArray:array];
  36.     }
  37.  
  38.     if (low < j) {
  39.         [self quickSort:array low:low high:j];
  40.     }
  41.     if (high > i) {
  42.         [self quickSort:array low:i high:high];
  43.     }
  44. }

快速排序的过程如下：

  1. 排序前:9 2 10 7 3 7 4
  2. 排序中:4 2 10 7 3 7 9
  3. 排序中:4 2 7 7 3 10 9
  4. 排序中:4 2 7 3 7 10 9
  5. 排序中:2 4 7 3 7 10 9
  6. 排序中:2 4 3 7 7 10 9
  7. 排序中:2 3 4 7 7 10 9
  8. 排序中:2 3 4 7 7 9 10
  9. 排序中:2 3 4 7 7 9 10
  10. 排序后:2 3 4 7 7 9 10

2、冒泡排序

  1. #pragma - mark 冒泡排序
  2. + (void)buddleSort:(NSMutableArray *)array
  3. {
  4.     if(array == nil || array.count == 0){
  5.         return;
  6.     }
  7.  
  8.     for (int i = 1; i < array.count; i++) {
  9.         for (int j = 0; j < array.count - i; j++) {
  10.             if ([array[j] compare:array[j+1]] == NSOrderedDescending) {
  11.                 [array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
  12.             }
  13.  
  14.             printf("排序中:");
  15.             [self printArray:array];
  16.         }
  17.     }
  18.  
  19. }

冒泡排序的过程如下：

  1. 排序前:9 2 10 7 3 7 4
  2. 排序中:2 9 10 7 3 7 4
  3. 排序中:2 9 10 7 3 7 4
  4. 排序中:2 9 7 10 3 7 4
  5. 排序中:2 9 7 3 10 7 4
  6. 排序中:2 9 7 3 7 10 4
  7. 排序中:2 9 7 3 7 4 10
  8. 排序中:2 9 7 3 7 4 10
  9. 排序中:2 7 9 3 7 4 10
  10. 排序中:2 7 3 9 7 4 10
  11. 排序中:2 7 3 7 9 4 10
  12. 排序中:2 7 3 7 4 9 10
  13. 排序中:2 7 3 7 4 9 10
  14. 排序中:2 3 7 7 4 9 10
  15. 排序中:2 3 7 7 4 9 10
  16. 排序中:2 3 7 4 7 9 10
  17. 排序中:2 3 7 4 7 9 10
  18. 排序中:2 3 7 4 7 9 10
  19. 排序中:2 3 4 7 7 9 10
  20. 排序中:2 3 4 7 7 9 10
  21. 排序中:2 3 4 7 7 9 10
  22. 排序中:2 3 4 7 7 9 10
  23. 排序后:2 3 4 7 7 9 10

3、选择排序

  1. + (void)selectSort:(NSMutableArray *)array
  2. {
  3.     if(array == nil || array.count == 0){
  4.         return;
  5.     }
  6.  
  7.     int min_index;
  8.     for (int i = 0; i < array.count; i++) {
  9.         min_index = i;
  10.         for (int j = i + 1; j<array.count; j++) {
  11.             if ([array[j] compare:array[min_index]] == NSOrderedAscending) {
  12.                 [array exchangeObjectAtIndex:j withObjectAtIndex:min_index];
  13.             }
  14.  
  15.             printf("排序中:");
  16.             [self printArray:array];
  17.         }
  18.     }
  19. }

选择排序的过程如下：

  1. 排序前:9 2 10 7 3 7 4
  2. 排序中:2 9 10 7 3 7 4
  3. 排序中:2 9 10 7 3 7 4
  4. 排序中:2 9 10 7 3 7 4
  5. 排序中:2 9 10 7 3 7 4
  6. 排序中:2 9 10 7 3 7 4
  7. 排序中:2 9 10 7 3 7 4
  8. 排序中:2 9 10 7 3 7 4
  9. 排序中:2 7 10 9 3 7 4
  10. 排序中:2 3 10 9 7 7 4
  11. 排序中:2 3 10 9 7 7 4
  12. 排序中:2 3 10 9 7 7 4
  13. 排序中:2 3 9 10 7 7 4
  14. 排序中:2 3 7 10 9 7 4
  15. 排序中:2 3 7 10 9 7 4
  16. 排序中:2 3 4 10 9 7 7
  17. 排序中:2 3 4 9 10 7 7
  18. 排序中:2 3 4 7 10 9 7
  19. 排序中:2 3 4 7 10 9 7
  20. 排序中:2 3 4 7 9 10 7
  21. 排序中:2 3 4 7 7 10 9
  22. 排序中:2 3 4 7 7 9 10
  23. 排序后:2 3 4 7 7 9 10

4、插入排序

  1. #pragma - mark 插入排序
  2. + (void)inserSort:(NSMutableArray *)array
  3. {
  4.     if(array == nil || array.count == 0){
  5.         return;
  6.     }
  7.  
  8.     for (int i = 0; i < array.count; i++) {
  9.         NSNumber *temp = array[i];
  10.         int j = i-1;
  11.  
  12.         while (j >= 0 && [array[j] compare:temp] == NSOrderedDescending) {
  13.             [array replaceObjectAtIndex:j+1 withObject:array[j]];
  14.             j--;
  15.  
  16.             printf("排序中:");
  17.             [self printArray:array];
  18.         }
  19.  
  20.         [array replaceObjectAtIndex:j+1 withObject:temp];
  21.     }
  22. }

插入排序的过程如下：

  1. 排序前:9 2 10 7 3 7 4
  2. 排序中:9 9 10 7 3 7 4
  3. 排序中:2 9 10 10 3 7 4
  4. 排序中:2 9 9 10 3 7 4
  5. 排序中:2 7 9 10 10 7 4
  6. 排序中:2 7 9 9 10 7 4
  7. 排序中:2 7 7 9 10 7 4
  8. 排序中:2 3 7 9 10 10 4
  9. 排序中:2 3 7 9 9 10 4
  10. 排序中:2 3 7 7 9 10 10
  11. 排序中:2 3 7 7 9 9 10
  12. 排序中:2 3 7 7 7 9 10
  13. 排序中:2 3 7 7 7 9 10
  14. 排序后:2 3 4 7 7 9 10

另外，类的代码也附上吧！

  1. //
  2. //  SortUtil.h
  3. //  SortUtil
  4. //
  5. //  Created by Mac on 14-4-17.
  6. //  Copyright (c) 2014年 KnightKing. All rights reserved.
  7. //
  8.  
  9. #import <Foundation/Foundation.h>
  10.  
  11. @interface SortUtil : NSObject
  12.  
  13. //快速排序
  14. + (void)quickSort:(NSMutableArray *)array low:(int)low high:(int)high;
  15.  
  16. //冒泡排序
  17. + (void)buddleSort:(NSMutableArray *)array;
  18.  
  19. //选择排序
  20. + (void)selectSort:(NSMutableArray *)array;
  21.  
  22. //插入排序
  23. + (void)inserSort:(NSMutableArray *)array;
  24.  
  25. //打印数组
  26. + (void)printArray:(NSArray *)array;
  27.  
  28. @end
  1. //
  2. //  SortUtil.m
  3. //  SortUtil
  4. //
  5. //  Created by Mac on 14-4-17.
  6. //  Copyright (c) 2014年 KnightKing. All rights reserved.
  7. //
  8.  
  9. #import "SortUtil.h"
  10.  
  11. @implementation SortUtil
  12.  
  13. #pragma - mark 快速排序
  14. + (void)quickSort:(NSMutableArray *)array low:(int)low high:(int)high
  15. {
  16.     if(array == nil || array.count == 0){
  17.         return;
  18.     }
  19.     if (low >= high) {
  20.         return;
  21.     }
  22.  
  23.     //取中值
  24.     int middle = low + (high - low)/2;
  25.     NSNumber *prmt = array[middle];
  26.     int i = low;
  27.     int j = high;
  28.  
  29.     //开始排序，使得left<prmt 同时right>prmt
  30.     while (i <= j) {
  31. //        while ([array[i] compare:prmt] == NSOrderedAscending) {  该行与下一行作用相同
  32.         while ([array[i] intValue] < [prmt intValue]) {
  33.             i++;
  34.         }
  35. //        while ([array[j] compare:prmt] == NSOrderedDescending) { 该行与下一行作用相同
  36.         while ([array[j] intValue] > [prmt intValue]) {
  37.             j--;
  38.         }
  39.  
  40.         if(i <= j){
  41.             [array exchangeObjectAtIndex:i withObjectAtIndex:j];
  42.             i++;
  43.             j--;
  44.         }
  45.  
  46.         printf("排序中:");
  47.         [self printArray:array];
  48.     }
  49.  
  50.     if (low < j) {
  51.         [self quickSort:array low:low high:j];
  52.     }
  53.     if (high > i) {
  54.         [self quickSort:array low:i high:high];
  55.     }
  56. }
  57.  
  58. #pragma - mark 冒泡排序
  59. + (void)buddleSort:(NSMutableArray *)array
  60. {
  61.     if(array == nil || array.count == 0){
  62.         return;
  63.     }
  64.  
  65.     for (int i = 1; i < array.count; i++) {
  66.         for (int j = 0; j < array.count - i; j++) {
  67.             if ([array[j] compare:array[j+1]] == NSOrderedDescending) {
  68.                 [array exchangeObjectAtIndex:j withObjectAtIndex:j+1];
  69.             }
  70.  
  71.             printf("排序中:");
  72.             [self printArray:array];
  73.         }
  74.     }
  75.  
  76. }
  77.  
  78. #pragma - mark 选择排序
  79. + (void)selectSort:(NSMutableArray *)array
  80. {
  81.     if(array == nil || array.count == 0){
  82.         return;
  83.     }
  84.  
  85.     int min_index;
  86.     for (int i = 0; i < array.count; i++) {
  87.         min_index = i;
  88.         for (int j = i + 1; j<array.count; j++) {
  89.             if ([array[j] compare:array[min_index]] == NSOrderedAscending) {
  90.                 [array exchangeObjectAtIndex:j withObjectAtIndex:min_index];
  91.             }
  92.  
  93.             printf("排序中:");
  94.             [self printArray:array];
  95.         }
  96.     }
  97. }
  98.  
  99. #pragma - mark 插入排序
  100. + (void)inserSort:(NSMutableArray *)array
  101. {
  102.     if(array == nil || array.count == 0){
  103.         return;
  104.     }
  105.  
  106.     for (int i = 0; i < array.count; i++) {
  107.         NSNumber *temp = array[i];
  108.         int j = i-1;
  109.  
  110.         while (j >= 0 && [array[j] compare:temp] == NSOrderedDescending) {
  111.             [array replaceObjectAtIndex:j+1 withObject:array[j]];
  112.             j--;
  113.  
  114.             printf("排序中:");
  115.             [self printArray:array];
  116.         }
  117.  
  118.         [array replaceObjectAtIndex:j+1 withObject:temp];
  119.     }
  120. }
  121.  
  122. + (void)printArray:(NSArray *)array
  123. {
  124.     for(NSNumber *number in array) {
  125.         printf("%d ",[number intValue]);
  126.     }
  127.  
  128.     printf("\n");
  129. }
  130.  
  131. @end

调用我就写在了app启动的方法里：

  1. - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
  2. {
  3.     self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
  4.     // Override point for customization after application launch.
  5.     self.window.backgroundColor = [UIColor whiteColor];
  6.     [self.window makeKeyAndVisible];
  7.  
  8.     NSMutableArray *array = [NSMutableArray arrayWithObjects:@9,@2,@10,@7,@3,@7,@4,nil];
  9.  
  10.     printf("排序前:");
  11.     [SortUtil printArray:array];
  12.     //快速排序
  13. //    [SortUtil quickSort:array low:0 high:6];
  14.     //冒泡排序
  15. //    [SortUtil buddleSort:array];
  16.     //选择排序
  17. //    [SortUtil selectSort:array];
  18.     //插入排序
  19.     [SortUtil inserSort:array];
  20.  
  21.     printf("排序后:");
  22.     [SortUtil printArray:array];
  23.  
  24.     return YES;
  25. }

Objective-C实现常用的4种排序算法的更多相关文章

  1. java算法03 - 常用的8种排序算法

    Java常用的八种排序算法: 插入排序 - 直接插入排序 每次将待排序的记录按照关键字的大小,插入到前面已经排好序的记录的适当位置.直到全部记录插入完成. 代码实现 /** * 直接插入排序 O(n^ ...

  2. 学习Java绝对要懂的，Java编程中最常用的几种排序算法！

    今天给大家分享一下Java中几种常见的排序算法的Java代码 推荐一下我的Java学习羊君前616,中959,最后444.把数字串联起来!     ,群里有免费的学习视频和项目给大家练手.大神有空时也 ...

  3. 算法分析中最常用的几种排序算法（插入排序、希尔排序、冒泡排序、选择排序、快速排序，归并排序）C 语言版

    每次开始动手写算法,都是先把插入排序,冒泡排序写一遍,十次有九次是重复的,所以这次下定决心,将所有常规的排序算法写了一遍,以便日后熟悉. 以下代码总用一个main函数和一个自定义的CommonFunc ...

  4. Java中常用的6种排序算法详细分解

    排序算法很多地方都会用到,近期又重新看了一遍算法,并自己简单地实现了一遍,特此记录下来,为以后复习留点材料. 废话不多说,下面逐一看看经典的排序算法: 1. 选择排序 选择排序的基本思想是遍历数组的过 ...

  5. Java常用的八种排序算法与代码实现

    1.直接插入排序 经常碰到这样一类排序问题:把新的数据插入到已经排好的数据列中. 将第一个数和第二个数排序,然后构成一个有序序列 将第三个数插入进去,构成一个新的有序序列. 对第四个数.第五个数--直 ...

  6. 一遍记住Java常用的八种排序算法与代码实现

    1.直接插入排序 经常碰到这样一类排序问题:把新的数据插入到已经排好的数据列中. 将第一个数和第二个数排序,然后构成一个有序序列 将第三个数插入进去,构成一个新的有序序列. 对第四个数.第五个数……直 ...

  7. Java基础学习总结（60）——Java常用的八种排序算法

    1.直接插入排序 经常碰到这样一类排序问题:把新的数据插入到已经排好的数据列中. 将第一个数和第二个数排序,然后构成一个有序序列 将第三个数插入进去,构成一个新的有序序列. 对第四个数.第五个数--直 ...

  8. 一遍记住Java常用的八种排序算法

    1.直接插入排序 经常碰到这样一类排序问题:把新的数据插入到已经排好的数据列中. 将第一个数和第二个数排序,然后构成一个有序序列 将第三个数插入进去,构成一个新的有序序列. 对第四个数.第五个数--直 ...

  9. C#常用8种排序算法实现以及原理简介

    public static class SortExtention { #region 冒泡排序 /* * 已知一组无序数据a[1].a[2].--a[n],需将其按升序排列.首先比较a[1]与a[2 ...

随机推荐

  1. 字符串的最长回文串：Manacher’s Algorithm

    题目链接:Longest Palindromic Substring 1. 问题描述 Given a string S, find the longest palindromic substring ...

  2. mysql获取某个表的所有字段名

    http://www.netingcn.com/mysql-column-name.html mysql安装成功后可以看到已经存在mysql.information_schema和test这个几个数据 ...

  3. Java Web -【分页功能】详解

    分页简介 分页功能在网页中是非常常见的一个功能,其作用也就是将数据分割成多个页面来进行显示. 使用场景: 当取到的数据量达到一定的时候,就需要使用分页来进行数据分割. 当我们不使用分页功能的时候,会面 ...

  4. Page Object设计模式实践

    Page Object模式是使用Selenium的广大同行最为公认的一种设计模式.在设计测试时,把元素和方法按照页面抽象出来,分离成一定的对象,然后再进行组织. Page Object模式,创建一个对 ...

  5. C语言多维数组的指针传递

    在C语言中为了节省空间,提高运行速度经常使用指针来完成数组的传递. 对于一维数组而言可以直接传递首地址 而对于二维数组必须在传递时声明是二维数组的指针,并且调用时也要经过一些运算 首先是定义形参: 函 ...

  6. 实战 PureMVC

    最近看PureMVC,在IBM开发者社区发现此文,对PureMVC的讲解清晰简洁,看了可快速入门.另外,<腾讯桌球>游戏的开发者吴秦,也曾进一步剖析PureMVC,可结合看加深理解. 引言 ...

  7. RDO Stack Exception: UnboundLocalError: local variable 'logFile' referenced before assignment

    Issue: When you install RDO stack on CentOS, you may encounter following error. Error: [root@localho ...

  8. Swift对象实例方法名混淆的解决

    在Xcode7.x中,比如有以下一个类: class Foo{ func test(v:Int,before:Int)->Int{ return v + 1 } } 我可以直接这么做: let ...

  9. Android makefile编写基础

    首先来看一个简单的Android makefile,这个是我上篇文章写的,重新摘出来: LOCAL_PATH:=$(call my-dir) include $(CLEAR_VARS) LOCAL_M ...

  10. Markdown对应Yelee主题语法

    概述 这里说的是Yelee主题的语法和原生语法是有些区别的:更多的基础语法可以到Cmd Markdown上面去查看:但是我觉得都会各有不同吧 注意这里说的不是真正意义上的Markdown语法 标题 一 ...