USSU Algorithm Analyzer v4.0

// Feature Matrix

Complete Algorithm Suite

Every algorithm is instrumented with complexity tracking, speed profiling, and operation counters. Not just theory — metrics-driven analysis.

🌐

Graph Traversal

Breadth First Search and Depth First Search with full path reconstruction, level tracking, and parent mapping for shortest unweighted paths.

BFS DFS O(V+E)

📍

Shortest Path

Dijkstra's min-heap algorithm, Bellman-Ford for negative weights, and Floyd-Warshall all-pairs shortest path with full matrix output.

Dijkstra Bellman-Ford Floyd-Warshall

🌳

Minimum Spanning Tree

Prim's priority queue approach and Kruskal's Union-Find implementation with cycle detection and total weight optimization.

Prim's Kruskal's Union-Find

🔍

Searching Suite

8 complete search algorithms from Linear O(n) to Interpolation O(log log n). Each tracks comparisons, accesses, and execution time.

Binary Jump Fibonacci Ternary

📊

Sorting Engine

11 sorting algorithms including Bubble, Merge, Quick, Heap, Shell, Cocktail, Comb, Counting, and Radix with stability indicators.

Merge Quick Heap Radix

🧮

Math Calculator

Advanced mathematical tools: Factorial, Fibonacci (3 methods), GCD, Fast Exponentiation, Primality Test, Sieve, and Matrix Multiply.

GCD Sieve Matrix Big-O

⚡

Speed Benchmarking

Cross-size performance suites with warmup runs, averaging, and automatic skipping of O(n²) algorithms on large inputs.

tracemalloc perf_counter Profiling

🎨

Graph Visualization

Matplotlib + NetworkX integration for publication-quality graph plots with cyberpunk color theming and automatic PNG export.

matplotlib networkx PNG Export

// Algorithm Index

Every Algorithm. Every Complexity.

Complete index of all implemented algorithms with their time and space complexities.

🔍

Searching

Linear SearchO(n)

Binary Search (Iterative)O(log n)

Binary Search (Recursive)O(log n)

Jump SearchO(√n)

Interpolation SearchO(log log n)

Exponential SearchO(log n)

Ternary SearchO(log₃ n)

Fibonacci SearchO(log n)

📊

Sorting

Bubble SortO(n²)

Selection SortO(n²)

Insertion SortO(n²)

Merge SortO(n log n)

Quick SortO(n log n)

Heap SortO(n log n)

Shell SortO(n log² n)

Cocktail ShakerO(n²)

Comb SortO(n²/2^p)

Counting SortO(n+k)

Radix SortO(d(n+k))

🌐

Graph Theory

BFS TraversalO(V+E)

DFS TraversalO(V+E)

Dijkstra Shortest PathO((V+E) log V)

Bellman-FordO(V×E)

Floyd-WarshallO(V³)

Longest Path (DAG)O(V+E)

Prim's MSTO((V+E) log V)

Kruskal's MSTO(E log E)

🧮

Mathematics

FactorialO(n)

Fibonacci (Iterative)O(n)

Fibonacci (Memoization)O(n)

Fibonacci (Recursive)O(2ⁿ)

Euclidean GCDO(log min(a,b))

Fast ExponentiationO(log n)

Primality TestO(√n)

Sieve of EratosthenesO(n log log n)

Matrix MultiplyO(n³)

// Interactive

Big-O Complexity Visualizer

Click the buttons below to visualize how different time complexities scale with input size n.

// Live Preview

Terminal Experience

The actual interface you get when running USSU Algorithm Analyzer v4.0 in your terminal.

ussu@kali:~/algorithm-analyzer

ussu@kali:~$ python3 app.py

Loading USSU Algorithm Analyzer v4.0...

[+] System check complete. Python 3.13 detected.

[+] matplotlib: YES | networkx: YES | numpy: YES

╔═══════════════════════════════════════════════════════════════╗

║ USSU'S ULTRA PRO MAX ALGORITHM ANALYZER v4.0 ║

║ Graph Theory | Search | Sort | ADA | Speed Benchmark ║

╚═══════════════════════════════════════════════════════════════╝

[1] Graph Operations - Create, load, display graphs

[2] BFS Traversal - Breadth First Search

[3] DFS Traversal - Depth First Search

[4] Shortest Path (Dijkstra)- Single source shortest path

[5] All Pairs Shortest Path - Floyd-Warshall algorithm

[6] Longest Path (DAG) - Critical path analysis

[7] Minimum Spanning Tree - Prim's & Kruskal's

[8] Bellman-Ford - Negative weight handling

[9] Compare Graph Algos - Performance comparison

[10] Searching Algorithms - Linear, Binary, Jump, etc.

[11] Sorting Algorithms - Bubble, Merge, Quick, etc.

[12] Math Calculator - Advanced mathematical tools

[USSU v4.0] Enter choice: 4

[DIJKSTRA - SHORTEST PATH]

Time: O((V + E) log V) | Space: O(V)

Shortest Distances from 0:

0 → 0: 0.00

0 → 1: 4.00

0 → 2: 1.00

0 → 3: 2.00

0 → 4: 3.00

Path to 4: 0 → 2 → 3 → 4

Total Distance: 3.00

Execution Time: 0.052 ms | Memory: 12.4 KB

USSU ALGORITHMANALYZER V4.0 ULTRA PRO MAX

0

0

0

0

0