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 introduce the doubly linked list data structure and code up an implementation of this data structure in Python. 

After that, we look at how to append (add elements to the back of the doubly linked list) and prepend (add elements to the front of the doubly linked list). 

Finally, we will write a print method to verify that the append and prepend methods work as expected. 

As you can see, the doubly linked list is very similar to the singly linked list except for the difference of the previous pointer. In a doubly linked list, a node is made up of the following components:
* Data
* Next (Points to the next node)
* Prev (Points to the previous node)

As illustrated, the `prev` of the head node points to NULL while the `next` of the tail node also points to NULL.  

Let's go ahead and implement the Doubly Linked List in Python:



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


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

    def append(self, data):
        pass

    def prepend(self, data):
        pass

    def print_list(self):
        pass

We have two classes in the code above:
1. `Node`
2. `DoublyLinkedList`

The key difference in the `Node` class of the last two chapters and of this chapter is that we have another component, `prev`, present in the `Node` class for this chapter.  `prev` will keep track of the previous node in the linked list. 

We also define `DoublyLinkedList` class and initialize its head to `None`. In this lesson, we will complete the implementation of the three class methods that we have specified in the code above. 

# `append`

Let's go over the implementation of `append`:

In this lesson, you will learn how to implement doubly linked lists and insert elements in it using Python.

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Append and Prepend