冒泡排序和快速排序

#pragma mark -
#pragma mark 冒泡排序(选择排序)
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}

void bubbleSort(int a[], int length) {
    while (length > 0) {
        bool temp = false;
        for (int i = 0; i < length; i++) {
            if (a[i+1] < a[i]) {
                swap(&a[i+1], &a[i]);
                temp = true;
            }
        }
        //简单优化，对于已经有序的序列，省去接下的循环。对于这种优化，实际还需考虑，多了赋值和判断操作。
        if (!temp) {
            break;
        }
        length--;
        print(a, length);
    }
}

直接来段代码，冒泡排序是比较常见的排序算法。其原理是依次两两比较，将较大的往后排。将最大的排到最后，再对前面的序列做同样的操作。

#pragma mark -
#pragma mark 快速排序
int patition(int a[], int m, int n) {
int x = a[m];
while (n > m) {
while (n > m && a
>= x) n--;
swap(&a[m], &a
);
while (n > m && a[m] <= x) m++;
swap(&a[m], &a
);
}
print(a, 8);
return m;
}

void sort(int a[], int m, int n) {
if (m < n) {
int location = patition(a, m, n);
sort(a, m, location-1);
sort(a, location+1, n);
}
}

void quickSort(int a[], int length) {
sort(a, 0, length-1);
}
快速排序的使用比较多，递归实现。以一个数据为基准，大于该数据的放在右边，小于该数据的放在左边。然后对左右的序列继续同样的操作。

时间复杂度：

冒泡排序的时间复杂度为O(n^2);

快速排序的时间复杂度为O(n*log(2)n)

以上都是平均状态下。相对堆排序较为稳定O(n*log(2)n)。