CareerCup

First check for cyclic or acyclic using slow and fast pointer.

If acyclic then it's easy to find out
If cyclic.
by help of slow and fast pointer find the no of nodes in loop.
let's say no of nodes in loop is L1
then start from head keep two pointer p1 and p2

move P2, L1 step ahead of P1 and then start moving them together and keep the counter with P1 once the collide u r the beginning of loop by the time counter will have value equal to linear link let's say L2

return L1 +L2

public void cyclicTest(Node node){

int num=0;
Node head=node;

if(node==null){
System.out.println("No Nodes: 0");
return;
}

while(node.next!=null){
num++;
node=node.next;
if(head==node){
System.out.println("Cyclic:"+ num);
return;
}
}

System.out.println("ACyclic:"+ (num+1));
}


////////////////////////////////////////////////
O(n) to compute cyclic or acyclic

fast = slow = headbackup = head;
count = 0;
do
{
	if( fast->next != NULL )
		fast = fast->next->next;
		count = count + 2;
	else
		return ++count;
	slow = slow->next
}while( slow != fast );
// the point at which slow and fast meet will be at the same distance from the start of the loop as the distance between head and start of the loop

// count the length of the LL segment that is not in the loop
count = 0;
while( headbackup != slow )
	count++;
	headbackup = headbackup->next;
	slow = slow->next;

// count the length of the LL segment that is in the loop
do
{
	count++;
	slow = slow->next;
while( slow != headbackup );

Here is a solution I think will work: have used slow and fast pointer to find the loop first then to count the number of nodes.

public int nodeCount(LinkedLists node){
  LinkedLists slow=head;
  LinkedLists fast=head;

  while(fast!=null && fast.next!=null) {
     slow = slow.next;
     fast = fast.next.next;
     if(slow==fast) //both pointers have collided
        break;
  }

  //Check if there are no loops at all
  if(fast==null || fast.next==null)
      return 0;
  // Now move slow to head, and increment slow and fast by one step so that they meet at the loop/cycle beginning point.
   slow = head;
   int countk = 0;
   while(slow!=fast) {
     slow = slow.next;
     fast = fast.next;
     countk++;
   }
   //Now keep the slow pointer there and increment fast pointer by 1, when slow==fast u have counted the entire list
   fast = fast.next;
   countk++;
   while(slow!=fast) {
      fast = fast.next;
      countk++;  
   }
   return countk;
}

This is my solution

#include <stdio.h>
#include <stdlib.h>

typedef struct __LinkedListNode__ {
	int data;
	struct __LinkedListNode__* next;
	
} LinkedListNode;

int count(LinkedListNode* head) {
	LinkedListNode* sp = head; //slow pointer
	LinkedListNode* fp = head; //fast pointer
	LinkedListNode* p = head; //follow up pointer
	
	int count = 0;
	if (head == NULL)
		return count;
		
	//Jump slow pointer once and fast pointer twice
	//till they meet if there is a cycle or if it terminates with NULL
	do {
		if (sp->next) {
			sp = sp->next;
			count++;
		}
		if (fp->next) {
			if (fp->next->next)
				fp = fp->next->next;
			else
				fp = fp->next; //ensures sp and fp meets if NULL encountered at end
		}
	} while (sp != fp);
	
	//no cycle. return count = slow jumps + 1
	if (sp->next == NULL)
		return count + 1;
	
	// Cycle begins from the head, return the slow jumps
	if (p == sp)
		return count;
		
	//Move followup pointer and fast pointer by one jump until they meet
	// This is the cycle head
	while (p != fp) {
		fp = fp->next;
		p = p->next;
	}
	
	//Move slow pointer till it meets the cycle head and return the count
	do {
		sp = sp->next;
		count++;
	} while (sp != p);
	
	return count;
}

void insert_at_beginning(LinkedListNode** head, int data) {
	if (*head == NULL) {
		*head = malloc(sizeof(LinkedListNode));
		(*head)->data = data;
		(*head)->next = NULL;
	} else {
		LinkedListNode* node = malloc(sizeof(LinkedListNode));
		node->data = data;
		node->next = *head;
		*head = node;
	}
}

void destroy(LinkedListNode* head) {
	LinkedListNode* node;
	while (head) {
		node = head;
		head = head->next;
		free(head);
	}
}

int main() {
	LinkedListNode* head = NULL;
	LinkedListNode* tail = NULL;
	LinkedListNode* cycle_head = NULL;
	
	insert_at_beginning(&head, 10);
	tail = head;
	insert_at_beginning(&head, 9);
	insert_at_beginning(&head, 8);
	insert_at_beginning(&head, 7);
	insert_at_beginning(&head, 6);
	cycle_head = head;
	insert_at_beginning(&head, 5);
	insert_at_beginning(&head, 4);
	insert_at_beginning(&head, 3);
	insert_at_beginning(&head, 2);
	insert_at_beginning(&head, 1);
	
	
	//Create a cycle
	tail->next = cycle_head;
	
	printf("count:%d\n",count(head));
	
	//Remove cycle for destruction
	tail->next = NULL;
	destroy(head);
}