Сортировка слиянием - EcsFlash/DataTypes GitHub Wiki

Cуть:

  1. Исходный массив делится на две части
  2. Для полученных подмассивов выполняется шаг 1 до тех пор пока не получатся просто элементы.
  3. Полученные элементы сравниваются между собой и выстраиваются в нужном порядке.
  4. Полученные пары сливаются в четверку, попутно сортируясь
  5. Четверки сливаются в восьмерки и тд пока не будет получен отсортированный исходный массив

Красивая гифка:

gif

Статистика

image

┌────────────┬───────────────┬────────────────┬──────────────┐
│ Сложность  │ Лучший случай │ Средний случай │ Худший случай│
├────────────┼───────────────┼────────────────┼──────────────┤
│   Время    │   O(n log n)  │   O(n log n)   │  O(n log n)  │
├────────────┼───────────────┼────────────────┼──────────────┤
│   Память   │     O(n)      │      O(n)      │     O(n)     │
└────────────┴───────────────┴────────────────┴──────────────┘

Псевдокод(на плюсах я эту залупу писать не собираюсь):

func mergeSort(items []int) []int {
	if len(items) < 2 {
		return items
	}
	first := mergeSort(items[:len(items)/2])//берем левую часть массива
	second := mergeSort(items[len(items)/2:])//берем правую часть массива
	return merge(first, second)
}
func merge(a []int, b []int) []int {
	final := []int{}
	i := 0
	j := 0
	for i < len(a) && j < len(b) { \\это типо while 
		if a[i] > b[j] {
			final = append(final, a[i])
			i++
		} else {
			final = append(final, b[j])
			j++
		}
	}
	for ; i < len(a); i++ { \\for без секции инициализации
		final = append(final, a[i])
	}
	for ; j < len(b); j++ { \\for без секции инициализации
		final = append(final, b[j])
	}
	return final
}

C++

#include <bits/stdc++.h>
using namespace std;

// Merges two subarrays of arr[].
// First subarray is arr[left..mid]
// Second subarray is arr[mid+1..right]
void merge(vector<int>& arr, int left, 
                     int mid, int right)
{
    int n1 = mid - left + 1;
    int n2 = right - mid;

    // Create temp vectors
    vector<int> L(n1), R(n2);

    // Copy data to temp vectors L[] and R[]
    for (int i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    int i = 0, j = 0;
    int k = left;

    // Merge the temp vectors back 
    // into arr[left..right]
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // Copy the remaining elements of L[], 
    // if there are any
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    // Copy the remaining elements of R[], 
    // if there are any
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

// begin is for left index and end is right index
// of the sub-array of arr to be sorted
void mergeSort(vector<int>& arr, int left, int right)
{
    if (left >= right)
        return;

    int mid = left + (right - left) / 2;
    mergeSort(arr, left, mid);
    mergeSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

// Function to print a vector
void printVector(vector<int>& arr)
{
    for (int i = 0; i < arr.size(); i++)
        cout << arr[i] << " ";
    cout << endl;
}

// Driver code
int main()
{
    vector<int> arr = { 12, 11, 13, 5, 6, 7 };
    int n = arr.size();

    cout << "Given vector is \n";
    printVector(arr);

    mergeSort(arr, 0, n - 1);

    cout << "\nSorted vector is \n";
    printVector(arr);
    return 0;
}

обля

⚠️ **GitHub.com Fallback** ⚠️