归并排序之数组和链表

归并排序之数组篇

Step1: 合并两个有序的数组

void mergearray (int arr[] , int first , int mid , int last , int temp[]) {
    // temp数组是临时用来储存已经排好序的数组
    int i = first , j = mid + 1 ; 
    // i , j分别储存两个数组两部分的开头
    int m = mid , n = last ; 
    // m储存中间值，i部分的末尾；n储存末尾值，j部分的末尾
    int k = 0 ; 
    // 储存temp数组的的位置 

    while (i <= m && j <= n) { // 两部分数组都未遍历完的时候
        if (arr[i] <= arr[j])
            temp[k ++] = arr[i ++] ;
        else if (arr[i] > arr[j])
            temp[k ++] = arr[j ++] ; 
    } 
    // i , j两部分数组至少有一个已经遍历完，如果遍历完，就不会进入while循环 
    while (i <= m) // 如果i部分数组还未遍历完
        temp[k ++] = arr[i ++] ;
    while (j <= n) // 如果j部分数组还未遍历完
        temp[k ++] = arr[j ++] ;

    for (int i = 0 ; i < k ; i ++)  
        arr[first + i] = temp[i] ; 
    // 将排好序的数组复制回原数组,因为temp数组是临时的
}

Step2: 将数组一分为二，不断递归

void mergesort (int arr[] , int first , int last , int temp[]) {
    if (first == last) return ; 
    // 只有一个元素的时候，就是已经排好序的，直接返回
    if (first < last) {
        int mid = (first + last) / 2 ;
        // 找到中间点
        mergesort (arr , first , mid , temp) ; 
        // 对左边排好序 
        mergesort (arr , mid + 1 , last , temp) ; 
        // 对右边排好序 
        mergearray (arr , first , mid , last , temp) ; 
        // 将左边，右边合并进入一个数组
    } 
}

Step3: 实现更加人性化的接口（更方便客户使用）

bool mergeSort (int arr[] , int length) {
    int* p = new int [length] ; 
    // 用作临时储存数组
    if (p == NULL || length == 0) {
        return false ;
    }
    mergesort (arr , 0 , length - 1 , p) ;
    delete [] p ;
    return true ;
}

归并排序之链表篇

有这样一个链表

 struct node {
  int data;
  struct node* next;
  node(int data = 0, struct node* next = NULL) : data(data), next(next) {}
} ；

Step1: 将两个有序链表合并成一个链表

node* mergeSortedList (node* h1 , node* h2) {
    // 注意这里要返回链表指针作为参数，否则其他函数无法获得已经排好序的链表
    node* newhead ;
    if (h1 == NULL) return h2 ;
    if (h2 == NULL) return h1 ;
    // 如果有一个链表为空，那么直接返回另外一个链表指针作为头即可
    if (h1 -> data <= h2 -> data) {
        newhead = h1 ;
        h1 = h1 -> next ;
    }
    else {
        newhead = h2 ;
        h2 = h2 -> next ;
    }
    // 找到新的头指针，并且把那个向后移一个
    node* temp = newhead ;
    // 防止newhead被修改
    while (h1 && h2) {
        if (h1 -> data <= h2 -> data) {
            temp -> next = h1 ;
            temp = temp -> next ;
            h1 = h1 -> next ;
        }
        else {
            temp -> next = h2 ;
            temp = temp -> next ;
            h2 = h2 -> next ;
        }
    }
    // 如果h1没排完：
    while (h1) {
        temp -> next = h1 ;
        h1 = h1 -> next ;
        temp = temp -> next ;
    }
    // 如果h2没排完：
    while (h2) {
        temp -> next = h2 ;
        temp = temp -> next ;
        h2 = h2 -> next ;
    }
    return newhead ;
}

Step2: 将链表一分为二（注意怎么找到链表的中间点）

node* mergeSort (node* head) {
    // 注意这里需要有返回值，原因是要在递归过程把结果传递下去
    if (head == NULL || head -> next == NULL) return head ;
    // 如果是空，直接返回head
    node* fast = head , *slow = head ;
    while (fast -> next && fast -> next -> next) {
        fast = fast -> next -> next ;
        slow = slow -> next ;
    }
    // 利用fast的检索速度是slow的两倍来找到中间点
    node* leftHead = head ;
    node* rightHead = slow -> next ;
    slow -> next = NULL ; 
    // 十分十分重要的是，要把左边的尾巴断掉，即置空
    leftHead = mergeSort (leftHead) ;
    // 排好左边链表
    rightHead =  mergeSort (rightHead) ;
    // 排好右边链表
    return mergeSortedList (leftHead , rightHead) ;
    // 返回合并后的链表
}