算法学习 - 归并排序，快速排序，冒泡排序

来源：互联网发布：php curl exec 超时编辑：程序博客网时间：2024/04/30 16:22

归并排序

现在的归并排序一般都是二路归并，多路归并用在外部排序比较多一点。
归并排序就是从头遍历两个有序的序列，然后放到第三个空列表里，依次放如两个列表头较小的那个元素。
下面是代码：

////  main.cpp//  MergeSort////  Created by Alps on 14-8-2.//  Copyright (c) 2014年 chen. All rights reserved.//#include <iostream>#define ElementType intusing namespace std;void Merge(int *A, int left, int right, int center, int *TmpArr){    int leftPtr = left, rightPtr = center;    int i = left;    while (leftPtr < center && rightPtr <= right) {        if (A[leftPtr] <= A[rightPtr]) {            TmpArr[i++] = A[leftPtr];            leftPtr++;        }else{            TmpArr[i++] = A[rightPtr];            rightPtr++;        }    }    if (leftPtr >= center) {        while (rightPtr <= right) {            TmpArr[i++] = A[rightPtr];            rightPtr++;        }    }    if (rightPtr > right) {        while (leftPtr < center) {            TmpArr[i++] = A[leftPtr];            leftPtr++;        }    }    for (int j = left; j <= right ; j++) {        A[j] = TmpArr[j];    }}void MSort(int *A, ElementType *TmpArr, int left, int right){        if (left < right) {        int center = (left+right)/2;        MSort(A, TmpArr, left,center);        MSort(A, TmpArr, center+1, right);        Merge(A,left, right, center+1, TmpArr);    }}void MergeSort(int *A, int length){    ElementType TmpArr[length];    int left = 0,right = length-1;    MSort(A, TmpArr, left, right);    for (int i = 0; i < length; i++) {        printf("%d ",A[i]);    }    printf("\n");}int main(int argc, const char * argv[]){    ElementType A[] = {24, 13, 26, 1, 2, 27, 38, 15};    MergeSort(A, sizeof(A)/sizeof(ElementType));    return 0;}

快速排序

快速排序是一个用的很多的排序算法，它的时间复杂度平均为O(NlogN)，但是重要的是要选择好正确的flag元素。我认为和归并正好相反，归并是先分成很多段，然后把各个段合并起来，快排是把一个长序列不断的有序的分成很多段，直接就排序好了。
下面时代码：

////  main.cpp//  QuickSort////  Created by Alps on 14-8-2.//  Copyright (c) 2014年 chen. All rights reserved.//#include <iostream>#define ElementType intvoid QuickSort(ElementType *A, int left, int right){    if (left < right) {        int i = left, j = left;        int mid = right;        for (int k = left; k < right; k++) {            if (A[j] <= A[mid]) {                A[i] += A[j];                A[j] = A[i]-A[j];                A[i] = A[i]-A[j];                i++;                j++;            }else{                j++;            }        }        A[i] = A[i]+A[mid];        A[mid] = A[i]-A[mid];        A[i] = A[i]-A[mid];        mid = i;        QuickSort(A, left, mid-1);        QuickSort(A, mid+1, right);    }    }int main(int argc, const char * argv[]){    ElementType A[] = {24, 13, 26, 1, 2, 27, 38, 15};    int length = sizeof(A)/sizeof(ElementType);    QuickSort(A, 0, length-1);    for (int i = 0; i < length; i++) {        printf("%d ",A[i]);    }    printf("\n");    return 0;}

冒泡排序

这个排序算法是最基础的了，就简单的直接说下，就是每次遍历把最大的数字放到序列最后，这样不断遍历，就可以了，所以时间复杂度比较高是O(N2)。
代码：

////  main.cpp//  BubbleSort////  Created by Alps on 14-8-2.//  Copyright (c) 2014年 chen. All rights reserved.//#include <iostream>#define ElementType intvoid BubbleSort(int *A, int length){    for (int i = 0; i < length; i++) {        for (int j = 0; j < length-i-1; j++) {            if (A[j] > A[j+1]) {                A[j] += A[j+1];                A[j+1] = A[j]-A[j+1];                A[j] = A[j] - A[j+1];            }        }    }}int main(int argc, const char * argv[]){    ElementType A[] = {24, 13, 26, 1, 2, 27, 38, 15};    int length = sizeof(A)/sizeof(ElementType);    BubbleSort(A, length);    for (int i = 0; i < length; i++) {        printf("%d ",A[i]);    }    printf("\n");    return 0;}

0 0