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 determine whether two strings are anagrams of each other. 

Simply put, an anagram is when two strings can be written using the same letters.

Examples:
```
"rail safety" = "fairy tales"
"roast beef" = "eat for BSE"
```

It sometimes changes a proper noun or personal name into a sentence:
```
"William Shakespeare" = "I am a weakish speller"
"Madam Curie" = "Radium came"
```

We will write two solutions to this problem. The first one will be concise, while the second one will be more robust and efficient. Both of these approaches involve normalizing the input string, which means converting them into lowercase and removing all the characters which are not alphanumeric. 

Let's get started with the first approach.

# Implementation
## Solution 1


s1 = "fairy tales"
s2 = "rail safety"

s1 = s1.replace(" ", "").lower()
s2 = s2.replace(" ", "").lower()

# Requires n log n time (since any comparison 
# based sorting algorithm requires at least 
# n log n time to sort).
print(sorted(s1) == sorted(s2))

On **lines 4-5**, `s1` and `s2` are normalized using `replace()` and `lower()` functions. `replace(" ","")` replaces all the spaces with an empty string so that we are only left with alphabets or numbers. `lower()` converts all the alphabets to lowercase. On **line 10**, the two strings are sorted after the normalization and then compared. If `s1` and `s2` are anagrams of each other, both the lists returned from `sorted` will be the same and `True` will be printed onto the console. On the other hand, if `sorted(s1)` does not equal `sorted(s2)`, `False` will be printed onto the console. 

You may notice that the solution above is very concise. However, the time complexity for the above algorithm will be $O(nlogn)$ as sorting takes $O(n logn)$. Therefore, we prefer the second approach, which is more efficient than the sorting approach. 

## Solution 2: The Preferred Solution

In this solution, we make use of a Python dictionary. First, we store the characters of one string in a dictionary, keeping track of the count of individual characters. Then we compare the count of each character with the characters of the other string. If they counterbalance each other, we'll declare the two strings as an anagram of each other. This solution is of linear time complexity which is an improvement on  $O(nlogn)$.

Have a look at the code below to see how we have implemented the approach mentioned above:

In this lesson, you will learn how to determine if a string is an anagram of another string or not. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Is Anagram

Implementation

Solution 1