Welcome to my journey of learning Data Structures and Algorithms (DSA) in C++. This repository is a personal project where I commit to learning and improving my DSA skills every day. I aim to update this repository regularly with new concepts, code snippets, and challenges I've tackled.
Data Structures and Algorithms are fundamental to improving problem-solving skills and understanding computational efficiency. My goal is to master these concepts in C++ due to its performance advantages and its close relationship with system-level resources.
- Arrays: Static and dynamic arrays, and their applications.
- Linked Lists: Singly and doubly linked lists; basic operations like insertion, deletion, and traversal.
- Stacks: Implementation and usage scenarios.
- Queues: Different types such as circular and priority queues.
- Heap: Max and min heaps; applications in priority queues and heapsort.
- HashMap: Efficient key-value storage, collision handling, and usage in various algorithms.
- Sets: Unordered and ordered sets, operations like union, intersection, and difference.
- Trees: General trees, binary trees, and traversal techniques (preorder, inorder, postorder).
- Binary Search Trees (BST): Operations like insertion, deletion, and searching in a BST.
- Sorting and Searching: Bubble sort, insertion sort, merge sort, quicksort, linear search, binary search.
- Greedy Algorithms: Problem-solving strategies that build up a solution step by step, making locally optimal choices.
- Dynamic Programming (DP): Techniques to solve complex problems by breaking them down into simpler subproblems, focusing on overlapping subproblems and optimal substructure.
- Graph Algorithms: Representation of graphs (adjacency matrix, adjacency list), depth-first search (DFS), breadth-first search (BFS), shortest path algorithms (Dijkstra's, Bellman-Ford), and minimum spanning tree algorithms (Kruskal's, Prim's).
- Backtracking(Currently Learning): Systematic way to iterate through all possible configurations of a search space, used for solving constraint satisfaction problems like puzzles, permutations, and combinations.
- Mastering OOP principles such as encapsulation, inheritance, polymorphism, and abstraction in C++ for better modularity and code reuse.
This journey is ongoing, and I plan to explore more advanced topics and dive deeper into optimizing solutions.
I've been leveraging a variety of resources to aid my learning:
You can follow my problem-solving progress on LeetCode:
LeetCode - Krotrn
This repository serves as both a log of my personal learning journey and a resource for anyone interested in mastering DSA in C++. Feel free to explore, contribute, or draw inspiration from it!
Explore my code and projects:
GitHub - CPP DSA Journey