ืื ืื ืืืื ืืืืื?
ืืืื ืืืืืื ืืื ืืืืืืจืืชื ืื ืคืืฅ ืืืืชืจ ืืืืื ื ืชืื ืื ืืืื ืืงืช " ืืคืจื ืืืืืฉ ". ืืืืืืจืืชื ืื, ืืืขืื ืืืืืงืช ืืชืช-ืืขืืืช ืืืืืจ ืืื ืืืืจ ืืืืื ืื ืืชืืืืืช ืืื. ื ื ืื ืฉืืฉ ืื ื ืจืฉืืื ืฉื ืืกืคืจืื ืื ืืืืื ืื, ืชืืฆืื ืฉื ืฉืืขืืจ ืื ืืฉื ืืกืืื. ืืื ืืืืื ืืืชื ืืคื ืกืืจ ืขืืื ื ืฆืืจื ืืืงื ืืืชื ืืจืฉืืื ืฉืืชืืืื ืื ืืื ืืืืื. ืืืืืืจืืชื ืืืื ืืืืื ืื, ืืจืฉืืื ืชืืืืง ืืจืฉืืืืช ืงืื ืืช ืืืชืจ ืืื ืืืืื ืืืชื ืืกืืจ ืขืืื ืืื ืืื ืชืืื ืืช ืืชืืฆืืืช ืืืื ื ืืืื ืืืชืจ. ื ืืชื ืืืกืืืจ ืืืืื ืืืื ื-Java ืืืืฆืขืืช ืืืืื ืฉื ืืขืจื {6,9,8,2,4,1}, ืฉืงืื ืืืชื ืืชืืฆืื ืืืืื ืืืืงื ืืชืื 10. ืืืขืจื (ืฉื ืืชืืฆืืืช) ืืืืืง ืฉืื ืืฉืื ืื ืชืืื ืงืื ืื ืืืชืจ ืขื ืฉืืืืื ืืื 1. ืืืืจ ืืื ืืชืจืืฉ ืชืืืื ืืืืืื ืชืื ืืืื ืืืกืคืจืื ืื ืืื ืืช. ืื ืืกืคืง ืื ื ืชืืฆืื ืฉืืชืืืื ืืืฆืืื ืื ืื ืืืืื ืืืืชืจ ืืขื ืืฆืืื ืื ืืืืืืื ืืืืชืจ ืฉืืชืงืืื. ืืขืจื ืื ืืืืืง ืืฉื ื ืืขืจืืื ืฉืืืืื 3 ืืืื ืืื ืื ืืื ืืคื ืฉืืืฆื ืืืื ืืฉืื 2 ืืืื ืืืฉืื ืืืชืืืง ืขื ืฉืืืืขืื ืืืืืืช ืืฉืื 4 . ืืืืจ ืืื, ืืืืืจืืชื ืืืืืื ืืชืืื ืืืืื ืืช ืืืกืคืจืื ืฆืขื ืืื ืืื ืคืขื ( ืฉืื 5 ) ืืืืืจ ืืื ืืืื ืืช ืืืกืคืจืื ืืืขืจื ืืืื ืืืชืจ ืืฉืืืื 6 ื-7 .ืืืฉืื
ืืืืฉืื ื ืืชืื ืงืื ืืืืืืจืืชื ืืืืืื ื-Java. ืืืฉืชื ืื ืื ืืจืฉืื ืืืื ืืขืจื ืืงืื ืืืืจื ืืืขืจื. ืฉื ื ืคืจืืืจืื ืืื ืืฉืืฉื ืขืื ืืื ืืืฆืื ืคืจืืืจืื ื ืืกืคืื ืืืฆืืจืช ืคืื ืงืฆืืืช ืืืืืื. ืืืื ื ืกืชืื ืขื ืืงืืข ืืืื ืืื ืืืืื ืืช ืืขืืืื ืืืืืืช ืฉื ืืืืืจืืชื ืืืืืื ื-Java.Merge_Sort_Algo (Array, Beginning, End)
/** Three parameters required for the Merge Sort Algorithm
* Array = values of the array
* Beginning = the starting element of the array
* End = the ending element of the array*/
if (Beginning < End) // condition check Beginning must be less than End
set Middle = (Beginning + End) / 2 // Assigning Middle to the array
Merge_Sort_Algo (Array, Beginning, Middle) /** Sorting and merging of elements from Beginning to the Middle */
Merge_Sort_Algo (Array, Middle +1, End) /** Sorting and merging of elements from Middle to the End */
Merge (Array, Beginning, Middle, End) // Merging both the sorted arrays
end of if
End Merge_Sort_Algo
ืจืืฉืืช, ืืจื ืืชื ืื ืื ืืชืืื ืืกืืฃ ืืฉืืฉืื ืืงืืืขืช ืืืืฆืข. ืืื ืืฉืื ืืื ื ืืฆืจืื 2 ืชืช-ืืขืจืืื ืืืฉืื ืืื ืืืืชืืื ืืืืฆืข ืืืฉื ื ืืชืืื ืืืืืฆืข +1 ืขื ืืกืืฃ. ืืขืจืืื ืืื ืืืืืงืื ืขื ืฉืืืจืื ืืืคื ื-1 ืืื ืืจื ืคืื ืงืฆืืืช ืืืืืื ืืชืืืืื ืืืืจื ืืช ืืขืจืื ืืืฉื ื ืืืืืื ืื Beginning, Middle, Middle+1 ื-End ืืื ืืจืืืฉ ืืช ืืคืชืจืื.
ืืืืื
ืืงืื ืืื ื-Java ืืกืืืจ ืืช ืืืืืจืืชื ืืืื ืืืืืื:import java.util.Arrays;
class HelloWorld {
public static void merge(
int[] array, int[] new_array_1, int[] new_array_2, int left, int right) {
// defining parameters
int i = 0, j = 0, k = 0;
while (i < left && j < right) { // conditions for merging
if (new_array_1[i] <= new_array_2[j]) {
array[k++] = new_array_1[i++];
}
else {
array[k++] = new_array_2[j++];
}
}
while (i < left) {
array[k++] = new_array_1[i++];
}
while (j < right) {
array[k++] = new_array_2[j++];
}
}
public static void mergeSort(int[] array, int length) { /** required parameters */
if (length < 2) { //condition for the length of array
return;
}
int middle = length / 2; // defining new parameter middle
int [ ] new_array_1 = new int [middle]; /** defining the new first array after division */
int [ ] new_array_2 = new int [length - middle]; /** defining the new second array */
for (int i = 0; i < middle; i++) { /**applying condition for sorting of new array 1 */
new_array_1 [ i ] = array [ i ];
}
for (int i = middle; i < length ; i++) { /**applying condition for sorting of new array 2 */
new_array_2 [ i - middle] = array [ i ];
}
mergeSort (new_array_1, middle); /** calling merge sort function for new array 1 */
mergeSort (new_array_2, length - middle); /** calling merge sort function for new array 2 */
merge(array, new_array_1, new_array_2, middle, length - middle); /** calling function for merging of new array 1 and new array 2 */
}
public static void main(String[] args) {
int [ ] testScores = {6,9,8,2,4,1};
int size = testScores.length;
System.out.println("Original Array " + Arrays.toString(testScores) + "\n");
mergeSort(testScores, size);
System.out.println("After Merge Sort " + Arrays.toString(testScores) + "\n");
}
}
ืชึฐืคืึผืงึธื
ืืขืจื ืืงืืจื [6, 9, 8, 2, 4, 1] ืืืืจ ืืืืื ืืืื [1, 2, 4, 6, 8, 9]
GO TO FULL VERSION