https://github.com/jonperk318/searching-algorithms

Comparing the efficiencies of linear, binary, and ternary searching algorithms in Python, Java, C++, and JavaScript
https://github.com/jonperk318/searching-algorithms

binary-search cpp css file-io graphjs html java javascript js linear-search python ternary-search webpack

Last synced: 9 days ago
JSON representation

Comparing the efficiencies of linear, binary, and ternary searching algorithms in Python, Java, C++, and JavaScript

• Host: GitHub
• URL: https://github.com/jonperk318/searching-algorithms
• Owner: jonperk318
• License: mit
• Created: 2024-06-08T04:49:18.000Z (7 months ago)
• Default Branch: main
• Last Pushed: 2024-09-02T04:41:09.000Z (4 months ago)
• Last Synced: 2024-11-06T05:18:51.297Z (about 2 months ago)
• Topics: binary-search, cpp, css, file-io, graphjs, html, java, javascript, js, linear-search, python, ternary-search, webpack
• Language: C++
• Homepage: https://jonperk318.github.io/searching-algorithms/
• Size: 29.6 MB
• Stars: 1
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# Searching Algorithms in Four Languages

Comparing the efficiencies of searching algorithms implemented 

in four programming languages: Python, Java, C++, and JavaScript.

Results: https://jonperk318.github.io/searching-algorithms/

## How to Use

Languages and packages used:

* Python 3.12.2

* Java 21.0.1

* C++ Apple Clang 15.0.0 (clang-1500.3.9.4)

* JavaScript Node 20.15.0

* * webpack-cli 5.1.4

First, run `./samples/sample_generator.py` to generate 50 sample arrays of logarithmically-spaced sizes from

100 to 1,000,000, each containing randomly-generated integers ranging from 1 to 1,000,000. These arrays are outputted 

into text files along with `./samples/sample-sizes.txt`, which contains the array sizes.

Second, run the following four main functions each utilizing three searching algorithms (with three trials each) 

implemented in their respective languages:

* `./python-algorithms/main.py`

* `./java-algorithms/src/Main.java`

* `./cpp-algorithms/main.cpp`

* `./javascript-algorithms/main.js`

These each generate text files containing the searching times for each algorithm.

Third, run `./src/result-loader.js` to convert these results into `./dist/results.js`, using a format readable by 

`./dist/main.js`. To generate this file, run `npx webpack` in the root directory.

## Results

The first four sections show all searching algorithms in one of four languages. The y-axis 

of each graph is scaled logarithmically.

In Python, Java, and JavaScript, linear search with a random key and with the key not found performed similarly, 

and both were the slowest. Linear search performs better than the other algorithms when the key was the first element 

in the array, while binary search and ternary search performed similarly whether the key was the first element, random

integer potentially present in the array, or an integer not present.

![demo-1.gif](src/demo-1.gif)

Python and C++ were the slowest languages, while Java and JavaScript performed the best.

JavaScript had the fastest times for larger arrays on all algorithms except for merge sort, 

and Java came in second on several others. It is unclear why C++ performed so poorly compared to the other languages 

which are less optimized for speed, but perhaps this is a memory allocation issue. The issue will be further explored 

to provide more accurate results.

![demo-2.gif](src/demo-2.gif)

## Sources

This project was inspired by:

* The searching algorithms demonstrated in multiple languages on GeeksforGeeks:

  https://www.geeksforgeeks.org/searching-algorithms/

* A sorting benchmark project by Ilya Frolov:

  https://github.com/frolovilya/sorting-benchmark/