awangdev/leet-code

Features

• Custom Data Structure Implementations - Provides practical Java implementations of specialized data structures like Tries and Segment Trees with complexity analysis.
• Pattern-Based Algorithm Categorization - Implements a categorized library of algorithmic patterns including dynamic programming, sliding windows, and backtracking.
• Graph Data Models - Provides graph representations using adjacency lists and matrices to manage network nodes and edges.
• Competitive Programming Repositories - Provides a categorized source code collection of optimized solutions for LeetCode and LintCode challenges.
• Binary Search Patterns - A collection of iterative and recursive search patterns used to find targets or optimal boundaries in sorted datasets.
• Data Structures Reference - Provides a reference library of custom Java implementations for advanced data structures like Tries, Heaps, and Segment Trees.
• Java Implementation References - Provides concrete Java reference implementations for standard data structures such as Heaps and Tries.
• Advanced DP Patterns - Ships a suite of optimization and counting solutions using sequence, interval, and coordinate-based dynamic programming.
• Graph Traversal Algorithms - Implements algorithms for visiting vertices in graphs, including breadth-first and depth-first searches.
• Algorithmic Problem Sets - Offers a curated collection of Java solutions for algorithmic problems from platforms like LeetCode and LintCode.
• Balanced Search Trees - Implements self-balancing search trees that ensure logarithmic time complexity for search and insertion.
• General List Sorting - Provides implementations for ordering elements in lists using various sorting algorithms and comparison logic.
• Prefix Trees - Implements trie data structures for efficient string-based retrieval and prefix validation.
• Connected Component Analysis - Implements algorithms for grouping nodes into reachable sets and detecting cycles in undirected graphs.
• Graph Search Implementations - Provides techniques for exploring nodes using depth-first search for exhaustive visits and breadth-first search for shortest paths.
• Two-Pointer Techniques - Implements two-pointer techniques, including fast-slow and collision pointers, for optimized linear scans.
• Sliding Window Algorithms - Provides sliding window algorithms for efficiently processing contiguous subarrays and substrings.
• Recursive Problem Solving - Implements techniques to decompose complex problems into simpler sub-problems through systematic recursive state transitions.
• Memoization Techniques - Implements memoization techniques to optimize recursive calculations in dynamic programming.
• Technical Interview Preparation - Provides a comprehensive set of Java implementations and algorithmic patterns for technical interview preparation.
• Double-Ended Queues - Implements double-ended queues supporting constant-time insertions and deletions at both ends.
• Segment Trees - Provides segment tree implementations for performing range queries and updates in logarithmic time.
• Binary Search Algorithms - Implements algorithms that repeatedly divide a sorted search interval in half to locate a target value.
• Backtracking Algorithms - Provides algorithmic strategies for solving constraint satisfaction problems by systematically exploring potential solution paths.
• Greedy - Implements algorithms that make locally optimal choices at each step to find a global optimum.
• Prefix Sum Algorithms - Implements prefix sum algorithms to enable efficient constant-time subarray sum queries.
• Recursive Tree Traversal Algorithms - Provides recursive depth-first traversal algorithms for visiting nodes in hierarchical structures.
• Binary Tree Traversals - Provides standard visitation patterns including preorder, inorder, and postorder for binary trees.
• Sorting Algorithms - Provides implementations of fundamental sorting algorithms including Quick Sort, Merge Sort, Bucket Sort, and Radix Sort.
• Subarray Sum Algorithms - Implements computational methods for calculating and counting subarray sums using prefix sum techniques.
• Algorithmic Problem Solving - Offers a comprehensive set of Java solutions for complex algorithmic challenges including DP and backtracking.
• Common Ancestor Algorithms - Implements algorithms to identify the lowest shared ancestor node of two given nodes in a tree.
• Complexity Analysis - Includes detailed time and space complexity analysis for evaluating the efficiency of implemented algorithms.
• Disjoint Set Union - Implements data structures for tracking and merging non-overlapping sets to determine connectivity.
• Dynamic Programming Techniques - Implements a problem-solving approach that breaks problems into overlapping subproblems and caches results.
• Heaps - Provides binary heap implementations for tracking top-K elements and maintaining ordered streams.
• Heap Element Accessors - Implements efficient operations to retrieve minimum or maximum elements from heap-based collections.
• Navigation Operations - Implements essential pointer-based operations for linked lists such as reversing, merging, and finding the middle node.
• Priority Queues - Provides heap-based priority queue implementations for efficient retrieval of prioritized elements.
• Trie Constructions - Implements the construction of prefix trees for efficient word insertion and search completion.
• Two-Pointer Strategies - Implements two-pointer strategies for optimized linear scanning of arrays and strings.
• System Design and Architecture - Includes architectural notes on load balancing, database replication, and horizontal scaling for system design.
• System Design And Architecture - Provides architectural summaries and strategies for scaling infrastructure and managing distributed data.
• Least Recently Used Caches - Implements a least recently used cache using a hash map and doubly linked list for constant-time access.
• Data Replication - Provides notes and implementations for synchronizing data across distributed database nodes via replication.
• In-Memory Caches - Provides concepts and implementations for memory-based data caching to reduce latency.
• Nested List Flattening - Provides recursive methods to convert multi-level nested list structures into linear sequences.
• Logical Data Partitioning - Implements logical dataset partitioning for splitting data across multiple servers to improve performance.
• Horizontal Scaling Strategies - Explains architectural methods for distributing traffic and storage to scale infrastructure horizontally.
• Traffic Load Balancers - Covers the design and implementation of network traffic balancing to ensure high availability.
• Bit Manipulation Algorithms - Implements bitwise logic operations and algorithms for low-level data manipulation.
• Combinatorial Generation - Implements algorithms for generating all possible permutations, subsets, and combinations through recursive exploration.
• Quickselect Implementations - Implements partition-based selection to find the k-th smallest element in an unordered list.
• Edit Distance Calculators - Provides algorithms for computing the minimum number of operations required to transform one string into another.
• Bitwise Manipulation Utilities - Provides low-level operations using bitwise logic to solve algorithmic problems.
• Greedy Optimization Algorithms - Implements greedy optimization algorithms for efficient resource allocation and scheduling.
• Sweep-Line Processing - Implements sweep-line processing for solving geometric interval and overlapping range problems.
• Cycle Detection - Implements cycle detection in linked lists using pointer-based verification.
• Shortest Path Algorithms - Provides algorithms used to calculate the most efficient path between nodes in a graph.
• Longest Palindromic Substring Algorithms - Implements algorithms for identifying the longest palindromic sequence within strings.
• Quickselect Algorithms - Provides algorithms used to find the kth smallest or largest element in an unordered list.
• Topological Sorting - Implements algorithms for determining a linear ordering of nodes in a directed acyclic graph.
• Design Pattern Implementations - Provides practical Java implementations of established software design patterns like Singleton and Factory.
• LRU Cache Eviction - Implements an LRU cache using a hash map and doubly linked list for constant-time eviction.
• Monotone Stack Algorithms - Implements algorithms using a monotonic stack to find the nearest extreme element in linear time.
• Priority Heaps - Provides priority heap implementations for efficient minimum and maximum element retrieval.
• Topological Sorting - Implements dependency-based node ordering for processing nodes in a directed graph.

Star history