mandliya/algorithms_and_data_structures

Features

• Algorithm Implementations - Offers a comprehensive C++ reference library of solved coding problems and standard algorithmic patterns.
• C++ Implementations - Serves as a high-performance algorithmic reference with over 180 solved coding problems implemented in C++.
• Bitwise Manipulation Utilities - Provides a specialized toolkit of low-level bitwise logic operations and utilities for solving algorithmic problems.
• Adjacency Lists - Implements graph representations using adjacency lists to store vertices and edges for efficient traversal.
• Graph Topology Management - Implements the ability to create directed connections between specified vertices in a graph.
• Competitive Programming Solutions - Provides optimized C++ implementations of algorithms and data structures for competitive programming challenges.
• Breadth-First Search - Provides a reference implementation of the breadth-first search algorithm for graph traversal.
• Depth-First Search Algorithms - Provides a reference implementation of the depth-first search algorithm for exploring graph branches.
• Shortest Path Algorithms - Implements Dijkstra and Prim algorithms to compute the minimum distance between nodes in graphs.
• Graph Algorithm Routines - Provides a suite of graph algorithms including BFS, DFS, Dijkstra, and Prim's algorithms.
• Data Structures - Includes scratch implementations of fundamental C++ structures such as linked lists and binary search trees.
• Generic Data Structures - Provides generic C++ implementations of fundamental data structures such as linked lists, stacks, queues, and trees.
• Binary Search Trees - Implements a binary search tree for efficient data insertion and retrieval.
• Data Structure Implementations - Provides practical C++ implementations of fundamental structures like stacks, queues, lists, graphs, and trees.
• Stack Implementations - Provides a LIFO stack implementation supporting push, pop, and peek operations.
• Graph Pathfinding Algorithms - Implements pathfinding and spanning tree algorithms including Dijkstra, Prim, and Kruskal.
• Mathematical Algorithms - Implements fundamental mathematical logic including GCD, factorials, and power calculations.
• Minimum Spanning Tree Algorithms - Implements algorithms to identify the minimum spanning tree in weighted graph structures.
• Backtracking Solutions - Provides a recursive backtracking search implementation to explore all possible solution paths.
• Backtracking Algorithms - Implements a backtracking search algorithm to solve combinatorial puzzles like word searches.
• Dynamic Programming - Provides reference implementations of dynamic programming solvers using tabular and memoization techniques.
• Bit Manipulation Primitives - Provides a comprehensive library of fundamental bitwise operations, masks, and shift-based primitives.
• General Sorting Algorithms - Provides standard implementations of fundamental sorting and searching routines like QuickSort and Binary Search.
• Memoization - Implements memoization to optimize recursive functions by caching results of expensive calls.
• Endianness and Range Control - Implements byte order reversal to convert data between big-endian and little-endian representations.
• Middle Node Identification - Implements a single-traversal algorithm to identify the middle node of a linked list.
• Doubly Linked Lists - Implements bidirectional record sequences allowing efficient traversal and node replacement in both directions.
• Circular Queue Logic - Implements a circular queue using a fixed-capacity buffer that wraps around.
• Binary Tree Solutions - Provides various binary tree operations, including zig-zag traversals and BST validation.
• Graph Problem Solving - Implements comprehensive graph-based solutions including Dijkstra, Prim, Kruskal, and standard BFS/DFS traversals.
• Bit Manipulation Solutions - Implements low-level binary operations in C++ for memory optimization and parity checking.
• Search Tree Implementations - Implements search operations to locate specific values and identify extreme elements within a tree.
• Tree Modifications - Provides capabilities for structural tree modifications, such as clearing nodes and mirroring symmetry.
• Bitwise Logic Operations - Provides a bitwise implementation of integer addition using XOR and AND operations.
• String Manipulation - Includes a suite of basic operations for transforming, modifying, and analyzing C++ strings.
• Integer Overflow Detections - Provides runtime checks to detect if mathematical operations exceed signed integer capacity.
• Element Rotations - Implements array element shifting using a reversal-based algorithm to rotate the sequence.
• Bitwise Uniqueness Verifications - Determines if a string contains only unique characters using bitwise tracking.
• Combinatorial Optimization Solvers - Implements optimization solvers using memoization and tabular techniques for combinatorial problems like the knapsack problem.
• Huffman Coding Implementations - Implements Huffman encoding for lossless data compression using variable-length binary codes.
• Integer Sequence Generators - Calculates specific terms of the Fibonacci sequence using iterative and memoized methods.
• Linked List Cycle Detectors - Implements pointer-based algorithms to detect loops within linked data structures.
• Linked List Cycle Removals - Provides capabilities to identify loops in a linked list and break them to restore the linear structure.
• Bit Reversals - Implements iterative swapping to flip the sequence of bits in an unsigned integer.
• Set Bit Counting - Uses set bit counting algorithms to determine the parity of a binary number.
• Divide and Conquer Sorts - Implements sorting algorithms that utilize the divide and conquer paradigm, such as Merge Sort and QuickSort.
• XOR-Based Element Identification - Locates elements appearing an odd number of times using XOR operations.
• Array Reordering Algorithms - Provides an algorithm to move zero values to the end of an array while preserving relative order.
• Dynamic Programming Techniques - Implements optimization and combinatorial problems using C++ memoization and tabular techniques.
• Optimization Problem Solvers - Provides general-purpose optimization solvers using dynamic programming and memoization.
• Duplicate Detection in Arrays - Identifies duplicate values within an array using frequency analysis and adjacent element checks.
• Pointer Manipulations - Provides implementations for rearranging linked lists and strings through in-place pointer updates.
• Bit-Level Integer Operations - Provides bit-level integer operations to calculate the number of differing bits between two integers.
• Bit Sequence Swapping - Implements XOR-based logic to interchange two non-overlapping sets of bits.
• Bit-Shifting Arithmetic - Implements mathematical operations using bit-shifts and subtraction to avoid standard multiplication operators.
• Linked List Manipulation Utilities - Provides a suite of fundamental operations for reversing nodes, removing cycles, and merging sorted lists.
• Linked List Analysis Utilities - Includes utilities to verify if a linked list is a palindrome.
• Duplicate Node Removal - Implements logic to remove duplicate nodes from sorted linked lists.
• Linked List Sorting Algorithms - Provides divide-and-conquer sorting implementations specifically optimized for linked lists.
• Sorted Insertions - Provides a mechanism to insert new elements into a linked list while maintaining ascending order.
• Linked List Topology Transformers - Provides routines for reversing the topology of linked list nodes.
• List Rotations - Implements algorithms for shifting linked list elements to the right via rotation.
• Node Removal Techniques - Provides techniques for deleting specific nodes from linked lists using target pointers.
• Partitioning Algorithms - Implements linked list partitioning to reorganize nodes around a pivot value.
• Bubble Sorts - Provides a reference implementation of the bubble sort algorithm for ordering lists.
• Heap Sorts - Implements the heap sort algorithm by constructing a max-heap to order elements.
• Missing Positive Integer Detections - Implements a linear-time algorithm to find the smallest missing positive integer in an unsorted array.
• Merge Sorts - Provides a recursive divide-and-conquer implementation of the merge sort algorithm.
• Quicksorts - Implements QuickSort using a recursive partitioning strategy around a pivot element.
• Selection Sorts - Implements selection sort by repeatedly finding the minimum element from the unsorted portion.
• Two-Pointer Strategies - Implements two-pointer algorithmic patterns for efficient linear data structure traversal and cycle detection.

Star history