Merge sort algorithm C code implementation

Merge sort is another type of sorting method. The meaning of merging is to combine two or more ordered data sequences into a new ordered data sequence, therefore, it is also called the merge algorithm. The basic idea is to assume that array A has n elements, and array a is composed of N ordered subsequences. The length of each subsequence is 1, then merge them in two ways to obtain an n/2 ordered subsequences with a length of 2 or 1, and then merge them in two, it is worthwhile to obtain a sequence of ordered data whose length is N. This sorting method is called 2-way merge sorting.

For example, if array A has 7 data records, which are 49 38 65 97 76 13 27, then the operation process using the Merge Sorting Algorithm is 7:
Initial Value [49] [38] [65] [97] [76] [13] [27]
It is regarded as composed of seven subsequences with a length of 1.
[38 49] [65 97] [13 76] [27] after the first merge
It is regarded as composed of four subsequences with a length of 1 or 2.
[38 49 65 97] [13 27 76] after the second merge
It is considered to be composed of two subsequences with a length of 4 or 3.
[13 27 38 49 65 76 97] after the third merge
The core operation of the merge algorithm is to combine two adjacent sequential sequences in one-dimensional array into one ordered sequence. Merge algorithms can also be implemented using recursive algorithms. The form is simple, but the practicality is poor. The number of merging operations of the merge algorithm is a very important amount. When the array contains 3 to 4 elements, the number of merging operations is twice. When there are 5 to 8 elements, the number of merging operations is three. When there are 9 to 16 elements, the number of merging operations is four. According to this rule, when there are n subsequences, we can infer that the number of merging times is X (2> = N, the minimum X that meets this condition ).

The time complexity is O (nlogn). The auxiliary storage space required is O (n)
The merge algorithm is as follows:

# Include <stdio. h>

1. # Include <stdlib. h>
2. Typedef int rectype; // type of the element to be sorted
   
3. Void Merge (rectype * r, int low, int M, int high)
4. {
5. // Combine two ordered sub-files R [low.. m) and R [M + 1 .. High] into an ordered sub-file R [low .. High]
   
6. Int I = low, j = m + 1, P = 0; // set the Initial Value
   
7. Rectype * R1; // R1 is a local vector
   
8. R1 = (rectype *) malloc (high-low + 1) * sizeof (rectype ));
9. If (! R1)
10. {
11. Return; // failed to apply for Space
    
12. }
14. While (I <= M & J <= high) // when the two sub-files are not empty, the small ones are output to R1 [p ].
    
15. {
16. R1 [p ++] = (R [I] <= R [J])? R [I ++]: R [J ++];
17. }
19. While (I <= m) // If the 1st sub-files are not empty, copy the remaining records to r1
    
20. {
21. R1 [p ++] = R [I ++];
22. }
23. While (j <= high) // If the 2nd sub-files are not empty, copy the remaining records to r1
    
24. {
25. R1 [p ++] = R [J ++];
26. }
28. For (P = 0, I = low; I <= high; P ++, I ++)
29. {
30. R [I] = R1 [p]; // after merging, copy the result back to R [low... high]
    
31. }
32. }
34. Void mergesort (rectype R [], int low, int high)
35. {
36. // Sort R [low .. High] by means of the division and Control Law.
    
37. Int mid;
38. If (low
39. {// The Interval Length is greater than 1
40. Mid = (low + high)/2; // Decomposition
    
41. Mergesort (R, low, mid); // recursively sorts R [low... mid]
    
42. Mergesort (R, Mid + 1, high); // recursively sorts R [Mid + 1 .. High]
    
43. Merge (R, low, mid, high); // combine two ordered zones into one ordered Zone
    
44. }
45. }
46. Void main ()
47. {
48. Int A [7] = {, 27}; // sort the eight elements
    
49. Int low = 0, high = 6; // initialize the values of low and high
    
51. Printf ("before merge sort :");
52. For (INT I = low; I <= high; I ++)
53. {
54. Printf ("% d", a [I]); // output test
    
55. }
56. Printf ("/N ");
58. Mergesort (A, low, high );
60. Printf ("after merge sort :");
61. For (I = low; I <= high; I ++)
62. {
63. Printf ("% d", a [I]); // output test
    
64. }
65. Printf ("/N ");
66. }