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 consider how to remove duplicates from a doubly linked list. 

# Implementation
Check out the code below:

def remove_duplicates(self):
  cur = self.head 
  seen = dict()
  while cur:
    if cur.data not in seen:
      seen[cur.data] = 1
      cur = cur.next
    else:
      nxt = cur.next
      self.delete_node(cur)
      cur = nxt

# Explanation
In the method `remove_duplicates`, we will keep track of the duplicates using a Python dictionary which we declare on **line 3**. `cur` is set to `self.head` on **line 2** to help us traverse the linked list using the `while` loop on **line 4**. 

In the `while` loop, we have to keep track of the number of times we encounter a data element. Therefore, if `cur.data` is not present in `seen`, we set the value of the key `cur.data` to `1`  on **line 6** to indicate that we have encountered it once while traversing the linked list. In the next line, we update `cur` to `cur.next` to iterate to the next node. 

On the other hand, if `cur.data` is present in `seen`, we jump to the `else` portion on **line 8**. This implies that `cur` in the current iteration has already been encountered in the previous iterations and is present in `seen`. On **line 9**, we save the next node of `cur` in `nxt` to keep with the traversal after we remove the duplicate node. We call the class method `self.delete_node(cur)` to delete the duplicate node on **line 10** and then set `cur` to `nxt` for the next iteration on **line 11**. 

Now let's discuss the `delete_node` method. You can see the modifications through the highlighted lines in the code snippet below. Instead of matching `key` with `cur.data`, we are comparing the entire `node` passed into the method with `cur`.

This lesson contains the solution review for the challenge of removing duplicates from a doubly linked list. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Solution Review: Remove Duplicates

Implementation

Explanation