Discover data structures and algorithms using Python. Gain insights into solving real-world problems and typical interview questions with detailed reviews, explanations, and hands-on coding exercises.

Data structures and algorithms are among the most fundamental concepts of Computer Science. Whether it’s real-world problems you’re trying to solve or the typical coding question asked in an interview, almost every problem requires you to demonstrate a deep understanding of data structures and algorithms. 

This course is a detailed review of some of the most common data structures and algorithms that you’ll see in interviews and your everyday work. With implementation details, thorough explanations, and hands-on coding exercises, you’ll quickly gain the confidence you need to solve any problem, no matter the situation.

Data Structures and Algorithms in Python

In this lesson, we are going to be solving the "Two-Sum Problem". Let's begin by defining the problem. Given an array of integers, return `True` or `False` if the array has two numbers that add up to a specific target. You may assume that each input would have exactly one solution.

We investigate three different approaches to solving this problem. 
# Solution 1 
A brute-force approach that takes $O(n^2)$ time to solve with $O(1)$ space where we loop through the array and create all possible pairings of elements. 

## Implementation

Have a look at the code below:

# Time Complexity: O(n^2)
# Space Complexity: O(1)
def two_sum_brute_force(A, target):
  for i in range(len(A)-1):
    for j in range(i+1, len(A)):
      if A[i] + A[j] == target:
        print(A[i], A[j])
        return True
  return False

A = [-2, 1, 2, 4, 7, 11]
target = 13
print(two_sum_brute_force(A,target))
target = 20
print(two_sum_brute_force(A,target))



## Explanation

The outer loop on **line 4** iterates over all the elements in `A` while the inner loop on **line 5** iterates from the next index of `i` to the last index of `A` in every iteration of the outer loop. These nested loops help us form all possible pairs of array elements in every iteration. On **line 6**, we check if the pair `A[i]` and `A[j]` add up to the `target`. If they do, we have found a solution, and we return `True` on **line 8**. Otherwise, we move on to the next pair. If we are unable to find a solution after both the loops terminate, we return `False` on **line 9**.

This solution is highly inefficient as the code has a time complexity of $O(n^2)$ because of the nested loops. Let's see if we can improve it.  

# Solution 2 
A slightly better approach time-wise, taking $O(n)$ time, but worse from a space standpoint, with space complexity of $O(n)$. In this approach, we make use of an auxiliary hash table to keep track of whether it's possible to construct the target based on the elements we've processed thus far in the array. 

## Implementation



In this lesson, you will learn how to solve the Two Sum Problem using three solutions in Python. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Two Sum Problem

Solution 1

Implementation

Explanation