Algorithms Overview<\/strong><\/h2>\n\n\n\nMerge Sort is a stable algorithm that uses a divide-and-conquer strategy. Its worst-case time complexity is O(nlogn), making it quite efficient for large amounts of data. MergeSort requires additional space of O(n).<\/p>\n\n\n
void<\/span> merge(int arr[], int left, int mid, int right)\n{\n int n1 = mid - left + 1<\/span>;\n int n2 = right - mid;\n\n\n int L[n1], R[n2];\n\n\n for<\/span> (int i = 0<\/span>; i < n1; i++)\n L[i] = arr[left + i];\n for<\/span> (int j = 0<\/span>; j < n2; j++)\n R[j] = arr[mid + 1<\/span> + j];\n\n\n int i = 0<\/span>, j = 0<\/span>, k = left;\n while<\/span> (i < n1 && j < n2)\n {\n if<\/span> (L[i] <= R[j])\n {\n arr[k] = L[i];\n i++;\n }\n else<\/span>\n {\n arr[k] = R[j];\n j++;\n }\n k++;\n swapCounter++;\n }\n\n\n while<\/span> (i < n1)\n {\n arr[k] = L[i];\n i++;\n k++;\n swapCounter++;\n }\n\n\n while<\/span> (j < n2)\n {\n arr[k] = R[j];\n j++;\n k++;\n swapCounter++;\n }\n}\n\n\nvoid<\/span> mergeSort(int arr[], int left, int right)\n{\n swapCounter = 0<\/span>;\n if<\/span> (left < right)\n {\n int mid = left + (right - left) \/ 2<\/span>;\n\n\n mergeSort(arr, left, mid);\n mergeSort(arr, mid + 1<\/span>, right);\n\n\n merge(arr, left, mid, right); \n }\n}\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\nQuick Sort is one of the most efficient sorting algorithms. Its average time complexity is O(nlogn), but in the worst case, it can be O(n2), which should be considered when evaluating. QuickSort is generally faster than MergeSort and HeapSort, even though the worst-case time complexity is O(n2). QuickSort sorts the array in place, avoiding the need for additional memory like MergeSort.<\/p>\n\n\n
\n\nint swapCounter = 0<\/span>;\n\n\nint partition(int *array<\/span>, int low, int high)\n{\n int pivot = array<\/span>[high];\n int i = (low - 1<\/span>);\n\n\n for<\/span> (int j = low; j < high; j++)\n {\n if<\/span> (array<\/span>[j] <= pivot)\n {\n i++;\n int temp = array<\/span>[i];\n array<\/span>[i] = array<\/span>[j];\n array<\/span>[j] = temp;\n swapCounter++;\n }\n }\n\n\n int temp = array<\/span>[i + 1<\/span>];\n array<\/span>[i + 1<\/span>] = array<\/span>[high];\n array<\/span>[high] = temp;\n swapCounter++;\n return<\/span> (i + 1<\/span>);\n}\n\n\nvoid quickSortExecute(int *array<\/span>, int low, int high)\n{\n if<\/span> (low < high)\n {\n int pi = partition(array<\/span>, low, high);\n quickSortExecute(array<\/span>, low, pi - 1<\/span>);\n quickSortExecute(array<\/span>, pi + 1<\/span>, high);\n }\n}\n\n\nvoid quickSort(int *array<\/span>, int low, int high)\n{\n swapCounter = 0<\/span>;\n quickSortExecute(array<\/span>, low, high);\n}\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nHeap Sort is an algorithm that uses a data structure called a heap. Its time complexity is also O(nlogn), making it consistently efficient even in the worst case. HeapSort also sorts in place but has more overhead due to tree-based operations.<\/p>\n\n\n
void<\/span> swap(int *a, int *b)\n{\n int temp = *a;\n *a = *b;\n *b = temp;\n swapCounter++;\n}\n\n\nvoid<\/span> heapify(int arr[], int n, int i)\n{\n int largest = i;\n int left = 2<\/span> * i + 1<\/span>;\n int right = 2<\/span> * i + 2<\/span>;\n\n\n if<\/span> (left < n && arr[left] > arr[largest])\n largest = left;\n\n\n if<\/span> (right < n && arr[right] > arr[largest])\n largest = right;\n\n\n if<\/span> (largest != i)\n {\n swap(&arr[i], &arr[largest]);\n heapify(arr, n, largest);\n }\n}\n\n\nvoid<\/span> heapSort(int arr[], int n)\n{\n swapCounter = 0<\/span>;\n for<\/span> (int i = n \/ 2<\/span> - 1<\/span>; i >= 0<\/span>; i--)\n {\n heapify(arr, n, i);\n }\n for<\/span> (int i = n - 1<\/span>; i > 0<\/span>; i--)\n {\n swap(&arr[0<\/span>], &arr[i]);\n heapify(arr, i, 0<\/span>);\n }\n}\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\nProblem statement<\/strong><\/h2>\n\n\n\nWhen solving a sorting problem, an important step is correctly choosing the data structure and types to use. For this problem, an array was selected as the data structure. The choice of arrays as the data structure is justified and appropriate for this problem for several reasons. First, arrays provide fast access to elements by index (access time to an element is O(1)), which is essential for most sorting algorithms. For example, algorithms like Quick Sort and Merge Sort often use indexing to exchange or compare elements, making arrays convenient for such operations. In addition, arrays are simple to implement and do not require additional memory costs, unlike complex data structures such as trees or graphs.<\/p>\n\n\n\n
Regarding the data type, integers and real numbers were chosen for sorting for several reasons. First, unlike strings, numeric data has a unique order, which makes them ideal for sorting. Comparing numbers is straightforward and efficient, allowing sorting algorithms to work quickly and without the additional time spent processing complex comparisons typical of strings. In the case of string sorting, the comparison involves comparing each character by their ASCII codes or other characteristics, which can be slower than comparing numbers. Moreover, sorting numbers is fundamental to many real-world problems, such as financial data processing, scientific analysis, statistical processing, etc.<\/p>\n\n\n\n
Workflow<\/strong><\/h2>\n\n\n\nThe algorithm for solving the problem includes several stages: generating input data, measuring the execution time of algorithms, counting operations, and plotting.<\/p>\n\n\n\n
\n- Initialization and selection of parameters:\n
\n- Choosing the data type.<\/li>\n\n\n\n
- Choosing the set of input data sizes for testing: 1000, 10000, 100000.<\/li>\n\n\n\n
- Choosing of three sorting algorithms for comparison: Merge Sort, Quick Sort, and Heap Sort.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
- Generating random input data. A random set of numbers is generated using the rand() function for each array size. A random number generator fills the array before starting the time measurement.<\/li>\n<\/ul>\n\n\n\n
For an array of integers, random integers from 0 to 999999 are generated:<\/p>\n\n\n
for (int i = 0; i < size<\/span>; i<\/span>++) {\n self.arrayInteger<\/span>[i<\/span>] = rand()<\/span> % 1000000<\/span>;\n }\n<\/span><\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n\n- Random integers from \u2212999.999 to 999.999 are generated for an array of real numbers. When forming the array, there is a 50% probability that the numbers will be negative.<\/li>\n<\/ul>\n\n\n
clock_t start = clock();\n mergeSort(array<\/span>, 0<\/span>, dataSize - 1<\/span>);\n clock_t end = clock();\n double time_taken = ((double)end - start) \/ CLOCKS_PER_SEC;\n executionTime = time_taken;<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n\n- I use a timer to measure the execution time of each algorithm using the clock() function from the <time.h> library.\u00a0<\/li>\n\n\n\n
- Calculating the average execution time. After collecting the results, the average execution time is calculated for each algorithm, and each array size averageTime = totalTime \/ 15.<\/li>\n<\/ul>\n\n\n\n
Results<\/strong><\/h2>\n\n\n\nThe obtained results of the algorithm execution time (ms *10-4) for integer and real numbers are presented in the table:<\/p>\n\n\n\n
<\/strong>Sort <\/strong><\/td>Array Size<\/strong><\/td><\/td><\/tr> 1000<\/strong><\/td>Real vs Integer<\/strong><\/td>10,000<\/strong><\/td>Real vs Integer<\/strong><\/td>100,000<\/strong><\/td>Real vs Integer<\/strong><\/td><\/tr>Merge Integer<\/strong><\/td>3.1166<\/td> -7.5%<\/td> 38.7986 <\/td> 8.79%<\/td> 269.3200<\/td> 6.4%<\/td><\/tr> Merge Real<\/strong><\/td>2.8826 <\/td> 42.2086<\/td> 286.5833<\/td><\/tr> Heap Integer<\/strong><\/td>4.0786<\/td> 0.99%<\/td> 53.1086<\/td> 5.07%<\/td> 365.6106<\/td> 5.41%<\/td><\/tr> Heap Real<\/strong><\/td>4.1193<\/td> 55.8026<\/td> 385.3926<\/td><\/tr> Quick Integer<\/strong><\/td>2.0666<\/td> 7.9%<\/td> 26.4866<\/td> 7.1%<\/td> 203.3046<\/td> 5.05%<\/td><\/tr> Quick Real<\/strong><\/td>2.2306<\/td> 28.3673<\/td> 213.5746<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nBased on these data, we construct graphs for the operation of algorithms with integers and real numbers:<\/p>\n\n\n\n![\"\"\/](\"https:\/\/lh7-qw.googleusercontent.com\/docsz\/AD_4nXcaMlZraYOfezRXwEytnD5C-VzAb7yyaq2YhNx8TN4HCT0lQJKw-JYQKOG_5qayhj9S1Z5FqHOTzG_HM0PtiiK5K3eaTAwk2Bqx-Zk9kXIVArlkt2vkQNwOBtWwXCoaZt6uN7dglwQ08radFOZ7B8k?key=dVM4EpN2t-Yv-Tj0_Eb2z5ry\")
<\/figure>\n\n\n\nFigure 1 – Running time (ms *10-4) of algorithms for integer numbers\u00a0\u00a0<\/p>\n\n\n\n![\"\"\/](\"https:\/\/lh7-qw.googleusercontent.com\/docsz\/AD_4nXcwakHZpfYNzXwxdULJvccadkKLdmiG60Ao0pDO2bF83Y-DDHjOqgrqvnJsvzcxdcbEEBPlAGKNm9sIAGrNhbPknojWRw7ZIBW4GiMXS_3pyJgu0KlayqL6GG5Dd5PI7kIQeQR1vy0_TXGGn113jeY?key=dVM4EpN2t-Yv-Tj0_Eb2z5ry\")
<\/figure>\n\n\n\nFigure 2 – Running time (ms *10-4) of algorithms for data with real numbers<\/p>\n\n\n\n
The number of exchange results for the same array is always the same. We obtained three different values \u200b\u200bfor each separately generated array type and calculated the average. The obtained average results of the number of exchange operations are presented in the table:<\/p>\n\n\n\n
<\/strong>Sort <\/strong><\/td>Array Size<\/strong><\/td><\/tr>1000<\/strong><\/td>10,000<\/strong><\/td>100,000<\/strong><\/td><\/tr>Merge Integer<\/strong><\/td>1,993<\/td> 19,994<\/td> 199,993<\/td><\/tr> Merge Real<\/strong><\/td>1,993<\/td> 19,994<\/td> 199,993<\/td><\/tr> Heap Integer<\/strong><\/td>9,044<\/td> 124,267<\/td> 1,575,017<\/td><\/tr> Heap Real<\/strong><\/td>9,067<\/td> 124,093<\/td> 1,574,953<\/td><\/tr> Quick Integer<\/strong><\/td>5,800<\/td> 85,827<\/td> 1,075,677<\/td><\/tr> Quick Real<\/strong><\/td>6,677<\/td> 90,721<\/td> 1,087,087<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nMergeSort avoids swaps. MergeSort primarily uses copy operations instead of swaps. It merges elements into a new array, making fewer direct swaps. MergeSort makes fewer swaps because it merges elements rather than swapping them.<\/p>\n\n\n\n
QuickSort and HeapSort require more swaps than MergeSort, with QuickSort being the fastest of the three algorithms and HeapSort being the slowest. QuickSort requires more swaps than MergeSort because QuickSort relies on partitioning by swapping elements. The partitioning step involves swapping elements several times. This increases the total number of swaps. QuickSort is generally faster due to cache efficiency and in-place sorting. <\/p>\n\n\n\n
HeapSort performs more comparisons than QuickSort and requires frequent element moves through heap operations. It sorts in place but has poor cache utilization due to the distributed nature of the heap.<\/p>\n\n\n\n
Conclusions<\/strong><\/h2>\n\n\n\n
void<\/span> merge(int arr[], int left, int mid, int right)\n{\n int n1 = mid - left + 1<\/span>;\n int n2 = right - mid;\n\n\n int L[n1], R[n2];\n\n\n for<\/span> (int i = 0<\/span>; i < n1; i++)\n L[i] = arr[left + i];\n for<\/span> (int j = 0<\/span>; j < n2; j++)\n R[j] = arr[mid + 1<\/span> + j];\n\n\n int i = 0<\/span>, j = 0<\/span>, k = left;\n while<\/span> (i < n1 && j < n2)\n {\n if<\/span> (L[i] <= R[j])\n {\n arr[k] = L[i];\n i++;\n }\n else<\/span>\n {\n arr[k] = R[j];\n j++;\n }\n k++;\n swapCounter++;\n }\n\n\n while<\/span> (i < n1)\n {\n arr[k] = L[i];\n i++;\n k++;\n swapCounter++;\n }\n\n\n while<\/span> (j < n2)\n {\n arr[k] = R[j];\n j++;\n k++;\n swapCounter++;\n }\n}\n\n\nvoid<\/span> mergeSort(int arr[], int left, int right)\n{\n swapCounter = 0<\/span>;\n if<\/span> (left < right)\n {\n int mid = left + (right - left) \/ 2<\/span>;\n\n\n mergeSort(arr, left, mid);\n mergeSort(arr, mid + 1<\/span>, right);\n\n\n merge(arr, left, mid, right); \n }\n}\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\nQuick Sort is one of the most efficient sorting algorithms. Its average time complexity is O(nlogn), but in the worst case, it can be O(n2), which should be considered when evaluating. QuickSort is generally faster than MergeSort and HeapSort, even though the worst-case time complexity is O(n2). QuickSort sorts the array in place, avoiding the need for additional memory like MergeSort.<\/p>\n\n\n
\n\nint swapCounter = 0<\/span>;\n\n\nint partition(int *array<\/span>, int low, int high)\n{\n int pivot = array<\/span>[high];\n int i = (low - 1<\/span>);\n\n\n for<\/span> (int j = low; j < high; j++)\n {\n if<\/span> (array<\/span>[j] <= pivot)\n {\n i++;\n int temp = array<\/span>[i];\n array<\/span>[i] = array<\/span>[j];\n array<\/span>[j] = temp;\n swapCounter++;\n }\n }\n\n\n int temp = array<\/span>[i + 1<\/span>];\n array<\/span>[i + 1<\/span>] = array<\/span>[high];\n array<\/span>[high] = temp;\n swapCounter++;\n return<\/span> (i + 1<\/span>);\n}\n\n\nvoid quickSortExecute(int *array<\/span>, int low, int high)\n{\n if<\/span> (low < high)\n {\n int pi = partition(array<\/span>, low, high);\n quickSortExecute(array<\/span>, low, pi - 1<\/span>);\n quickSortExecute(array<\/span>, pi + 1<\/span>, high);\n }\n}\n\n\nvoid quickSort(int *array<\/span>, int low, int high)\n{\n swapCounter = 0<\/span>;\n quickSortExecute(array<\/span>, low, high);\n}\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\nHeap Sort is an algorithm that uses a data structure called a heap. Its time complexity is also O(nlogn), making it consistently efficient even in the worst case. HeapSort also sorts in place but has more overhead due to tree-based operations.<\/p>\n\n\n
void<\/span> swap(int *a, int *b)\n{\n int temp = *a;\n *a = *b;\n *b = temp;\n swapCounter++;\n}\n\n\nvoid<\/span> heapify(int arr[], int n, int i)\n{\n int largest = i;\n int left = 2<\/span> * i + 1<\/span>;\n int right = 2<\/span> * i + 2<\/span>;\n\n\n if<\/span> (left < n && arr[left] > arr[largest])\n largest = left;\n\n\n if<\/span> (right < n && arr[right] > arr[largest])\n largest = right;\n\n\n if<\/span> (largest != i)\n {\n swap(&arr[i], &arr[largest]);\n heapify(arr, n, largest);\n }\n}\n\n\nvoid<\/span> heapSort(int arr[], int n)\n{\n swapCounter = 0<\/span>;\n for<\/span> (int i = n \/ 2<\/span> - 1<\/span>; i >= 0<\/span>; i--)\n {\n heapify(arr, n, i);\n }\n for<\/span> (int i = n - 1<\/span>; i > 0<\/span>; i--)\n {\n swap(&arr[0<\/span>], &arr[i]);\n heapify(arr, i, 0<\/span>);\n }\n}\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\nProblem statement<\/strong><\/h2>\n\n\n\nWhen solving a sorting problem, an important step is correctly choosing the data structure and types to use. For this problem, an array was selected as the data structure. The choice of arrays as the data structure is justified and appropriate for this problem for several reasons. First, arrays provide fast access to elements by index (access time to an element is O(1)), which is essential for most sorting algorithms. For example, algorithms like Quick Sort and Merge Sort often use indexing to exchange or compare elements, making arrays convenient for such operations. In addition, arrays are simple to implement and do not require additional memory costs, unlike complex data structures such as trees or graphs.<\/p>\n\n\n\n
Regarding the data type, integers and real numbers were chosen for sorting for several reasons. First, unlike strings, numeric data has a unique order, which makes them ideal for sorting. Comparing numbers is straightforward and efficient, allowing sorting algorithms to work quickly and without the additional time spent processing complex comparisons typical of strings. In the case of string sorting, the comparison involves comparing each character by their ASCII codes or other characteristics, which can be slower than comparing numbers. Moreover, sorting numbers is fundamental to many real-world problems, such as financial data processing, scientific analysis, statistical processing, etc.<\/p>\n\n\n\n
Workflow<\/strong><\/h2>\n\n\n\nThe algorithm for solving the problem includes several stages: generating input data, measuring the execution time of algorithms, counting operations, and plotting.<\/p>\n\n\n\n
\n- Initialization and selection of parameters:\n
\n- Choosing the data type.<\/li>\n\n\n\n
- Choosing the set of input data sizes for testing: 1000, 10000, 100000.<\/li>\n\n\n\n
- Choosing of three sorting algorithms for comparison: Merge Sort, Quick Sort, and Heap Sort.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
- Generating random input data. A random set of numbers is generated using the rand() function for each array size. A random number generator fills the array before starting the time measurement.<\/li>\n<\/ul>\n\n\n\n
For an array of integers, random integers from 0 to 999999 are generated:<\/p>\n\n\n
for (int i = 0; i < size<\/span>; i<\/span>++) {\n self.arrayInteger<\/span>[i<\/span>] = rand()<\/span> % 1000000<\/span>;\n }\n<\/span><\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n\n- Random integers from \u2212999.999 to 999.999 are generated for an array of real numbers. When forming the array, there is a 50% probability that the numbers will be negative.<\/li>\n<\/ul>\n\n\n
clock_t start = clock();\n mergeSort(array<\/span>, 0<\/span>, dataSize - 1<\/span>);\n clock_t end = clock();\n double time_taken = ((double)end - start) \/ CLOCKS_PER_SEC;\n executionTime = time_taken;<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n\n- I use a timer to measure the execution time of each algorithm using the clock() function from the <time.h> library.\u00a0<\/li>\n\n\n\n
- Calculating the average execution time. After collecting the results, the average execution time is calculated for each algorithm, and each array size averageTime = totalTime \/ 15.<\/li>\n<\/ul>\n\n\n\n
Results<\/strong><\/h2>\n\n\n\nThe obtained results of the algorithm execution time (ms *10-4) for integer and real numbers are presented in the table:<\/p>\n\n\n\n
<\/strong>Sort <\/strong><\/td>Array Size<\/strong><\/td><\/td><\/tr> 1000<\/strong><\/td>Real vs Integer<\/strong><\/td>10,000<\/strong><\/td>Real vs Integer<\/strong><\/td>100,000<\/strong><\/td>Real vs Integer<\/strong><\/td><\/tr>Merge Integer<\/strong><\/td>3.1166<\/td> -7.5%<\/td> 38.7986 <\/td> 8.79%<\/td> 269.3200<\/td> 6.4%<\/td><\/tr> Merge Real<\/strong><\/td>2.8826 <\/td> 42.2086<\/td> 286.5833<\/td><\/tr> Heap Integer<\/strong><\/td>4.0786<\/td> 0.99%<\/td> 53.1086<\/td> 5.07%<\/td> 365.6106<\/td> 5.41%<\/td><\/tr> Heap Real<\/strong><\/td>4.1193<\/td> 55.8026<\/td> 385.3926<\/td><\/tr> Quick Integer<\/strong><\/td>2.0666<\/td> 7.9%<\/td> 26.4866<\/td> 7.1%<\/td> 203.3046<\/td> 5.05%<\/td><\/tr> Quick Real<\/strong><\/td>2.2306<\/td> 28.3673<\/td> 213.5746<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nBased on these data, we construct graphs for the operation of algorithms with integers and real numbers:<\/p>\n\n\n\n<\/figure>\n\n\n\nFigure 1 – Running time (ms *10-4) of algorithms for integer numbers\u00a0\u00a0<\/p>\n\n\n\n<\/figure>\n\n\n\nFigure 2 – Running time (ms *10-4) of algorithms for data with real numbers<\/p>\n\n\n\n
The number of exchange results for the same array is always the same. We obtained three different values \u200b\u200bfor each separately generated array type and calculated the average. The obtained average results of the number of exchange operations are presented in the table:<\/p>\n\n\n\n
<\/strong>Sort <\/strong><\/td>Array Size<\/strong><\/td><\/tr>1000<\/strong><\/td>10,000<\/strong><\/td>100,000<\/strong><\/td><\/tr>Merge Integer<\/strong><\/td>1,993<\/td> 19,994<\/td> 199,993<\/td><\/tr> Merge Real<\/strong><\/td>1,993<\/td> 19,994<\/td> 199,993<\/td><\/tr> Heap Integer<\/strong><\/td>9,044<\/td> 124,267<\/td> 1,575,017<\/td><\/tr> Heap Real<\/strong><\/td>9,067<\/td> 124,093<\/td> 1,574,953<\/td><\/tr> Quick Integer<\/strong><\/td>5,800<\/td> 85,827<\/td> 1,075,677<\/td><\/tr> Quick Real<\/strong><\/td>6,677<\/td> 90,721<\/td> 1,087,087<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nMergeSort avoids swaps. MergeSort primarily uses copy operations instead of swaps. It merges elements into a new array, making fewer direct swaps. MergeSort makes fewer swaps because it merges elements rather than swapping them.<\/p>\n\n\n\n
QuickSort and HeapSort require more swaps than MergeSort, with QuickSort being the fastest of the three algorithms and HeapSort being the slowest. QuickSort requires more swaps than MergeSort because QuickSort relies on partitioning by swapping elements. The partitioning step involves swapping elements several times. This increases the total number of swaps. QuickSort is generally faster due to cache efficiency and in-place sorting. <\/p>\n\n\n\n
HeapSort performs more comparisons than QuickSort and requires frequent element moves through heap operations. It sorts in place but has poor cache utilization due to the distributed nature of the heap.<\/p>\n\n\n\n
Conclusions<\/strong><\/h2>\n\n\n\n