Слияние двух отсортированных массивов в третий

#include <iostream>
using namespace std;
//функция, сливающая массивы
void Merge(int *A, int first, int last, int *B, int first_1, int last_1) 
{
int middle, start, final, j, middle_1, start_1, final_1, k;
int *mas=new int[100],*mas_1=new int[100]; 
// Начало массива А.
middle=(first+last)/2; //вычисление среднего элемента A
start=first; //начало левой части A
final=middle+1; //начало правой части A
for(j=first; j<=last; j++) //выполнять от начала до конца A
if ((start<=middle) && ((final>last) || (A[start]<A[final])))
{
mas[j]=A[start];
start++;
}
else
{
mas[j]=A[final];
final++;
} // Конец массива А.
// Начало массива В.
middle_1=(first_1+last_1)/2; //вычисление среднего элемента В
start_1=first_1; //начало левой части В
final_1=middle_1+1; //начало правой части В
for(k=first_1; k<=last_1; k++) //выполнять от начала до конца В
if ((start_1<=middle_1) && ((final_1>last_1) || (B[start_1]<B[final_1])))
{
mas_1[k]=B[start_1];
start_1++;
}
else
{
mas_1[k]=B[final_1];
final_1++;
} // Конец массива В.
 
//возвращение результата в список
for (j=first; j<=last; j++) A[j]=mas[j];
for (k=first_1; k<=last_1; k++) B[k]=mas_1[k];
delete[]mas; delete[]mas_1; 
};
//рекурсивная процедура сортировки
void MergeSort(int *A, int first, int last, int *B, int first_1, int last_1)
{
{
if (first<last, first_1<last_1)
{
MergeSort(A, first, (first+last)/2, B, first_1, (first_1+last_1)/2); 
MergeSort(A, (first+last)/2+1, last, B, (first_1+last_1)/2+1, last_1);
Merge(A, first, last, B, first_1, last_1); //слияние двух частей
}
}
};
//главная функция
void main()
{
setlocale(LC_ALL, "Rus");
int n, m, i, l, q; int p=0;
int *A=new int[100], *B=new int[100], *C=new int[100];
cout<<"Размер массива A > "; cin>>n;
cout<<"Размер массива B > "; cin>>m;
cout<<"Размер массива С > "; q=n+m; cout<<q<<endl;
for (i=1; i<=n; i++)
{ cout<<i<<" элемент A > "; cin>>A[i];}
for (l=1; l<=m; l++)
{ cout<<l<<" элемент B > "; cin>>B[l];}
 
MergeSort(A, 1, n, B, 1, m); //вызов сортирующей процедуры
cout<<"Упорядоченный массив A: "; //вывод упорядоченного массива A
for (i=1; i<=n; i++) cout<<A[i]<<" "; 
cout<<endl;
cout<<"Упорядоченный массив B: "; //вывод упорядоченного массива B
for (l=1; l<=m; l++) cout<<B[l]<<" ";
cout<<endl;
cout<<"Упорядоченный массив C: "; //вывод упорядоченного массива C
for (i=0; i<=n; i++) {for (l=0; l<=m; l++) 
    while (p<n+m) {if (A[i]<B[l]) C[p++]=A[i++];
    else C[p++]=B[l++];}}
 
for (p=0; p<=q; p++) cout<<C[p]<<" ";
cout<<endl;
delete[]A; delete[]B; delete[]C;
system("pause");
};

#include <iostream>
using namespace std;
//функция, сливающая массивы
void Merge(int *A, int first, int last, int *mas) {
    int middle, part1, part2, j;
    // Начало массива А.
    middle = (first + last) / 2; //вычисление среднего элемента A
    part1 = first; //начало левой части A
    part2 = middle; //начало правой части A
    for (j = first; j < last; j++) {    //выполнять от начала до конца A
        if (part1 >= middle) {
            mas[j] = A[part2++];
            continue;
        }
        if (part2 >= last) {
            mas[j] = A[part1++];
            continue;
        }
        if (A[part1] < A[part2])
            mas[j] = A[part1++];
        else
            mas[j] = A[part2++];
    }
 
    //возвращение результата в список
    for (j = first; j < last; j++) A[j] = mas[j];
};
//рекурсивная процедура сортировки
void _MergeSort(int *A, int first, int last, int *mas) {
    {
        if (last - first > 1) {
            _MergeSort(A, first, (first + last) / 2, mas);
            _MergeSort(A, (first + last) / 2, last, mas);
            Merge(A, first, last, mas); //слияние двух частей
        }
    }
};
//нерекурсивная процедура сортировки
void MergeSort(int *A, int first, int last) {
    int *_mas = new int[100];       // используем для слияния постоянный буфер
    _MergeSort(A, first, last, _mas);
    delete[] _mas;
}
//главная функция
int main() {
    setlocale(LC_ALL, "Rus");
    int n, m, i, l, q; int p = 0;
    int *A = new int[100], *B = new int[100], *C = new int[100];
    cout << "Размер массива A > "; cin >> n;
    cout << "Размер массива B > "; cin >> m;
    cout << "Размер массива С > "; q = n + m; cout << q << endl;
    for (i = 0; i < n; i++) {
        cout << i << " элемент A > "; cin >> A[i];
    }
    for (l = 0; l < m; l++) {
        cout << l << " элемент B > "; cin >> B[l];
    }
 
    MergeSort(A, 0, n); //вызов сортирующей процедуры
    MergeSort(B, 0, m); //вызов сортирующей процедуры
    cout << "Упорядоченный массив A: "; //вывод упорядоченного массива A
    for (i = 0; i < n; i++) cout << A[i] << " ";
    cout << endl;
    cout << "Упорядоченный массив B: "; //вывод упорядоченного массива B
    for (l = 0; l < m; l++) cout << B[l] << " ";
    cout << endl;
    cout << "Упорядоченный массив C: "; //вывод упорядоченного массива C
 
    i = l = 0;
    for (int j = 0; j < q; ++j) {
        if (i >= n) {       // массив A уже весь обработан
            C[j] = B[l++];
            continue;
        }
        if (l >= m) {       // массив B уже весь обработан
            C[j] = A[i++];
            continue;
        }
        if (A[i] < B[l])
            C[j] = A[i++];
        else
            C[j] = B[l++];
    }
 
 
    for (p = 0; p < q; p++) cout << C[p] << " ";
    cout << endl;
    delete[]A; delete[]B; delete[]C;
    system("pause");
}

#include <algorithm>
#include <array>
#include <iostream>
#include <random>
 
int main() {
 
    constexpr std::size_t size = 10;
 
    std::array<int, size> arrA;
    std::array<int, size> arrB;
    std::array<int, size * 2> arrC;
 
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> dist(-50, 50);
 
    std::generate(arrA.begin(), arrA.end(), [&gen, dist]() { return dist(gen); });
    std::generate(arrB.begin(), arrB.end(), [&gen, dist]() { return dist(gen); });
 
    std::sort(arrA.begin(), arrA.end());
    std::sort(arrB.begin(), arrB.end());
 
    std::merge(arrA.begin(), arrA.end(), arrB.begin(), arrB.end(), arrC.begin());
 
    std::copy(arrC.begin(), arrC.end(), std::ostream_iterator<int>(std::cout, " "));
 
    system("PAUSE");
    return 0;
 
}