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 investigate singly-linked lists by focusing on how one might delete a node in the linked list. In summary, to delete a node, we'll first find the node to be deleted by traversing the linked list. Then, we'll delete that node and update the rest of the pointers. That's it!

# Algorithm

To solve this problem, we need to handle two cases:

1. Node to be deleted is head. 
2. Node to be deleted is not head. 

## Case of Deleting Head

Let's look at the illustration below to get a fair idea of the steps that we are going to follow while writing the code. 

Now let's go ahead and implement the case illustrated above in Python. 

def delete_node(self, key):
  
  cur_node = self.head

  if cur_node and cur_node.data == key:
    self.head = cur_node.next 
    cur_node = None
    return

The class method `delete_node` takes `key` as an input parameter. On **line 3**, we'll declare `cur_node` as `self.head` to have a starting point to traverse the linked list. To handle the case of deleting the head, we'll check if `cur_node` is not `None` and if the data in `cur_node` is equal to `key` on **line 5**. Note that `cur_node` is pointing to the head of the linked list at this point. If `key` matches `cur_node.data`, we'll update the head of the linked list (`self.head`) to `cur_node.next`, i.e., the next node of the previous head node (**line 6**). Once we have updated the head of the linked list, we'll set the node to be deleted (`cur_node`) to `None` (**line 7**) and return from the method. 

Now that we have written the code for deleting the head node let's move on to the other case of deletion, deleting a node from a linked list which is not the head node. 

## Case of Deleting Node Other Than the Head

In this case, we'll traverse the linked list to find the node that we are supposed to delete. As we move along, we also need to keep track of the previous node of the node to be removed. Below is a slide for you to visualize the process. 

In this lesson, we will learn how to delete a node based on a value from a linked list. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Deletion by Value

Algorithm #

Case of Deleting Head #