https://github.com/andreie91/fundamental-algorithms

This repository contains various fundamental algorithms implemented in C and C++, focusing on performance analysis.
https://github.com/andreie91/fundamental-algorithms

algorithms-and-data-structures breadth-first-search depth-first-search graph-algorithms hashtables heaps heapsort hybrid-quicksort mergeklists mergesort profiler quicksort redblack-tree sorting-algorithms tetris

Last synced: 4 months ago
JSON representation

This repository contains various fundamental algorithms implemented in C and C++, focusing on performance analysis.

• Host: GitHub
• URL: https://github.com/andreie91/fundamental-algorithms
• Owner: AndreiE91
• Created: 2023-06-03T16:43:37.000Z (about 2 years ago)
• Default Branch: main
• Last Pushed: 2024-02-05T20:57:45.000Z (over 1 year ago)
• Last Synced: 2025-01-14T04:10:00.282Z (6 months ago)
• Topics: algorithms-and-data-structures, breadth-first-search, depth-first-search, graph-algorithms, hashtables, heaps, heapsort, hybrid-quicksort, mergeklists, mergesort, profiler, quicksort, redblack-tree, sorting-algorithms, tetris
• Language: C++
• Homepage:
• Size: 1.06 MB
• Stars: 1
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# Fundamental Algorithms

This repository contains various fundamental algorithms implemented in C and C++, focusing on performance analysis. Each algorithm is accompanied by a brief description and example usage.

## Topics Covered

### Basic File I/O

Handles basic file input/output operations.

### Basic Sort Comparison

![Basic Sort Average](images/BasicSort_Average.jpg)

*Average Case of Basic Sort*

![Basic Sort Best](images/BasicSort_Best.jpg)

*Best Case of Basic Sort*

![Basic Sort Worst](images/BasicSort_Worst.jpg)

*Worst Case of Basic Sort*

Compares basic sorting algorithms.

### Breadth-First Search (BFS)

![BFS Performance](images/BFS_Performance.jpg)

*Performance Analysis of BFS*

Implements the Breadth-First Search algorithm.

### Depth-First Search (DFS)

![DFS Performance](images/DFS_Performance.jpg)

*Performance Analysis of DFS*

Implements the Depth-First Search algorithm.

### Fstream I/O

Demonstrates file input/output operations using `fstream`.

### Hash Tables

![Hash Tables](images/Hashtables.jpg)

*Hash Tables in Action*

Implements hash tables for efficient data retrieval.

### Heaps and Heapsort

![Heapsort Average](images/Heapsort_Average.jpg)

*Average Case of Heapsort*

![Heapsort Best](images/Heapsort_Best.jpg)

*Best Case of Heapsort*

![Heapsort Worst](images/Heapsort_Worst.jpg)

*Worst Case of Heapsort*

Implements heaps and the Heapsort algorithm.

### Kruskal's Minimum Spanning Tree (MST)

![Kruskal's MST Performance](images/KruskalMST_PerformanceReport.jpg)

*Performance Report of Kruskal's MST*

Finds the Minimum Spanning Tree using Kruskal's algorithm.

### Merge k Sorted Lists

![Merge k Lists](images/MergeKLists.jpg)

*Merging k Sorted Lists*

Merges k sorted lists efficiently.

### Merge Sort

Implements the Merge Sort algorithm.

### Merge Sort Test

Tests the Merge Sort implementation.

### Profiler Test

Tests the performance of various algorithms.

### Quicksort

![Quicksort Average](images/QuickSort_Average.jpg)

*Average Case of Quicksort*

![Quicksort Best](images/QuickSort_Best.jpg)

*Best Case of Quicksort*

![Quicksort Worst](images/QuickSort_Worst.jpg)

*Worst Case of Quicksort*

Implements the Quicksort algorithm.

### Red-Black Trees

![Red-Black Trees](images/RedBlackTree.jpg)

*Red-Black Trees*

Implements Red-Black Trees for balanced binary search trees.

### Tetris

![Console Tetris](images/ConsoleTetris.jpg)

*Console Tetris Game*

A Tetris game implementation.

### Tree Data Structures

![Tree Data Structures](images/Tree_DataStructures.jpg)

*Various Tree Data Structures*

Implements various tree data structures.

### Tree Traversals and Hybrid Quick Sort

![Hybrid Quick Sort Threshold Report](images/HybridQuickSort_ThresholdReport.jpg)

*Threshold Report for Hybrid Quick Sort*

Performs tree traversals and implements a hybrid Quick Sort algorithm.