Check If A Linked List Is Circular Linked List

#include<bits stdc++.h="">
using namespace std;

struct Node {
    int val;
    Node* next;

    Node(int value){
        val = value;
        next = NULL;
    }
};

void push_front(Node** head, int new_val){
    Node* new_node = new Node(new_val);
    new_node->next = *head;
    *head = new_node;
}

bool isCircular(Node* head){
    // detect cycle
    Node *slow, *fast;
    slow = fast = head;

    while(fast!=NULL && fast->next!=NULL){
        slow = slow->next;
        fast = (fast->next)->next;

        if(slow==fast) break;
    }

    if(fast==NULL) return false;
    if(fast->next == NULL) return false;


    // now we have a loop
    // find its starting point
    slow = head;
    while(slow!=fast){
        slow = slow->next;
        fast = fast->next;
    }

    // check if starting point of loop
    // is the first node
    if(slow == head) return true;
    else return false;
}



int main(){
    Node* h1 = NULL;

    push_front(&h1, 5);
    push_front(&h1, 4);
    push_front(&h1, 3);
    push_front(&h1, 2);
    push_front(&h1, 1);

    // let's check if our lined list if circular or not
    if(isCircular(h1)) cout<<"YES\n";
    else cout<<"NO\n";

    // make the next pointer of last node point to first node
    Node* i = h1;
    while(i->next!=NULL){
        i = i->next;
    }

    i->next = h1;

    // now the linked list is made circular
    // 1->2->3->4->5
    //  \----------/

    // let's check if our function finds out or not
    if(isCircular(h1)) cout<<"YES\n";
    else cout<<"NO\n";

    // make the next pointer of last node point to second node
    i->next = (h1->next);

    // now the linked list isn't circular
    // but has a loop
    // 1->2->3->4->5
    //    \--------/

    // let's check if our function finds out or not
    if(isCircular(h1)) cout<<"YES\n";
    else cout<<"NO\n";
}

 
class Circular
{
    
static class Node
{
    int data;
    Node next;
}
 
static boolean isCircular( Node head)
{
   
    if (head == null)
    return true;
 
    Node node = head.next;
    while (node != null && node != head)
    node = node.next;

    return (node == head);
}
 

static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = data;
    temp.next = null;
    return temp;
}
public static void main(String args[])
{
    Node head = newNode(1);
    head.next = newNode(2);
    head.next.next = newNode(3);
    head.next.next.next = newNode(4);
 
    System.out.print(isCircular(head)? "Yes\n" :"No\n" );
 
    head.next.next.next.next = head;
 
    System.out.print(isCircular(head)? "Yes\n" :"No\n" );
 
}
}

# Node structure of a doubly linked list node
class Node:
	def __init__(self, data):
		self.data = data
		self.next = None
		self.prev = None

# Using this function we will be inserting a new node in the list
def insert(head_ref, data):
	
	new_node = Node(data)
	new_node.data = data
	if (head_ref == None):

		new_node.next = new_node
		new_node.prev = new_node

	else :
		
		last = head_ref.prev
		new_node.next = head_ref
		new_node.prev = last
		last.next = new_node
		head_ref.prev = new_node
	
	head_ref = new_node
	return head_ref

# Using this function we will be merging two sorted doubly linked list
# merge2SortedDLL stands for merge two sorted doubly linked list
def merge(first, second):
	
	if (first == None):
		return second

	if (second == None):
		return first

	if (first.data < second.data) :
		first.next = merge(first.next,
						second)
		first.next.prev = first
		first.prev = None
		return first
	
	else :
		second.next = merge(first,
							second.next)
		second.next.prev = second
		second.prev = None
		return second
	
# Using this function we will be merging two sorted doubly circular linked list
# merge2SortedDCLL stands for merge two sorted doubly circular linked list
def merge2SortedDCLL(head1, head2):
	
	if (head1 == None):
		return head2

	if (head2 == None):
		return head1

	if (head1.prev.data < head2.prev.data):
		last_node = head2.prev
	else:
		last_node = head1.prev

	head1.prev.next = None
	head2.prev.next = None

	finalHead = merge(head1, head2)

	finalHead.prev = last_node
	last_node.next = finalHead

	return finalHead

# Using this function we will be printing the linked list content
def printList(head):
	temp = head

	while (temp.next != head):
		print(temp.data, end = " ")
		temp = temp.next
	
	print(temp.data, end = " ")

if __name__=='__main__':
	head1 = None
	head2 = None

	head1 = insert(head1, 7)
	head1 = insert(head1, 5)
	head1 = insert(head1, 3)
	head1 = insert(head1, 1)

	print("Original linked list 1: ", end = "")
	printList(head1)
	print()

	head2 = insert(head2, 8)
	head2 = insert(head2, 6)
	head2 = insert(head2, 4)
	head2 = insert(head2, 2)

	print("Original linked list 2: ", end = "")
	printList(head2)
	print()
	newHead = merge2SortedDCLL(head1, head2)

	print("Final Sorted List: ", end = "")
	printList(newHead)