歸併排序算法

歸併排序算法

• 算法實現
  • 兩個有序的向量或者列表, 每次只比較兩個有序序列中首個元素，取小值附加到空序列上, 一旦一個序列空了，另外一個序列的元素可以直接附加到空序列上
• 和冒泡排序相比的優勢
  • 冒泡排序的複雜度是 O(n^2)， 最好情況下是 O(n) 最壞的情況 O(n^2) 不穩定; 而歸併排序算法一直是 O(nlogn)

算法實現

template<typename T>
void mergeSort(vector<T> &numbers, RANK low, RANK high) {

    // 單元素自然有序
    if (high - low < 2) {
        return;
    }

    // 二分
    RANK mi = (low + high) >> 1;

    // 各自排序
    mergeSort(numbers, low, mi);
    mergeSort(numbers, mi, high);

    merge(numbers, low, high, mi);
}

template<typename T>
void merge(vector<T> &numbers, RANK low, RANK high, RANK mi) {
    T* begin = &numbers[0];

     A = begin + low; // 合併後向量 A[0, high-low) = numbers[low, high)
    int lb = mi - low;
    T *B = new T[lb]; // 前子向量 B[0, lb) = numbers[lo, mi)
    for (int i = 0; i < lb; ++i) {
        B[i] = A[i];
    }

    int lc = high - mi;
    T *C = begin + mi;// 後子向量 C[0, lc) = numbers[mi, hi)

    for (RANK i = 0, j = 0, k = 0; (j < lb || k < lc);) {
        int rand_number2 = rand();
        // 如果 前子向量還沒有循環結束且前子向量當前的值大於後子向量的當前值 或者後子向量循環結束了 則取當前的前向量的元素附加到A末尾
        if (j < lb && (k >= lb || B[j] < C[k])) {
			A[i++] = B[j++];
        }

        if (k < lc && (j >= lc || C[k] <= B[j])) {
            A[i++] = C[k++];
        }
    }
}

調用案列

#include <iostream>
#include <vector>

using namespace std;

typedef int RANK;
typedef int T;

#define AGE_MIN 15
#define AGE_MAX 25
#define AGE_SIZE 10
#define STATUS_ERROR -1

T *A;

template<typename T>
void merge(vector<T> &vector, RANK low, RANK high, RANK mi);

// 15 25之間的年齡
RANK getRandomAges() {
    return AGE_MIN + rand() % (AGE_MAX - AGE_MIN);
}

// 打印向量
void showAges(vector<T> ages) {
    for (int i = 0; i < ages.size(); ++i) {
        cout << " ages[" << i << "]=" << ages[i] << endl;
    }
    cout << "向量打印結束" << endl;
};

// 歸併排序算法 [low, high)
template<typename T>
void mergeSort(vector<T> &numbers, RANK low, RANK high) {
    // 單元素自然有序
    if (high - low < 2) {
        return;
    }

    // 二分
    RANK mi = (low + high) >> 1;

    // 各自排序
    mergeSort(numbers, low, mi);
    mergeSort(numbers, mi, high);
	
	// 歸併排序
    merge(numbers, low, high, mi);
}


template<typename T>
void merge(vector<T> &numbers, RANK low, RANK high, RANK mi) {
	// 使用指針實現
    T* begin = &numbers[0];
     A = begin + low; // 合併後向量 A[0, high-low) = numbers[low, high)
    int lb = mi - low;
    T *B = new T[lb]; // 前子向量 B[0, lb) = numbers[lo, mi)
    for (int i = 0; i < lb; ++i) {
        B[i] = A[i];
    }

    int lc = high - mi;
    T *C = begin + mi;// 後子向量 C[0, lc) = numbers[mi, hi)

    for (RANK i = 0, j = 0, k = 0; (j < lb || k < lc);) {
        int rand_number2 = rand();
        // 如果 前子向量還沒有循環結束且前子向量當前的值大於後子向量的當前值 或者後子向量循環結束了 則取當前的前向量的元素附加到A末尾
        if (j < lb && (k >= lb || B[j] <= C[k])) {
            A[i++] = B[j++];
        }

        if (k < lc && (j >= lc || C[k] <= B[j])) {
            A[i++] = C[k++];
        }
    }
}

int main() {
    vector<RANK> ages;
 for (int i = 0; i < AGE_SIZE; ++i) {
       ages.push_back(getRandomAges());
   }

	// 打印原始向量
    showAges(ages);
    
    // 歸併排序
    mergeSort(ages, 0, ages.size());
    
	// 打印排序後的向量
    showAges(ages);
    return 0;
}