归并排序算法

归并排序算法

• 算法实现
  • 两个有序的向量或者列表, 每次只比较两个有序序列中首个元素，取小值附加到空序列上, 一旦一个序列空了，另外一个序列的元素可以直接附加到空序列上
• 和冒泡排序相比的优势
  • 冒泡排序的复杂度是 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;
}