Efficient Large-Scale Data Processing in C: An Experimental Study of Algorithmic and Memory Performance

Authors

Shubham Alria ORCID icon for Shubham Alria

Bachelor of technology in Computer Science and Engineering, CGC University Mohali (India)

Article Information

DOI: 10.51244/IJRSI.2026.1310000207

Subject Category: Computers

Volume/Issue: 13/10 | Page No: 5139-5154

Publication Timeline

Submitted: 2026-09-23

Accepted: 2026-09-28

Published: 2026-11-16

Abstract

Efficient processing of large-scale datasets requires careful consideration of algorithmic efficiency, execution time, and memory utilisation as data volume increases. This study experimentally evaluates four classical sorting algorithms—Quick Sort, Merge Sort, Heap Sort, and Insertion Sort—implemented in the C programming language. The algorithms are examined across increasing dataset sizes and four input patterns: random, sorted, reverse-sorted, and nearly sorted data. A controlled experimental framework is used to compare execution time, memory consumption, throughput, scalability, and time–memory trade-offs under consistent implementation and measurement conditions. The results demonstrate clear differences in performance as dataset size and input organisation change. Quick Sort provides the strongest speed-oriented performance under random input, while Merge Sort exhibits higher memory requirements because of its auxiliary storage. Heap Sort maintains low additional-memory requirements but generally requires more execution time than Quick Sort. Insertion Sort performs efficiently on ordered data but becomes increasingly costly as dataset size increases under disordered input. The findings demonstrate that practical algorithm selection should consider execution time, memory requirements, throughput, scalability, and workload characteristics rather than relying on execution time alone.

Keywords

C Programming, Large-Scale Data Processing, Algorithm Performance, Memory Efficiency, Sorting Algorithms, Computational Performance, Scalability

Downloads

References

1. Ala’anzy, M. A., Tolendi, N., Baubek, B., & Algarni, A. (2026). Performance evaluation of GPU-based parallel sorting algorithms. PLOS ONE, 21(2), e0342167. https://doi.org/10.1371/journal.pone.0342167 [Google Scholar] [Crossref]

2. Aho, A. V., Lam, M. S., Sethi, R., & Ullman, J. D. (2006). Compilers: Principles, techniques, and tools (2nd ed.). Pearson. [Google Scholar] [Crossref]

3. Bingmann, T., Marianczuk, J., & Sanders, P. (2021). Engineering faster sorters for small sets of items. Software: Practice and Experience, 51(5), 965–1004. https://doi.org/10.1002/spe.2922 [Google Scholar] [Crossref]

4. Blelloch, G. E., Leiserson, C. E., Maggs, B. M., Plaxton, C. G., Smith, S. J., & Zagha, M. (1998). An experimental analysis of parallel sorting algorithms. Theory of Computing Systems, 31(2), 135–167. https://doi.org/10.1007/s002240000083 [Google Scholar] [Crossref]

5. Bryant, R. E., & O’Hallaron, D. R. (2016). Computer systems: A programmer’s perspective (3rd ed.). Pearson. [Google Scholar] [Crossref]

6. Codish, M., Bundala, D., Cruz-Filipe, L., Schneider-Kamp, P., & Závodný, J. (2017). Optimal-depth sorting networks. Journal of Computer and System Sciences, 84, 185–204. [Google Scholar] [Crossref]

7. https://doi.org/10.1016/j.jcss.2016.09.004 [Google Scholar] [Crossref]

8. Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to algorithms (3rd ed.). MIT Press. [Google Scholar] [Crossref]

9. Fogli, A., Pietzuch, P., & Giceva, J. (2024). Optimizing sorting for chiplet-based CPUs. In Proceedings of the 15th International Workshop on Accelerating Analytics and Data Management Systems Using Modern Processor and Storage Architectures (ADMS 2024). VLDB Endowment. [Google Scholar] [Crossref]

10. Frigo, M., Leiserson, C. E., Prokop, H., & Ramachandran, S. (1999). Cache-oblivious algorithms. In Proceedings of the 40th Annual Symposium on Foundations of Computer Science (pp. 285–297). IEEE. https://doi.org/10.1109/SFFCS.1999.814600 [Google Scholar] [Crossref]

11. Georges, A., Buytaert, D., & Eeckhout, L. (2007). Statistically rigorous Java performance evaluation. ACM SIGPLAN Notices, 42(10), 57–76. https://doi.org/10.1145/1297027.1297033 [Google Scholar] [Crossref]

12. Hennessy, J. L., & Patterson, D. A. (2019). Computer architecture: A quantitative approach (6th ed.). Morgan Kaufmann. [Google Scholar] [Crossref]

13. Hoare, C. A. R. (1962). Quicksort. The Computer Journal, 5(1), 10–15. [Google Scholar] [Crossref]

14. https://doi.org/10.1093/comjnl/5.1.10 [Google Scholar] [Crossref]

15. Islam, M. S., Halder, P., Rahman, S. R., Shakil, S., Kamarudin, N. S., Zaman, O., Islam, M. S., & Al Mamun, M. A. (2026). Cross-language evaluation of sorting algorithms on various input patterns: A comparative study. Journal of Computer Languages, 87, 101397. [Google Scholar] [Crossref]

16. https://doi.org/10.1016/j.cola.2026.101397 [Google Scholar] [Crossref]

17. Kernighan, B. W., & Ritchie, D. M. (1988). The C programming language (2nd ed.). Prentice Hall. [Google Scholar] [Crossref]

18. Knuth, D. E. (1998). The art of computer programming, Volume 3: Sorting and searching (2nd ed.). Addison-Wesley. [Google Scholar] [Crossref]

19. LaMarca, A., & Ladner, R. E. (1999). The influence of caches on the performance of sorting. Journal of Algorithms, 31(1), 66–104. https://doi.org/10.1006/jagm.1998.0985 [Google Scholar] [Crossref]

20. McIlroy, M. D. (1999). A killer adversary for quicksort. Software: Practice and Experience, 29(4), 341–344. https://doi.org/10.1002/(SICI)1097-024X(19990410)29:4<341::AID-SPE237>3.0.CO;2-R [Google Scholar] [Crossref]

21. Nyberg, C., Barclay, T., Cvetanovic, Z., Gray, J., & Lomet, D. B. (1995). AlphaSort: A cache-sensitive parallel external sort. The VLDB Journal, 4(4), 603–627. [Google Scholar] [Crossref]

22. Polychroniou, O., & Ross, K. A. (2014). A comprehensive study of main-memory partitioning and its application to large-scale comparison- and radix-sort. In Proceedings of the 2014 ACM SIGMOD International Conference on Management of Data (pp. 755–766). ACM. [Google Scholar] [Crossref]

23. https://doi.org/10.1145/2588555.2610522 [Google Scholar] [Crossref]

24. Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Addison-Wesley Professional. [Google Scholar] [Crossref]

25. Szefer, J. (2015). Leveraging processor performance counters for security and performance. In Proceedings of the 5th International Workshop on Trustworthy Embedded Devices (TrustED ’15) (p. 41). Association for Computing Machinery. https://doi.org/10.1145/2808414.2808421 [Google Scholar] [Crossref]

26. Xiao, L., Zhang, X., & Kubricht, S. A. (2000). Improving memory performance of sorting algorithms. ACM Journal of Experimental Algorithmics, 5, Article 3. https://doi.org/10.1145/351827.384245 [Google Scholar] [Crossref]

Metrics

Views & Downloads

Similar Articles