Data Structures and Algorithms (DSA) Journey

Overview

This repository tracks my journey through learning Data Structures and Algorithms (DSA). It includes all the assignments, questions, and challenges I’ve solved so far. Each section will focus on different aspects of DSA, and the goal is to progressively learn and apply the concepts through hands-on problems.

Objective

The objective of this repository is to:

• Document the key concepts learned in DSA.
• Keep track of the assignments and questions solved.
• Continuously improve problem-solving skills by tackling challenges and assignments.
• Learn efficient solutions and algorithms to solve various problems.

Base 60 📔

CONCEPTS 📔

Click to Expand: CONCEPTS 📔

Conditionals and Loops ✅

Patterns ✅

Arrays ✅

Binary Search ✅

Maps and Sets ✅

Assignments 📔

Click to Expand: Assignments 📔

Question Set 1 ✅

Question Set 2 ✅

Question Set 3 ✅

Question Set 4 ✅

Question Set 5 ✅

Question Set 6 ✅

Question Set 7 ✅

Question Set 8 ✅

Table of Contents

1. Introduction to DSA
2. Array
3. Linked List
4. Stacks and Queues
5. Trees
6. Graphs
7. Sorting and Searching
8. Dynamic Programming
9. Greedy Algorithms
10. Recursion and Backtracking
11. Practice Questions and Assignments

1. Introduction to DSA

This section covers the basics of Data Structures and Algorithms, including:

• The importance of DSA in problem-solving.
• Different types of data structures: Arrays, Linked Lists, Stacks, Queues, Trees, Graphs, Hashmaps, etc.
• Basic algorithms and their applications.

2. Array

• Concepts learned: Arrays, Traversal, Searching, Sorting.
• Key problems solved:
  • Reverse an Array.
  • Find the Maximum Element in an Array.
  • Merge Two Sorted Arrays.

3. Linked List

• Concepts learned: Singly Linked Lists, Doubly Linked Lists, Linked List Operations (Insertion, Deletion).
• Key problems solved:
  • Reverse a Linked List.
  • Detect a Loop in a Linked List.
  • Merge Two Sorted Linked Lists.

4. Stacks and Queues

• Concepts learned: Stacks, Queues, Circular Queues, Stack Operations (Push, Pop), Queue Operations (Enqueue, Dequeue).
• Key problems solved:
  • Implement a Stack using Arrays.
  • Implement a Queue using Linked List.
  • Valid Parentheses (Stack-based problem).

5. Trees

• Concepts learned: Binary Trees, Binary Search Trees, Tree Traversals (Inorder, Preorder, Postorder), Balanced Trees.
• Key problems solved:
  • Height of a Binary Tree.
  • Level Order Traversal.
  • Check if a Binary Tree is Balanced.

6. Graphs

• Concepts learned: Graph Representation (Adjacency Matrix, Adjacency List), BFS, DFS, Shortest Path Algorithms.
• Key problems solved:
  • Implement BFS and DFS Traversals.
  • Detect a Cycle in a Graph.
  • Find the Shortest Path using Dijkstra’s Algorithm.

7. Sorting and Searching

• Concepts learned: Sorting Algorithms (Bubble Sort, Merge Sort, Quick Sort), Searching Algorithms (Binary Search).
• Key problems solved:
  • Implement Binary Search on a Sorted Array.
  • Implement Merge Sort.
  • Find the Kth Smallest/Largest Element in an Array.

8. Dynamic Programming

• Concepts learned: Memoization, Tabulation, Optimal Substructure, Overlapping Subproblems.
• Key problems solved:
  • Fibonacci Sequence using Dynamic Programming.
  • Longest Common Subsequence.
  • 0/1 Knapsack Problem.

9. Greedy Algorithms

• Concepts learned: Greedy Strategy, Local Optimal Choices, Optimal Substructure.
• Key problems solved:
  • Activity Selection Problem.
  • Huffman Coding.
  • Fractional Knapsack.

10. Recursion and Backtracking

• Concepts learned: Recursion, Base Case, Backtracking.
• Key problems solved:
  • Tower of Hanoi.
  • N-Queens Problem.
  • Subset Sum Problem.

11. Practice Questions and Assignments

This section will contain the details of all the problems I've solved along the way. These will include:

• Problem statements.
• Approach taken to solve them.
• Code implementation for each problem.
• Time and Space Complexity analysis.

How to Use This Repository:

1. Clone this repository to your local machine.
2. Navigate through different folders to find the problems and solutions you need.
3. Practice solving the problems on your own first, and then compare your solutions with the ones in this repository.
4. If you're stuck, refer to the explanations and code implementations provided for each topic.

Future Enhancements:

• Continuously adding more problems and solutions.
• Optimizing existing solutions and exploring more efficient algorithms.
• Adding explanations for complex problems with time and space complexity analysis.

---