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

For this problem, we will use two pointers where one will keep track of the last node of the linked list, and the other will point to the second-to-last node of the linked list. Let's have a look at the code below. 

## Implementation

def move_tail_to_head(self):
  if self.head and self.head.next:
    last = self.head 
    second_to_last = None
    while last.next:
        second_to_last = last
        last = last.next
    last.next = self.head 
    second_to_last.next = None 
    self.head = last

## Explanation
Let's go over a line by line explanation of the solution above.

**Line 2** ensures that the code proceeds to **line 3** if there is more than one element in the linked list. This implies `self.head` and `self.head.next` is not `None`. We initialize `last` and `second_to_last` to `self.head` and `None` on **lines 3-4**. Now we have to make them point to what they are supposed to point to, i.e., `last` should point to the last node while `second_to_last` should point to the second to last node in a linked list. Therefore, we traverse the linked list using the `while` loop on **line 5**. The `while` loop will run until `last.next` becomes `None` which implies that `last` is the last node in the linked list. Before updating `last` to `last.next` on **line 7**, we keep updating `second_to_last` to `last` on **line 6** so that in the last iteration, when `last` is the last node in the linked list, `second_to_last` will be the second to last node in the linked list. 

Now that the two pointers are rightly positioned, we have to change a few pointers to complete our solution. Therefore, `last.next` which was previously pointing to `None` is pointed to `self.head` on **line 8**. This makes a circular linked list where the last node points to the first element of the linked list. To make the linked list linear, we make `second_to_last.next` point to `None` on **line 9**. In this way, we have updated the tail pointer of the linked list. At this stage, all that is left is to update the head pointer which we do on **line 10**, and set `self.head` equal to `last`. This completes our solution when we have to move the tail node to the head. 

You can visualize the solution above with the help of the slides below:

For this problem, we will use two pointers where one will keep track of the last node of the linked list, and the other will point to the second-to-last node of the linked list. Let's have a look at the code below. 

# Implementation

# Explanation
Let's go over a line by line explanation of the solution above.

**Line 2** ensures that the code proceeds to **line 3** if there is more than one element in the linked list. This implies `self.head` and `self.head.next` is not `None`. We initialize `last` and `second_to_last` to `self.head` and `None` on **lines 3-4**. Now we have to make them point to what they are supposed to point to, i.e., `last` should point to the last node while `second_to_last` should point to the second to last node in a linked list. Therefore, we traverse the linked list using the `while` loop on **line 5**. The `while` loop will run until `last.next` becomes `None` which implies that `last` is the last node in the linked list. Before updating `last` to `last.next` on **line 7**, we keep updating `second_to_last` to `last` on **line 6** so that in the last iteration, when `last` is the last node in the linked list, `second_to_last` will be the second to last node in the linked list. 

Now that the two pointers are rightly positioned, we have to change a few pointers to complete our solution. Therefore, `last.next` which was previously pointing to `None` is pointed to `self.head` on **line 8**. This makes a circular linked list where the last node points to the first element of the linked list. To make the linked list linear, we make `second_to_last.next` point to `None` on **line 9**. In this way, we have updated the tail pointer of the linked list. At this stage, all that is left is to update the head pointer which we do on **line 10**, and set `self.head` equal to `last`. This completes our solution when we have to move the tail node to the head. 

You can visualize the solution above with the help of the slides below:

This lesson contains the solution review for the challenge of moving the tail node of a linked list to the head. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Solution Review: Move Tail to Head

Implementation #

Explanation #