Complete Python With DSA Bootcamp + LEETCODE Exercises

Complete Python With DSA Bootcamp + LEETCODE Exercises

Learning Python and data structures and algorithms (DSA) is essential for anyone aspiring to be a successful software developer. 

Enroll Now

Python is one of the most versatile and powerful programming languages, offering simplicity, readability, and an extensive ecosystem of libraries. When combined with a solid understanding of DSA, it becomes a powerhouse for solving complex problems. To truly become proficient, tackling real-world problems on platforms like LeetCode is a must.

This guide is structured as a comprehensive bootcamp to cover Python basics, DSA, and LeetCode exercises. Let's dive into it step by step.

---

Part 1: Python Fundamentals

Before diving into data structures and algorithms, it's crucial to have a strong foundation in Python. Python is known for its simplicity and clean syntax, which makes it an excellent choice for beginners.

1.1 Variables and Data Types

In Python, variables are used to store data. There’s no need to declare the type of a variable as Python is dynamically typed.

python
x = 5  # Integer
name = "Alice"  # String
is_student = True  # Boolean
pi = 3.14  # Float

Python supports the following primary data types:

• Integers: Whole numbers.
• Floats: Decimal numbers.
• Strings: Text data, enclosed in single or double quotes.
• Booleans: True or False values.

1.2 Control Flow

Control flow allows you to make decisions and iterate over data. The two most important control flow statements are conditional statements (if, else, elif) and loops (for, while).

python
if age >= 18:
    print("You're an adult.")
else:
    print("You're a minor.")

Loops allow us to repeat tasks:

python
for i in range(5):
    print(i)  # Prints 0 to 4

1.3 Functions

Functions allow you to encapsulate blocks of code for reusability.

python
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))

1.4 Data Structures in Python

Python provides built-in data structures like lists, sets, tuples, and dictionaries.

• Lists: Ordered, mutable collections.

python
fruits = ["apple", "banana", "cherry"]

• Sets: Unordered, unique collections.

python
unique_numbers = {1, 2, 3, 4, 5}

• Tuples: Ordered, immutable collections.

python
coordinates = (10, 20)

• Dictionaries: Key-value pairs.

python
student = {"name": "Alice", "age": 21, "major": "CS"}

1.5 Object-Oriented Programming (OOP)

Python is an object-oriented language. Classes and objects are fundamental to OOP.

python
class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def start(self):
        print(f"{self.make} {self.model} is starting.")

car = Car("Toyota", "Corolla")
car.start()

---

Part 2: Data Structures

In this section, we'll cover essential data structures and their implementations using Python. Data structures allow you to store and organize data efficiently.

2.1 Arrays (Lists)

Arrays store elements in contiguous memory locations. Python lists can be used to represent arrays, but they are dynamic in size.

Key Operations:

• Accessing an element: arr[index]
• Appending an element: arr.append(value)
• Removing an element: arr.pop()

LeetCode Example: Two Sum

python
def two_sum(nums, target):
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]

2.2 Linked Lists

A linked list is a linear data structure where each element (node) points to the next one. It’s used when you need dynamic memory allocation and quick insertions or deletions.

python
class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None
    
    def append(self, value):
        if not self.head:
            self.head = Node(value)
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = Node(value)

LeetCode Example: Reverse Linked List

python
def reverse_list(head):
    prev = None
    curr = head
    while curr:
        next_temp = curr.next
        curr.next = prev
        prev = curr
        curr = next_temp
    return prev

2.3 Stacks

A stack is a Last In First Out (LIFO) data structure. It supports two main operations:

• push(): Add an item.
• pop(): Remove the last item.

python
stack = []
stack.append(10)
stack.pop()

LeetCode Example: Valid Parentheses

python
def is_valid(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    
    for char in s:
        if char in mapping:
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:
            stack.append(char)
    return not stack

2.4 Queues

A queue is a First In First Out (FIFO) data structure. The two main operations are:

• enqueue(): Add an element.
• dequeue(): Remove the first element.

python
from collections import deque

queue = deque([1, 2, 3])
queue.append(4)
queue.popleft()

2.5 Hash Maps (Dictionaries)

A hash map (or dictionary in Python) stores key-value pairs and provides average O(1) time complexity for lookups, insertions, and deletions.

python
hash_map = {"name": "Alice", "age": 21}

---

Part 3: Algorithms

Once you’re comfortable with data structures, it’s time to learn algorithms, which are essential for problem-solving.

3.1 Sorting Algorithms

Sorting is a common task in programming. Here are a few essential sorting algorithms:

• Bubble Sort: Simple, but inefficient for large data sets.

python
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

• Merge Sort: A divide-and-conquer algorithm with O(n log n) time complexity.

python
def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left = arr[:mid]
        right = arr[mid:]

        merge_sort(left)
        merge_sort(right)

        i = j = k = 0

        while i < len(left) and j < len(right):
            if left[i] < right[j]:
                arr[k] = left[i]
                i += 1
            else:
                arr[k] = right[j]
                j += 1
            k += 1

        while i < len(left):
            arr[k] = left[i]
            i += 1
            k += 1

        while j < len(right):
            arr[k] = right[j]
            j += 1
            k += 1

3.2 Search Algorithms

Search algorithms help locate elements in data structures. Two common ones are:

• Linear Search: O(n) time complexity.

python
def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

• Binary Search: Requires a sorted array and has O(log n) time complexity.

python
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

---

Part 4: LeetCode Exercises

LeetCode is one of the most popular platforms for practicing DSA. It provides a large variety of problems, from easy to hard. The problems are categorized under topics like arrays, linked lists, dynamic programming, graphs, and more.

4.1 Array-Based Problems

Example: Find the Missing Number

python
def missing_number(nums):
    n = len(nums)
    expected_sum = n * (n + 1) // 2
    return expected_sum - sum(nums)

4.2 Graph-Based Problems

Graph algorithms are key for many real-world problems.

Example: Number of Islands

python
def num_islands(grid):
    if not grid:
        return 0

    count = 0
    rows, cols = len(grid), len(grid[0])

    def dfs(r, c):
        if r < 0 or c < 0 or r >= rows or c >= cols or grid[r][c] == "0":
            return
        grid[r][c] = "0"
        dfs(r + 1, c)
        dfs(r - 1, c)
        dfs(r, c + 1)
        dfs(r, c - 1)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == "1":
                count += 1
                dfs(r, c)
    return count

4.3 Dynamic Programming (DP) Problems

Dynamic programming is a powerful technique for optimizing recursive algorithms by storing intermediate results.

Example: Climbing Stairs

python
def climb_stairs(n):
    if n == 1:
        return 1
    dp = [0] * (n + 1)
    dp[1], dp[2] = 1, 2

    for i in range(3, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]

    return dp[n]

---

Conclusion

By mastering Python and combining it with a solid grasp of data structures and algorithms, you’ll be well-equipped to tackle coding challenges, technical interviews, and real-world programming tasks. Platforms like LeetCode provide an excellent opportunity to apply your knowledge, practice problem-solving skills, and become proficient in DSA. Keep practicing, and you’ll find yourself progressing quickly through the ranks of a competent coder!

AWS Essentials: A Complete Beginner's Guide Udemy