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

Here is an overview of our solution to finding a pair of nodes in a doubly linked list that sums up to a specific number.


# Implementation

Here is the coding solution in Python for the previous challenge:

def pairs_with_sum(self, sum_val):
  pairs = list()
  p = self.head 
  q = None 
  while p:
    q = p.next
    while q:
      if p.data + q.data == sum_val:
          pairs.append("(" + str(p.data) + "," + str(q.data) + ")")
      q = q.next
    p = p.next
  return pairs

# Explanation
On **line 2**, `pairs` is initialized to an empty Python list. In the next lines (**lines 3-4**), `p` and `q` are set equal to `self.head` and `None` respectively. We will use both these pointers (`p` and `q`) to make pairs out of the doubly linked list by using two `while` loops afterward. 

The outer `while` loop on **line 5** will run until `p` becomes equal to `None` while the inner loop on **line 7** will run for every iteration of the outer loop until `q` becomes `None`. 

On **line 6**, we set `q` equal to `p.next` as we have to start pairing nodes from the next node of the current node as we would already have checked the pairing with all previous nodes. Then we'll check if the sum of `p.data` and `q.data` equals `sum_value` or not on **line 8**. If it is, then we append `p.data` and `q.data` to the list we declared at the beginning of the `pairs_with_sum` method. If it does not, we move on to the next node of `q` by updating `q` to `q.next` on **line 10**. In each iteration of the inner loop, we pair the data of `p` with all the data of the nodes after `p` using `q` and then check each of these pairs to see if they sum up to `sum_value`. This process is repeated for every node in the linked list as `p` updates to `p.next` on **line 11** in the outer `while` loop. After the outer loop terminates, `pairs` is returned from the method on **line 12**.  

You can play around with all the methods that we have implemented for the `DoublyLinkedList` class in the code widget provided below. 

This lesson contains the solution review for the challenge of finding pairs in a doubly linked list which sum up to the given number. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Solution Review: Pairs with Sums

Implementation

Explanation