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

# Introduction
First of all, let's talk about what a circular linked list is. It is very similar to a singly linked list except for the fact that the next of the tail node is the head node instead of null. 

Below is an illustration to help you visualize a circular linked list:

You can see from the illustration above that the circular linked list contains the same kind of nodes as a singly linked list. As the name *circular* suggests, the tail node points to the head of the linked list instead of pointing to null which makes the linked list circular. Now let's implement it in Python:

class Node:
    def __init__(self, data):
      self.data = data
      self.next = None


class CircularLinkedList:
    def __init__(self):
      self.head = None 

    def prepend(self, data):
      pass

    def append(self, data):
      pass

    def print_list(self):
      pass

The *Node* class is the same as before. Also, the constructor of *CircularLinkedList* class is identical to the constructor of the *LinkedList* class. However, the methods `prepend`, `append`, and `print_list` will be different this time. 

# `append`

Appending to a circular linked list implies inserting the new node after the node that was previously pointing to the head of the linked list. 

Let's have a look at the code below for the `append` method:

def append(self, data):
  if not self.head:
      self.head = Node(data)
      self.head.next = self.head
  else:
      new_node = Node(data)
      cur = self.head
      while cur.next != self.head:
          cur = cur.next
      cur.next = new_node
      new_node.next = self.head

One case is to append to an empty linked list. In this case, we make the new node the head of the linked list, and its next node is itself.
So, we'll check if the linked list is empty. If `self.head` is `None`, then the condition on **line 2** will evaluate to `true` and we will initialize `self.head` to a new *Node* based on the input parameter `data`. As this is the `append` method for a circular linked list, we make the next of the head point to itself on **line 4**. 

Now let's look at the case where the linked list is not empty. In this case, we iterate the linked list to get to the last element whose next is the head node and insert the new element after that last node. On **line 6**, we initialize `new_node` by calling the constructor of the *Node* class and passing `data` to it. Next, we have to find an appropriate position in the linked list to insert `new_node`. For this, we set `cur` to `self.head` on **line 7** and set up a `while` loop on **line 8** which executes until the next node of the `cur` does not equal `self.head`. `cur` is updated to `cur.next` in the body of the `while` loop on **line 9** to help us traverse the linked list. After the `while` loop terminates, `cur` will be the node that points to the head node and we will insert `new_node` after `cur`. Hence, we set `cur.next` equal to `new_node` on **line 10**.  As we have to complete our circular chain, we set `new_node.next` to point to `self.head` on **line 11**. This completes our implementation for the `append` method. 

# `print_list`

To verify the `append` method, we will need to print the circular linked list. Let's see how we would do this. Check out the code below:


In this lesson, you will be introduced to circular linked lists and you will learn how to insert elements into a circular linked list. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Introduction and Insertion