排序算法

时间复杂度O( ),空间复杂度 S( )
选择排序,冒泡排序,插入排序 (耗时n*n)
快速排序 2^k = n , k = log2n O(n log n)
计数排序（是水桶排序，效率极高），O（n）, S(2n)

//快速排序
void quickSort(int count, int arr[]){

    if(count < 2){  //如果个数小于2后，停止排序
        return;
    }

    int start1 = 0;
    int end1 = count - 1;
    int temp1 = arr[0];

    while (start1 < end1) {
        while (start1 < end1 && arr[end1] > temp1) {
            end1 --;
        }
        if (start1 < end1) {
            arr[start1] = arr[end1];
            start1 ++;
        }
        while (start1 < end1 && arr[start1] < temp1) {
            start1 ++;
        }
        if (start1 < end1) {
            arr[end1] = arr[start1];
            end1 --;
        }
    }
    arr[start1] = temp1;

    //两边递归
    quickSort(start1,arr);
    quickSort(count - start1 - 1,arr + start1 + 1);
}

@implementation ViewController



- (void)viewDidLoad {
    [super viewDidLoad];

   //冒泡排序（本质：有序区在扩张，无序区缩小）
   //如果数据有明显的分界，优化效果才起作用

    int arr[] = {3,7,5,2,9,4,1,8,6};
    int count = sizeof(arr)/sizeof(*arr);
    BOOL flag = NO;

    for (int i = 0; i < count && flag == NO; i ++) {
        flag = YES;  //假定有序

        for (int j = 0; j < count - 1 - i; j ++) {
            if (arr[j] < arr[j+1]) {
                int t = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = t;
                flag = NO; //确定无序
            }
        }

//        if (flag) {
//            continue;
//        }
    }
    for (int i = 0; i < count; i ++) {
        printf("%d   ",arr[i]);
    }


    //数组下标表示地址偏移次数，所以从0开始

    //二分查找（有序的）
    int arr1[] = {1,2,3,4,5,6,7,8,9};

    int start = 0;
    int end = count - 1;
    int mid = (start + end) / 2;
    int target = 8;

    while (start <= end) {
        if (arr1[mid] > target) {
            end = mid - 1;
        }else if (arr1[mid] < target){
            start = mid + 1;
        }else{
            break;
        }
        mid = (start + end) / 2;
    }

    if (start > end) {
        printf("not found");
    }else{
        printf("     %d",mid);
    }


    //插入排序（j与j-1相比交换，然后 j--）（大量数据的时候？最优）
    int arr2[] = {1,2,3,4,6,7,8,9,5};
    int temp = 0;
    int j = 0;
    for (int i = 1; i < count; i ++) {
        j = i;
        temp = arr2[j];
        while (arr2[j-1] > temp && j > 0) {
            arr2[j] = arr2[j-1];
            j --;
        }
        arr2[j] = temp;
    }
    for (int i = 0; i < count; i ++) {

        printf("\n%d",arr2[i]);
    }


    //快速排序（随便找一个对照数，将数组对半，大的放一边，小的放一边。两边一起进行，当两边的下表重叠时，将对照数放在重叠的位置）
    int arr3[] = {1,3,2,6,4,7,8,9,5};
    quickSort(9,arr3);
    //选择排序

}

注意：递归不是循环，它会不停的开辟空间，耗空间