java根号n元素的合并排序算法_分治算法：根号n段合并排序算法

问题：

将数组 a[0,n-1]划分为 根号n 个子数组，每个子数组有 O(根号n)个元素。然后递归地对分割后的子数组进行排序，最后将所得到的根号n 个排好序的子数组合并排序。

工具与语言

我选择的为VS Studio和C++语言。

分治算法基本思想

分治法的设计思想：

将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

分治策略：

对于一个规模为n的问题，若该问题可以容易地解决(比如说规模n较小)则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解决，然后将各子问题的解合并得到原问题的解。

本问题的解决思路为：

首先将问题分解为 根号n 个子问题。对每个子问题同样分解为 根号n 个子问题。当子问题足够小时便直接解决子问题不在分解，并始合并子问题。

映射到本问题则为对a[0,n-1]排序，首先将a[0,n-1]划分为 根号n 数组并对每个子数组进行排序，然后将子数组进行归并操作。对于每个子数组当问题规模仍然很大时，将其划分为 根号n 子数组，并对子数组进行排序，然后将子数组进行归并操作。当子数组问题规模足够小是直接解决此问题。

解决问题

不想打字了

#include #include #include #include using namespace std;

#pragma region 输入

int *input(int n)

{

int* arr = (int*)malloc(sizeof(int)*n);

for (int i = 0; i < n; i++)

{

arr[i] = rand();

}

return arr;

}

#pragma endregion

#pragma region 输出

void output(int* arr,int n)

{

for (int i = 0; i < n; i++)

{

cout << arr[i] << " ";

}

cout << endl;

}

#pragma endregion

#pragma region 排序

//选择排序

int sort(int* arr, int size)

{

if (size == 0)

{

return 0;

}

for (int i = 0; i < size; i++)

{

for (int j = i + 1; j < size; j++)

{

if (arr[j] < arr[i])

{

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

}

return 0;

}

//复制数组

void arrcopy(int*arrcopyform, int*arr1,int size)

{

for (int i = 0; i < size; i++)

{

arr1[i] = arrcopyform[i];

}

}

//归并

void Merging(int* arr, int first1,int last1,int first2,int last2) {

int size1 = last1 - first1;

int size2 = last2 - first2;

int* arr1 = (int*)malloc(sizeof(int)*size1);

int* arr2 = (int*)malloc(sizeof(int)*size2);

int* arr3;

if (first1 < first2)

{

arr3 = arr + first1;

}

else

{

arr3 = arr + first2;

}

arrcopy(arr + first1, arr1, size1);

arrcopy(arr + first2, arr2, size2);

int a = 0;

int p = 0;

int q = 0;//游标

while (p < size1 && q < size2)

{

if (arr1[p] < arr2[q])

{

arr3[a] = arr1[p];

p++;

a++;

}

else

{

arr3[a] = arr2[q];

q++;

a++;

}

}

if (p == size1)

{

while (q < size2)

{

arr3[a] = arr2[q];

a++;

q++;

}

}

else

{

while (p < size1)

{

arr3[a] = arr1[p];

a++;

p++;

}

}

free(arr1);

free(arr2);

}

void rsort(int* arr, int first, int last)

{

int size = last - first;

int sq = (int)sqrt(size);

if (size > 3)

{

int spfirst, splast;

for (int i = 0; i < sq - 1; i++)

{

spfirst = first+sq * i;

splast = spfirst + sq;

rsort(arr, spfirst, splast);

}

rsort(arr, splast, last);

}

else

{

int* tfirst = arr + first;

sort(tfirst, size);

}

int spfirst1 = first;

int splast1 = first + sq;

int spfirst2=first;

int splast2;

for (int i = 1; i < sq - 2; i++)

{

spfirst2 = first+sq * i;

splast2 = spfirst2 + sq;

Merging(arr, spfirst1, splast1, spfirst2, splast2);

splast1 += sq;

}

Merging(arr, spfirst1, splast1, splast1, last);

}

#pragma endregion

int main()

{

int n;

cin >> n;

cout << endl;

int* arr = input(n);

output(arr, n);

rsort(arr, 0, n);

cout<