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 look at how we can reverse a singly linked list in an
iterative way and a recursive way. 

Let's first be clear about what we mean by reversing a linked list. Have a look at the illustration below to get a clear idea. 



Let's discuss the algorithm to reverse the linked list as depicted in the illustration above. 


# Algorithm

Before jumping to the code, let's figure out the algorithm. 


# Iterative Implementation

If we look at the reversal above, the
key idea is that we're reversing the orientation of the arrows. For example, **node A** is initially pointing to **node B** but after we flip them, **node B** points to **node A**. The same is the case for other nodes. We can take this key observation to solve our problem and implement the method `reverse_iterative`. 


def reverse_iterative(self):
  prev = None 
  cur = self.head
  while cur:
    nxt = cur.next
    cur.next = prev
    prev = cur 
    cur = nxt 
  self.head = prev

The crux of the solution will be to iterate through the linked list using the *previous and current node strategy* in the *Node swap* lesson. 

On **line 2** and **line 3**, we set the initial values of `prev` and `cur` which are `None` and `self.head` respectively. 

Next, we set the `while` loop on **line 4** which will run until `cur` is not equal to `None`. On **line 7** and **line 8**, we update the `prev` to `cur` and `cur` to `nxt`, i.e., `cur.next`, which help us to iterate through the linked list while keeping track of the previous and current nodes. `nxt` is used as a temporary variable to store the value of `cur.next` on **line 5**  because it gets modified on **line 6**. `cur.next = prev` is the statement which does the actual work. This is because the flipping of the arrows takes place through this statement. Instead of pointing to the next node, we point the next of the current node to the previous node. 

Now we just need to take care of one more thing. On **line 9**, after iterating through the linked list, `prev` is the last node in the linked list. We set `self.head` equal to the last node in the linked list. This completes our code to reverse a linked list.

Let's verify our method by making it part of the linked list implementation! You can also print out the current node and the previous node after each line in the `while` loop for a better understanding. 



In this lesson, you will learn how to reverse a linked list in both an iterative and recursive manner. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Reverse

Algorithm #

Iterative Implementation #