International Journal of Computer Science Trends and Technology (IJCST) – Volume 11 Issue 4, Jul-Aug 2023

RESEARCH ARTICLE OPEN ACCESS

Impact of Language on Sorting Algorithms: An Empirical Study

Nishita Raghavendra [1], Manushree Shah [2]
[1]
Student, Choithram School, Manik Bagh, Indore, Madhya Pradesh
[2]
B.Sc. (Hons), NMIMS University Navi Mumbai, Maharashtra

ABSTRACT
This research paper presents a comprehensive comparative analysis of sorting and searching algorithm execution speed in
three prominent programming languages: Python and Java. The study aims to assess the impact of language choice on the
performance of these fundamental operations, which are crucial in numerous applications and algorithms. The research
involves conducting experiments with representative datasets and implementing well-known algorithms. Bubble Sort, Quick
Sort, and Merge Sort algorithms were utilized for sorting, while Binary Search and Linear Search algorithms were employed
for searching. Execution times were measured and compared across the three languages. The findings reveal noteworthy
variations in execution speed among the sorting and searching algorithms in the three programming languages. The research
further explores the contributing factors behind these differences, including language features, memory allocation, and
compiler optimization techniques. It addresses potential limitations and implications of the findings, emphasizing the
significance of considering language performance when choosing an appropriate programming language for sorting and
searching tasks. Overall, this study provides valuable insights into the performance characteristics of sorting and searching
algorithms in Python and Java, enabling researchers and practitioners to make informed decisions regarding language
selection for efficient execution of these fundamental operations in diverse software applications.
Keywords: searching, sorting, execution, compiler, programming.

I. INTRODUCTION
Searching and sorting are fundamental operations in
computer science and play a crucial role in various
applications and algorithms. Both searching and sorting
are essential tasks performed on data sets to organize and
retrieve information efficiently. Understanding these
operations and their performance characteristics is vital for
developing efficient algorithms and optimizing software
systems.
Searching refers to the process of finding a specific
element or value within a given data set. It involves
systematically examining the data to locate the desired
item. Searching algorithms, such as Binary Search and
Linear Search, are widely used to efficiently locate
elements in both ordered and unordered data sets. The
choice of a suitable searching algorithm depends on factors
such as the data set's size, order, and search requirements.
On the other hand, sorting involves arranging a collection
of elements in a specific order, such as numerical or
alphabetical. Sorting algorithms rearrange the elements in
a systematic manner, making it easier to search, analyze,
and process the data. Various sorting algorithms exist,
including Bubble Sort, Quick Sort, Merge Sort, and many
others, each with its own advantages and performance
characteristics. The choice of a sorting algorithm depends
on factors such as the size of the data set, the initial order
of the elements, and the desired time complexity.
Efficient searching and sorting algorithms are crucial for
improving the performance of numerous applications, such
as databases, information retrieval systems, computational
biology, and network routing. The execution speed and
efficiency of these algorithms depend on various factors,
including the choice of programming language, the
algorithm's design and implementation, and the
characteristics of the data set.
In this research paper, we aim to compare the execution
speed of searching and sorting algorithms across three
prominent programming languages: Python, and Java. By
evaluating and analysing the performance of these
algorithms in different languages, we can gain insights into
the impact of language choice on the efficiency of these
fundamental operations. This knowledge will enable
researchers and practitioners to make informed decisions
when selecting the most appropriate language for their
specific searching and sorting requirements.
II. LITERATURE REVIEW
[1] In the paper, the author surveyed and categorized the
metadata required for a diverse set of Stanford Digital
Library services that they have built. Their metadata

ISSN: 2347-8578 www.ijcstjournal.org Page 44

 International Journal of Computer Science Trends and Technology (IJCST) – Volume 11 Issue 4, Jul-Aug 2023
architecture fits into their established infrastructure and
promotes interoperability among existing and de-facto
metadata standards. Several pieces of the architecture are
implemented; others are under construction. The
architecture includes attribute model proxies, attribute
model translation services, metadata information facilities
for search services, and local metadata repositories.
Together, these components provide, exchange, and
describe metadata for information objects and metadata for
information services.
[2]. Author mentions that over the past several years, they
have analyzed the error-handling designs of a variety of
critical applications and have discovered serious defects
even in well-tested and mature systems. In the paper, they
describe specific recurring patterns of error handling
defects which have been observed in critical systems. It
seems clear that the design, implementation, and testing of
error handling are often not given adequate attention and
resources.
[3]. In this paper explains that recent progress in cognitive
computing suggests that we might approach the point
when the algorithmic principles of brain-like computing
will be revealed and the study, design and realization of
thinking machines will start to be an issue in computer
science. For this purpose, the author presents a brief
overview of related results from a machine-oriented
complexity theory.
[4]. The book of Z. Michalewicz has an important message
that is also reflected in the title. Namely, it advocates the
modem view that, regardless to representationdata
structures), a problem solver can be seen as ‘evolutionary’
if it is based on the basic reproduction-selection cycle
genetic algorithms).
[5].Author has compared Python and Java languages and
each of the two languages taken into account in this
analysis has advantages and disadvantages specific to that
field. The claim that one of them is superior to the other
cannot be made with certainty. Although Java's structure is
a little more complicated than Python's, it offers a better
grasp of memory management and is safer. Python is a
small, easy language. Python programs are written in plain
English, making them simple enough for a beginner to
grasp. Python's code is easier to read because indentation
is required. But with Java, indentation has no effect and
the entire program can be written in a single line to make it
appear shorter. Java is statically typed, so the precise
datatype for variables is known during compilation,
leading to faster execution than Python, whereas Python is
ISSN: 2347-8578 www.ijcstjournal.org
dynamically typed, so the variable type is checked during
run time.
[6]. C, C++, java, perl, python, rexx and tcl were compared
in this study. Although Java still has a significant memory
overhead when compared to C or C++ as of JDK 1.2.1
(and on the Solaris platform), the run-time efficiency has
improved to an acceptable level. Even for applications
requiring a good degree of computation and data handling,
the frequently used "scripting languages" Perl, Python,
Rexx, and Tcl can be viable alternatives to "conventional"
languages like C or C++. At least for tiny programmes like
the phone code problem, their relative run time and
memory consumption overhead will frequently be
acceptable, and they may give considerable benefits in
terms of programmer productivity. A change in
programming language tends to account for fewer
variances between programs than interpersonal variability,
which is the capacity and behaviour differences amongst
programmers using the same language.
[7].Authors discusses about the impact on the memory of a
system due to programs with large datasets. A significant
performance bottleneck might occur from the subsequent
input/output communication, or I/O, between fast internal
memory and slower external memory (such discs).
III. EXPERIMENTAL SETUP
The experimental setup involved comparing the
performance of two popular programming languages:
Python and Java. Both languages were chosen due to their
widespread usage and their capabilities in handling
searching and sorting operations.
The experimental set up was conducted on a suitable
device for both the languages.
A. Searching Operations: The experiments included two
commonly used searching algorithms: linear search and
binary search. These algorithms were implemented
separately in both Python and Java.
Linear search is a basic searching algorithm that
sequentially checks each element in a given list or array
until the target value is found or the end of the list is
reached. It is a simple yet inefficient algorithm for large
datasets since it has a time complexity. However, it is
suitable for small or unsorted lists where the elements are
accessed sequentially. Linear search is easy to understand
and implement, making it a common choice for simple
search operations, hence we included it in our experiment.
Binary search is a more efficient searching algorithm that
is applicable to sorted lists or arrays. It follows a divide-
Page 45
 International Journal of Computer Science Trends and Technology (IJCST) – Volume 11 Issue 4, Jul-Aug 2023
and-conquer approach by repeatedly dividing the search
space in half until the target value is found. Binary search
has a time complexity, making it highly efficient for large
datasets. However, it requires the input to be sorted
beforehand. Binary search is widely used in various
applications where efficient search operations are required,
such as in searching databases or in certain data structures
like balanced binary trees. It is more efficient than linear
search in a lot of aspects.
B. Sorting Operations: The experiments involved
implementing three popular sorting algorithms: quick sort,
merge sort, and bubble sort. Each algorithm was
implemented in both Python and Java.
Quick sort is a popular sorting algorithm known for its
efficiency and simplicity. It follows a divide-and-conquer
approach, where it partitions the array based on a chosen
pivot element and recursively sorts the sub-arrays on either
side of the pivot. Quick sort has an average time
complexity, making it one of the fastest sorting algorithms.
It is widely used in various applications due to its excellent
average-case performance, but it can have a worst-case
time complexity in certain scenarios.
Merge sort is a stable and efficient sorting algorithm that
also employs the divide-and-conquer strategy. It
recursively divides the input array into smaller sub-arrays,
sorts them individually, and then merges them back
together to produce a sorted result. Merge sort has a
consistent time complexity in all cases, making it suitable
for large datasets. Although it requires additional space for
merging the sub-arrays, merge sort is widely used due to
its reliable performance and ease of implementation.
Bubble sort is a simple and straightforward sorting
algorithm that repeatedly compares adjacent elements and
swaps them if they are in the wrong order. It proceeds by
bubbling up the largest elements to the end of the array in
each pass until the entire array is sorted. Bubble sort has a
time complexity, making it inefficient for large datasets. It
is primarily used for educational purposes or for sorting
small, nearly sorted arrays due to its simplicity. However,
due to its poor performance, it is rarely used in practical
applications.
We have also used three scenarios in searching operations
to make it more efficient to be interpreted: best case, worst
case and average case.
The best-case scenario represents the most favourable or
optimal situation for an algorithm. It occurs when the input
data is in the best possible order or when the algorithm
encounters the easiest-to-process elements. The best-case
ISSN: 2347-8578 www.ijcstjournal.org
scenario provides an understanding of the lower bounds of
an algorithm's performance and is used to determine the
best-case time complexity.
The average case scenario refers to the expected
performance or behavior of an algorithm when it is
executed on typical or randomly generated inputs. It takes
into account the distribution of inputs and provides an
estimate of how the algorithm is likely to perform on
average. The average case scenario is often used to
evaluate the efficiency or time complexity of an algorithm.
The worst-case scenario represents the least favourable or
most challenging situation for an algorithm. It occurs when
the input data is in the worst possible order or when the
algorithm encounters the most difficult-to-process
elements. The worst-case scenario helps establish the
upper bounds of an algorithm's performance and is used to
determine the worst-case time complexity. It provides
insight into how an algorithm might perform in the most
unfavourable conditions. Dataset for both the
programming languages were the same, and generated in
the code itself
IV. RESULTS
The purpose of this study was to compare the efficiency of
searching and sorting operations between Python and Java,
two widely-used programming languages. The goal was to
determine which language is more suitable for performing
these tasks and provide recommendations based on the
findings.
To assess the performance, we conducted a series of
experiments and collected data on the execution time for
both operations. The data was analysed and summarised in
Table 1 below:
The results of the experiments indicate a notable difference
in execution speed between Python and Java across
various programs. In the best case scenarios, Python
demonstrated significantly faster execution times
compared to Java. For example, the execution time for
linear search in Python was 0.001186370849609375 ns,
whereas in Java it was considerably slower at 17954700
ns: even in the average case the difference was quite
visible as python require only 0.0019953250885009766 ns
whereas Java required 2069500 ns . Similarly, the binary
search in Python executed in 0.00099873542-78564453 ns,
while Java took substantially longer at 535300 ns in the
best case. As we look over the worst and average cases we
see a similar pattern with python at
0.0009953975677490234 ns with 0.000995635986328125
ns and Java at 172500 ns with 575100 ns.
Page 46
 International Journal of Computer Science Trends and Technology (IJCST) – Volume 11 Issue 4, Jul-Aug 2023

In each scenario, Java's execution times were consistently -ribute Time), ns Time)
slower than Python. This is evident from the data, as the
worst-case execution times for linear and binary search in 1 Linear Best 0.0011863 17954700
Python were 0.0009970664978027344 and Search Case 708496093
0.000995397567 7490234 ns, respectively. In contrast, Scenari 75
Java's worst-case execution times were much higher at o
3574500 and 172500 ns for linear and binary search, 2 Linear Worst 0.0009970 3574500
respectively. These findings provide clear evidence Search case 664978027
supporting the analysis stated above. Scenari 344
o
In summary, the experimental results demonstrate that
Python consistently outperformed Java in terms of 3 Linear Averag 0.0015938 1755700
execution speed across the evaluated programs, including Search e Case 282012939
linear and binary search. These findings underscore the Scenari 453
superior performance of Python compared to Java for these o
specific operations.
4. Binary Best 0.0009987 535300
These findings suggest that Python is more efficient in Search Case 354278564
terms of operations when compared to Java. The observed Scenari 453
differences in execution time may be attributed to various o
factors, including differences in language design,
5. Binary Worst 0.0009953 172500
optimization techniques, and underlying algorithms. Search Case 975677490
Upon examining the sorting algorithms, a similar pattern Scenari 234
emerges, reaffirming the superiority of Python over Java in o
terms of speed. In the best-case scenarios, Python 6. Binary Averag 0.0009956 575100
exhibited significantly faster execution times in quick sort, Search e Case 359863281
merge sort, and bubble sort, with times of Scenari 25
0.0019969940185546875, 0.006139278411865234, and o
0.003048181533 8134766 ns, respectively. In contrast,
Java lagged behind considerably, with execution times of 7. Quick Best 0.0019969 13945400
Sort Case 940185546
13945400, 5069500, and 5427200 milliseconds for the
Scenari 875
respective sorting algorithms. o
Considering the worst-case scenario as well there was a
8. Quick Worst 0.0009980 22669500
similarity in our observations as Python was at
Sort Case 201721191
0.0009980201721191406, 0.0670239925 3845215 and Scenari 406
0.012440204 620361328 ns. Contrarily Java was once o
again slower with 22669500, 6963800 and 5461800 ns.
9. Merge Best 0.0061392 5069500
Further analysis of the data in the table reinforces this Sort Case 784118652
trend, as it becomes evident that Python consistently Scenari 34
outperforms Java across different scenarios. Whether o
considering the average case or best case, Python
consistently exhibits faster execution times than Java. 10. Merge Worst 0.0670239 6963800
Sort Case 925384521
In summary, the findings regarding sorting operations Scenari 5
align with the results obtained for searching. Python o
demonstrates superior performance over Java, showcasing
faster execution times across various; scenarios and sorting 11. Bubble Best 0.0030481 5427200
Sort Case 815338134
algorithms.
Scenari 766
Table -1: Analysis of execution speed
o
SL. ALGO- Parame PYTHON JAVA
NO RITHM ters/Att (Execution (Execution

ISSN: 2347-8578 www.ijcstjournal.org Page 47

 International Journal of Computer Science Trends and Technology (IJCST) – Volume 11 Issue 4, Jul-Aug 2023

12. Bubble Worst 5461800 [5]. Khoirom, S., Sonia, M., Laikhuram, B.,
Sort case 0.0124402 Laishram, J., & Singh, T. D. (2020).
Scenari 046203613 Comparative analysis of Python and Java for
o 28 beginners. Int. Res. J. Eng. Tec hnol, 7(8), 4384-4407.
[3] Parkvall, S.; Astely, D., “The Evolution of
LTE towards IMT-Advanced”, Journal of
VI. CONCLUSION communications, Vol. 4, No. 3, 2009.
In conclusion, the comparative analysis of searching and
sorting operations between Python and Java demonstrates [6]. Prechelt, L. (2000). An empirical comparison
of c, c++, java, perl, python, rexx and tcl. IEEE
that Python outperforms Java in terms of execution speed.
Computer, 33(10), 23-29.
The experimental results consistently show that Python
exhibits faster execution times across various scenarios,
[7]. Vitter, J. S. (2001). External memory
including both searching and sorting tasks. Whether algorithms and data structures: Dealing with
examining best, worst, or average case scenarios, Python massive data. ACM Computing surveys (CsUR), 33(2),
consistently proves to be more efficient than Java. 209-271.

These findings suggest that Python is a more suitable Authors’ Profile

language for performing searching and sorting operations,
providing a compelling recommendation for its usage in
these contexts. The observed differences in execution Nishitha Raghavendra is a
times can be attributed to various factors, such as language student of grade 12 , in
design, optimization techniques, and underlying Choithram school, Manik
algorithms. bagh, Indore, and she is a
science stream students
Overall, this research highlights the superior performance doing specialization in
of Python over Java in terms of speed and efficiency for computer science along with
searching and sorting tasks. These findings can inform mathematics, physics and
developers and programmers in choosing the appropriate chemistry as the majors.
programming language for such operations, ultimately She has a special interest in exploring various machine
leading to improved performance and productivity. learning and artificial intelligence along with the
programming and astrophysics . At present she is
VIII. REFERENCES preparing for various engineering entrance exams
[1]. Baldonado, M., Chang, C.-C.K., Gravano, L., along with her project work in AI and ML.
Paepcke, A.: The Stanford Digital Library Metadata
Architecture. Int. J. Digit. Libr. 1 (1997) 108–121
Manushree Shah is a second-year student at NMIMS
[2]. Bruce, K.B., Cardelli, L., Pierce, B.C.: University, Navi Mumbai, pursuing her Bachelors in
Comparing Object Encodings. In: Abadi, M., Ito, T. Science (Honors) in Artificial Intelligence. She is a
(eds.): Theoretical Aspects of Computer Software. highly motivated and enthusiastic student with a
Lecture Notes in Computer Science, Vol. 1281. profound passion for technology and statistics.
Springer-Verlag, Berlin Heidelberg New York (1997) Fascinated by the endless possibilities offered by
415–438 technology, she is exploring deep into the realms of
[3]. Van Leeuwen, J. (ed.): Computer Science programming, data
analysis, and machine
Today. Recent Trends and Developments. Lecture
Notes in Computer Science, Vol. 1000. Springer- learning.
Verlag, Berlin Heidelberg New York (1995)
[4]. Michalewicz, Z.: Genetic Algorithms + Data
Structures = Evolution Programs. 3rd edn. Springer-
Verlag, Berlin Heidelberg New York (1996)

ISSN: 2347-8578 www.ijcstjournal.org Page 48