AlgoStruct

Overview

AlgoStruct is a Spring Boot project meticulously developed as a personal portfolio to demonstrate a robust understanding of fundamental and advanced computer science concepts. This project serves as a practical showcase of skills acquired during the Higher Diploma in Computer Science, with a particular emphasis on algorithms, data structures, and web application architecture. It is intended to provide potential recruiters with a clear and comprehensive view of my technical capabilities and commitment to continuous learning.

Core Areas of Exploration

• Data Structures and Algorithms: In-depth implementation and analysis of various data structures (e.g., linked lists, trees, hash tables) and algorithmic paradigms, including search, sorting, graph traversal, and dynamic programming. This section is currently under active development, focusing on practical challenges and their efficient solutions in Java, exposed through web controllers.
• Advanced Algorithms: Implementation of sophisticated algorithmic techniques beyond basic sorting and searching, demonstrating problem-solving abilities and efficiency considerations, accessible via web controllers.
• Web Application Architecture: Exploration of web application architecture within the Spring Boot framework, focusing on the Model-View-Controller (MVC) pattern and the use of Thymeleaf for dynamic content rendering to interact with the implemented functionalities.

Current Development Focus: Data Structures and Algorithms

This project serves as a platform to explore and implement various concepts in computer science. Currently, the application allows users to generate a specified quantity of random numbers and then sort these numbers using a selection of common sorting algorithms. The performance of these algorithms is then visualized through a chart.

As part of an ongoing commitment to professional growth, I am now expanding this project to include the study and practical implementation of fundamental data structures and search algorithms, as well as basic array analysis. The goal is to build a strong foundation and demonstrate the ability to translate theoretical knowledge into functional code accessible through a web interface. The implementation will follow a gradual approach, starting with fundamental concepts and progressively tackling more complex challenges as part of a continuous learning process.

Implemented Features:

• Random Number Generation: Users can input the desired quantity of random numbers to be generated.

• Sorting Algorithms: Implementation and execution of the following sorting algorithms:

  • Tim Sort (leveraging Java's Arrays.sort)
  • Bubble Sort
  • Insertion Sort
  • Selection Sort

• Performance Visualization: The execution time of the selected sorting algorithms is displayed and visualized using a bar chart.

• Search Algorithms:

  • Linear Search: This is a foundational search algorithm involving a sequential traversal of an array to locate a target value. It is integrated with a Spring Boot web controller, enabling user input and result display.

  • Array Analysis:

    • Find Minimum and Maximum Identifies and displays the smallest and largest elements within the generated array.
    • Check for Duplicates: Determines if the generated array contains any duplicate elements.

• Singly Linked List (Basic Operations):

  • Allows the user to insert integer values at the end of the linked list.
  • Allows the user to insert integer values at the beginning of the linked list.
  • Displays the current contents of the linked list.

In Development:

• Singly Linked List (Basic Operations):
  • Implementing the functionality that provides a count of the number of elements in the linked list.
  • Implementing the functionality to delete the first node from the linked list.

Upcoming Learning and Implementation Areas:

This project will continue to evolve with the implementation of various data structures and algorithms, gradually increasing in complexity. Future areas of focus will include, but are not limited to:

• Fundamental data structures such as linked lists, stacks, and queues.
• Basic and advanced sorting algorithms have not yet been implemented (e.g., Merge Sort and Quick Sort).
• Tree-based data structures and algorithms.
• Graph-based data structures and algorithms.
• Other relevant algorithmic techniques.

The specific challenges and their order of implementation will be determined as part of this continuous learning process. Implemented features will be reflected in the sections above.

Technologies

• Spring Boot
• Thymeleaf
• Maven
• Heroku

Demonstration

The live application is hosted on Heroku and can be accessed at: https://algo-struct-be23b0a0fa35.herokuapp.com/

Currently, the application showcases the generation of random numbers and their sorting using the available algorithms, with visual representation of the execution times. The Linear Search functionality is also implemented, allowing users to search for a specific number within the generated array. The functionality to find the minimum and maximum elements in the generated array is currently under development and will be integrated into the "Output" section of the Linear Search page. As new data structures and algorithms are implemented, their interactive demonstrations will be integrated into the web interface, providing a hands-on way to explore their functionality. Updates on how to specifically test new features will be provided in the "Current Development" section.

Author

• Sérgio Oliveira, +353 86 272 1772
• oliveira-sergio@outlook.com

Academic Information

• Course: Higher Diploma in Computer Science
• Institution: National College of Ireland
• Year of Completion: 2024