AlgoVista is a premium, high-performance Desktop Application built with JavaFX, designed to transform abstract Data Structures and Algorithms (DSA) into immersive, cinematic visual experiences.
Whether you are a student mastering the basics or a developer revisiting core concepts, AlgoVista provides an interactive environment to see logic in motion.
- Sleek UI/UX: Modern dark-mode interface with smooth transitions and hover effects.
- Interactive Navigation: Seamlessly jump between different algorithm categories.
- Global Controls: Adjust animation speeds in real-time to match your learning pace.
- Sorting Algorithms: Visualize Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, Quick Sort, Radix Sort, and more.
- Graph Theory: Interactive BFS, DFS, Dijkstra’s (Shortest Path), and Topological Sorting.
- Dynamic Programming: Step-through visualizations for Fibonacci, Knapsack, and Longest Common Subsequence (LCS).
- Data Structures: Real-time manipulation of Linked Lists (Singly/Doubly), Binary Search Trees (BST), Heaps, Stacks, and Queues.
- Divide & Conquer: Visual execution of Merge Sort, Quick Sort, and Binary Search.
- Complexity Analysis: Dynamic detection of Best, Worst, and Average case time complexities.
- Code Highlighting: Synchronized source code highlighting that tracks the visualization step-by-step.
- State Management: Ability to pause, resume, and reset visualizations at any time.
Experience a premium startup sequence and a centralized command center.
AlgoVista is designed with the user in mind, featuring deep customization and a dedicated team overview.
Every algorithm category is represented by a stunning, interactive card system, ordered as they appear in the dashboard.
| Linked List | Graph | Binary Search Tree | Sorting |
|---|---|---|---|
 |
 |
 |
 |
| Recursion | Divide & Conquer | Dynamic Programming |
|---|---|---|
 |
 |
 |
Visualizing LIFO, FIFO, and linear data manipulation with precision.
Gateway to the Linear Data Structures module.
-
Doubly Linked List Traversal:
Forward traversal through a Doubly Linked List, highlighting the current node and its pointers. -
Stack Operations:
Left: Visualizing the 'pop' operation. Right: Sequential traversal of stack elements. -
Queue & Array:
Left: Searching for a specific value within a Queue. Right: Visualizing the in-place array reversal algorithm.
Solving complex connectivity problems through sub-problems and pathfinding.
Gateway to the Graph algorithms module.
-
Graph Structure & Traversal:
Left: Defining the adjacency matrix/list structure. Right: Real-time visualization of BFS across connected nodes. -
Algorithm Compatibility & Alerts:
Proactive educational alerts: A custom dialogue warns the user when trying to run Dijkstra’s algorithm on a graph with negative weights.
Real-time node manipulation, balancing, and property analysis.
Dynamic Binary Search Tree management interface.
-
Level Order Traversal & Deletion:
Left: Breadth-first level-order tree traversal. Right: Handling complex node deletions and automatic re-balancing. -
Tree Properties:
Automatic calculation of tree height, total internal nodes, and leaf node distribution.
Watch data organize itself through various algorithmic paradigms.
Comprehensive library of popular sorting paradigms.
-
Selection & Counting Sort:
Left: Selection Sort highlighting the current minimum element. Right: Non-comparative sorting using frequency arrays. -
Heap Sort:
Transforming a standard array into a heap structure for efficient sorting.
Deep dive into recursive call stacks and flow control.
Visual exploration of recursion paths and call stack logic.
-
Recursive Topological Sort:
Using depth-first recursion to resolve dependencies in a Directed Acyclic Graph (DAG). -
Call Stack & Tail Recursion:
Left: Visualizing the growth of the call stack. Right: Optimizing function calls through Tail Recursion. -
Recursive Fibonacci Sequence:
Standard Recursion: Visualizing the exponential growth of the call tree without memory optimization.
Optimized Execution: Implementation of memory optimization and constant space logic to streamline the calculation. -
Advanced Recursion:
Left: Visualizing stack overflow risks. Right: Recursive DFS for In-order tree traversal.
Solving large problems through recursive partitioning and merging.
Visualizing the powerful Divide and Conquer paradigm.
-
Merge Sort Workflow:
Sequence: Splitting into atomic sub-problems and merging back to a sorted whole. -
Quick Sort Partitioning:
Step-by-step partitioning logic using pivot-based organization.
Optimizing solutions through tabulation and memoization.
Tabular exploration of Dynamic Programming algorithms.
-
0/1 Knapsack Sequence:
Building the DP table to find the maximum value subset. -
Longest Common Subsequence (LCS):
Tracking overlapping subsequences across multiple strings.
- Language: Java 17+
- Framework: JavaFX 21+ (Rich Client Platform)
- Styling: Vanilla CSS (Modern aesthetic with custom transitions)
- Layout: FXML (Declarative UI structure)
- Build System: IntelliJ IDEA
- Java Development Kit (JDK) 17 or higher (Tested on JDK 21).
- JavaFX SDK 21+ (Necessary for the GUI animations).
- Extract the Project:
Unzip the
AlgoVista.zipfile to a local directory on your machine. - Open in Your IDE:
- IntelliJ IDEA: File > Open > Select the
Java_Fxfolder. - Eclipse/NetBeans: Import as an existing project.
- IntelliJ IDEA: File > Open > Select the
- Configure JavaFX Libraries:
- Go to Project Structure (Ctrl+Alt+Shift+S in IntelliJ).
- Under Libraries, add the JavaFX
libfolder from your local SDK. - Add the following VM Options in your Run Configuration to link the modules:
--module-path /path/to/javafx-sdk/lib --add-modules javafx.controls,javafx.fxml,javafx.media
- Run the Application:
Run the
Main.javafile found at:
src/com/AlgoVista/dashboard/Main.java.
The project includes a maintenance/ folder containing Python utility scripts used during development for FXML decoding and project auditing. These are not required to run the main Java application but are included for structural completeness.
- Select a Category: Choose from Sorting, Graphs, Trees, Recursion, etc., from the main dashboard.
- Input Data: Generate random data or input your own custom values (e.g., custom arrays for BST).
- Control Animation: Use the slider at the bottom to speed up or slow down the visualization.
- Analyze: Watch the code highlights and complexity labels to understand the logic deeply.
Contributions are welcome! If you'd like to add new algorithms or improve the UI, feel free to fork the repo and submit a PR.
This project is licensed under the MIT License - see the LICENSE file for details.
Created by Badhon Pain & Joyshree Mukharjee Joya