[数据结构与算法002]归并排序

目录

前言

一、顺序结构的归并排序

1.算法思想

2.代码实现 

二、链表的归并排序

1.算法思想

①合并两个有序链表

②将条链表一分为二 

2.代码实现

---

前言

归并排序的思想在很多算法都会有体现，这一节介绍归并排序在数组和链表的实现

一、顺序结构的归并排序

1.算法思想

我们首先考虑如何合并两个已经有顺序的数组(函数MERGE的设计)呢？一个简单的方案就是设计两个指针以及一个与原序列等大小的辅助结构即可，分别指向两个数组的开始，然后通过比较每次选中最小的那一个元素安置到辅助数组即可。直到一方到达末尾，将另一方全部拼接到辅助数组中即可。这里有一个问题就是在逻辑上我们认为是两个数组的合并，但是实际上我们只是在一个数组上进行操作的，接下来给出实现的过程。

首先初始化辅助结构，以及两个比较指针，以及安置指针k

 然后开始进行比较，选择较小的元素放到辅助数组，同时指针后移

多次重复操作后直到有一个比较指针到达边界 

将剩余元素插入辅助数组的末尾。

然后我们递归调用整个过程，即可实现目的。

2.代码实现 

#include<iostream>
using namespace std;

void MERGE(int* a, int right, int mid, int left) {
    int i = right, j = mid + 1, k = 0;
    int* b = new int[left - right + 1];
    while (i <= mid && j <= left) {
        if (a[i] <= a[j]) {
            b[k++] = a[i++];
        } else {
            b[k++] = a[j++];
        }
    }
    while (i <= mid) {
        b[k++] = a[i++];
    }
    while (j <= left) {
        b[k++] = a[j++];
    }
    k = 0;
    for (int s = right; s <= left; s++) {
        a[s] = b[k++];
    }
    delete[] b;
}

void MERGESORT(int* a, int right, int left) {
    if (right < left) {
        int mid = (right + left) / 2;
        MERGESORT(a, right, mid);
        MERGESORT(a, mid + 1, left);
        MERGE(a, right, mid, left);
    }
}

void printArray(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main() {
    int arr[] = {38, 27, 43, 3, 9, 82, 10};
    int arr_size = sizeof(arr) / sizeof(arr[0]);

    cout << "Given array is \n";
    printArray(arr, arr_size);

    MERGESORT(arr, 0, arr_size - 1);

    cout << "\nSorted array is \n";
    printArray(arr, arr_size);
    return 0;
}

二、链表的归并排序

1.算法思想

①合并两个有序链表

首先我们来解决如何合并两个有序链表的问题（非常重要）可以单独考察，我们接下来给出解决方法

②将条链表一分为二 

我们利用快慢指针的方式即，快指针（记为p）移动的速度为慢指针（记为q）的二倍。当快指针到达链表的末尾时，慢指针恰好在链表的中间。我们需要返回后一条链表的头节点（即q结点）。链表中的归并排序与数组中的归并排序最大的不同就是，链表真的被切割了，而在数组中只是逻辑上方便理解我们认为被分割。

2.代码实现

代码如下（示例）：

#include <iostream>
#include<vector>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

// 合并两个有序链表
ListNode* merge(ListNode* head1, ListNode* head2) {
    ListNode* dummynode = new ListNode(0);
    ListNode* curr = dummynode;
    ListNode* p1 = head1;
    ListNode* p2 = head2;
    while (p1 && p2) {
        if (p1->val <= p2->val) {
            curr->next = p1;
            p1 = p1->next;
        }
        else {
            curr->next = p2;
            p2 = p2->next;
        }
        curr = curr->next;
    }
    curr->next = !p1 ? p2 : p1;
    return dummynode->next;
}

// 将链表一分为二
ListNode* cut(ListNode* head) {
    ListNode* L1 = head; // 快指针
    ListNode* L2 = head; // 慢指针
    while (L1) {
        L1 = L1->next;
        if (L1 && L1->next) {
            L1 = L1->next;
            L2 = L2->next;
        }
    }
    ListNode* second_head = L2->next;
    L2->next = nullptr;
    return second_head;
}

// 归并排序链表
void Listmergesort(ListNode*& head) {
    if (!head || !head->next) return;
    ListNode* head2 = cut(head);
    Listmergesort(head);
    Listmergesort(head2);
    head = merge(head, head2);
}

// 打印链表
void printList(ListNode* head) {
    while (head) {
        cout << head->val << " ";
        head = head->next;
    }
    cout << endl;
}

// 创建链表
ListNode* createList(const vector<int>& values) {
    if (values.empty()) return nullptr;
    ListNode* head = new ListNode(values[0]);
    ListNode* current = head;
    for (size_t i = 1; i < values.size(); ++i) {
        current->next = new ListNode(values[i]);
        current = current->next;
    }
    return head;
}

int main() {
    vector<int> values = { 4, 2, 1, 3 };
    ListNode* head = createList(values);
    cout << "Original list: ";
    printList(head);
    Listmergesort(head);
    cout << "Sorted list: ";
    printList(head);
    return 0;
}

---