Split a Circular List into 2 Halves

Introduction

A Circular linked list where the last node points back to the first node, forming a loop. Every node in the circular linked list has a data element and a pointer to the next node. In this article, we will be splitting a circular linked list into two halves, an operation in linked list manipulation where we will use Floyd's Cycle-finding algorithm.

Key Points

Note: Each element in a circular linked list is called a node. A node consists of two parts: data and a pointer to the next node in the list.

Circularity: The key characteristic of a circular linked list is that the last node's reference points back to the first node, creating a loop. This ensures that there is no real end to the list.

Problem Statement

We have a circular linked list of length n. We have to split the original circular linked list into two halves

Input

Original Circular Linked List

Output

First Half

Second Half

Explantation

The original number of nodes is 5, separated into 3 and 2 nodes. The given nodes are in odd numbers so that the first Half will contain the extra node than the second Half.

Algorithm

To split a circular linked list in C++ using Floyd's Cycle-Finding Algorithm (also known as the "Tortoise and Hare" algorithm), you can follow these steps:

Initialize Two Pointers: Start with two pointers, the slow and fast pointers. Set both pointers initially to the head of the circular list.
Move the Pointers
Determine the Midpoint: Once the loop terminates, the fast pointer will be at the end of the list, and the slow pointer will be at the midpoint of the circular list. The slow pointer will be in the first Half if there are more elements.
Split the List: To split the circular list into two halves, you need to update the next pointers of the last node of the first Half and the head of the second Half. This effectively breaks the circular structure into two separate linked lists.
Connect the Second Half: To ensure that the second Half remains circular, connect the second Half's last node to the second Half's head.

Implementation C++

#include <iostream>

class Node {
public:
    int data;
    Node* next;

    Node(int data) : data(data), next(nullptr) {}
};

// CircularLinkedList class for managing the circular linked list
class CircularLinkedList {
public:
    Node* head;

    CircularLinkedList() : head(nullptr) {}

    // Append a new node with data to the end of the circular linked list
    void append(int data) {
        Node* new_node = new Node(data);
        if (!head) {
            // If the list is empty, make the new node the head and point it back to itself
            head = new_node;
            head->next = head;
        } else {
            Node* temp = head;
            // Traverse to the end of the list
            while (temp->next != head) {
                temp = temp->next;
            }
            // Append the new node and complete the circle
            temp->next = new_node;
            new_node->next = head;
        }
    }

    // Split the circular linked list into two halves and return the heads of both halves
    std::pair<Node*, Node*> splitInHalf() {
        if (!head) {
            // If the list is empty, return two nullptrs
            return {nullptr, nullptr};
        }

        Node* slow_ptr = head;
        Node* fast_ptr = head;

        // Use Floyd's cycle-finding algorithm to find the midpoint
        while (fast_ptr->next != head && fast_ptr->next->next != head) {
            slow_ptr = slow_ptr->next;
            fast_ptr = fast_ptr->next->next;
        }

        if (fast_ptr->next->next == head) {
            fast_ptr = fast_ptr->next;
        }

        // Split the list and adjust pointers
        Node* first_half_head = head;
        Node* second_half_head = slow_ptr->next;
        slow_ptr->next = first_half_head;
        fast_ptr->next = second_half_head;

        return {first_half_head, second_half_head};
    }

    // Display the elements of the circular linked list
    void display() {
        if (!head) {
            return;
        }
        Node* temp = head;
        do {
            std::cout << temp->data << " -> ";
            temp = temp->next;
        } while (temp != head);
        std::cout << std::endl;
    }
};
//Driver Code
int main() {
    CircularLinkedList cll;
    int values[] = {7, 14, 21, 28, 7};
    for (int value : values) {
        cll.append(value);
    }

    std::cout << "Original Circular Linked List:" << std::endl;
    cll.display();

    auto halves = cll.splitInHalf();
    std::cout << "\nFirst Half:" << std::endl;
    cll.head = halves.first;
    cll.display();

    std::cout << "\nSecond Half:" << std::endl;
    cll.head = halves.second;
    cll.display();

    return 0;
}

Output:

The above code uses Floyd's cycle-finding algorithm to find the midpoint of the circular linked list and then splits it into two halves.

Note: As an example in this article, if the Inputs are in an odd number of nodes, the first Half will contain one Extra node.

Conclusion

In conclusion, splitting a circular linked list into two halves we have used can be a useful operation when dealing with data manipulation and algorithms. We can divide the list into two equal parts by finding the middle node and breaking the circular reference.

Next TopicCheck given array of size n can represent BST of n levels or not

← prev next →