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

归并排序

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

---

//
//  main.cpp
//  MergeSort
//
//  Created by Alps on 14-8-2.
//  Copyright (c) 2014年 chen. All rights reserved.
//

#include <iostream>
#define ElementType int
using 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 int

void 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 int

void 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;
}