iOS常见算法以及应用

---

算法比较

关键词

• 二分
• 递归
• 分治
• 回溯

冒泡排序

• 思想：两次循环，外层进行循环次数的控制，内层循环，进行数据之间的比较，大的数据上浮（下沉）

#pragma mark - Objective-C
//冒泡排序
- (void)bubbleSort:(id)array{
    if (!([array isKindOfClass:[NSArray class]] || [array isKindOfClass:[NSMutableArray class]])) {
        NSLog(@"传入的参数不是数组类型");
        return;
    }
    NSMutableArray *tmpArr;
    if ([array isKindOfClass:[NSMutableArray class]]) {
        tmpArr = array;
    }else{
        tmpArr = [array mutablecopy];
    }
    for (int i = 0; i<tmpArr.count; i++) {
        for (int j = 0; j < tmpArr.count -1; j++) {
            if ([tmpArr[j] compare:tmpArr[j+1]] == NSOrderedDescending) {
                [tmpArr exchangeObjectAtIndex:i withObjectAtIndex:j+1];
            }
        }
    }
    NSLog(@"排序完的结果为:%@/n",tmpArr);
}

#pragma mark - C
//冒泡排序
void bubble_sort(int arr[], const int size){
    for (int i = 0; i < size; i++) {
        for (int j = 0; j<size -1 ; j++) {
            if (arr[j] > arr[j+1]) {
                swap(arr[j], arr[j+1]);
            }
        }
    }
}

void swap(int i,int j){
    i = i + j;
    j = i - j;
    i = i - j;
}

快速排序

• 思想：（快速排序是基于一种叫做“二分”的思想）从数列中，挑选出一个元素作为基准，重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以放在任一边，在这个分区退出之后，该基准就处于数列的中间位置，递归的把小于基准值元素的子数列和大于基准值元素的子数列排序。

/**
 快速排序
 @param array 任意类型
 @param low 需要排序的数组的开始位置
 @param high 需要排序的数组的结束位置
 */
- (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) {
//            i++;
//        }
        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--;
        }
    }
    
    if (low < j) {
        [self quickSort:array low:low high:j];
    }
    if (high > i) {
        [self quickSort:array low:i high:high];
    }
}

//快速排序
int a[101],n;//定义全局变量，这两个变量需要在子函数中使用
void quicksort(int left,int right)
{
    int i,j,t,temp;
    if(left>right)
        return;
    
    temp=a[left]; //temp中存的就是基准数
    i=left;
    j=right;
    while(i!=j){
        //顺序很重要，要先从右边开始找
        while(a[j]>=temp && i<j)
            j--;
        //再找右边的
        while(a[i]<=temp && i<j)
            i++;
        //交换两个数在数组中的位置
        if(i<j){
            t=a[i];
            a[i]=a[j];
            a[j]=t;
        }
    }
    //最终将基准数归位
    a[left]=a[i];
    a[i]=temp;
    
    quicksort(left,i-1);//继续处理左边的，这里是一个递归的过程
    quicksort(i+1,right);//继续处理右边的 ，这里是一个递归的过程
}

选择排序

思想：首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾，以此类推，直到所有元素均排序完毕。

1
2
3
4
5
大专栏

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。