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 will be solving the following problem:

 **Given two sorted arrays, `A` and `B`, determine their intersection. What elements are common to `A` and `B`?**

There is a one-line solution to this problem in Python that will also work in the event when the arrays are not sorted. 

A = [2, 3, 3, 5, 7, 11]
B = [3, 3, 7, 15, 31]

print(set(A).intersection(B))

The  `set` function in Python operates on a list and returns a set object that contains the unique elements of that list. `A` is converted into a set on **line 4** by using `set(A)`. Now there is another built-in function in Python called `intersection` which operates on sets. In the code above, `intersection` returns a set which is the intersection of `A` and `B`. The method `intersection` is a member of the `Set` class, but it can accept lists as arguments too. This solution is fine considering it works on unsorted arrays as well. However, since we are aware that the arrays `A` and `B` are sorted, we can use this to our advantage and solve the problem in a way that leverages this and gives us a slightly better runtime.

# Algorithm

In the algorithm that we'll use to solve this problem more efficiently, we will make use of two iterators, `i` and `j`, one for each array. If the ith element in `array1` is less than the jth element in `array2`, we increment the `ith` iterator to increase the value so that we can reach a match with `array2`. On the other hand, if `array1[i]` is greater than `array2[j]`, `j` will be incremented so that we can get a larger value from `array2`. If both the elements pointed to by the iterators are equal, we have found an intersection and both the iterators are incremented. 

Additionally, we need to cater for an edge case of duplicates. If an intersection is recorded for some elements, we need to make sure that we don't count another intersection of their duplicates. In the slides below, this algorithm has been illustrated for you.

In this lesson, you will learn how to find the intersection of two sorted arrays in Python. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Intersection of Two Sorted Arrays