Find Merge Point of Two Lists

                            Solution in C :

In C++ :

/*
   Find merge point of two linked lists
   Node is defined as
   struct Node
   {
       int data;
       Node* next;
   }
*/
int getCount(Node* head)
{
  Node* current = head;
  int count = 0;
 
  while (current != NULL)
  {
    count++;
    current = current->next;
  }
 
  return count;
}

int getNode(int d, Node* head1, Node* head2)
{
  int i;
  Node* current1 = head1;
  Node* current2 = head2;
 
  for(i = 0; i < d; i++)
  {
    if(current1 == NULL)
    {  return -1; }
    current1 = current1->next;
  }
 
  while(current1 !=  NULL && current2 != NULL)
  {
    if(current1 == current2)
      return current1->data;
    current1= current1->next;
    current2= current2->next;
  }
 
  return -1;
}

int FindMergeNode(Node *headA, Node *headB)
{
    // Complete this function
    // Do not write the main method. 
    int c1 = getCount(headA);
  int c2 = getCount(headB);
  int d;
 
  if(c1 > c2)
  {
    d = c1 - c2;
    return getNode(d, headA, headB);
  }
  else
  {
    d = c2 - c1;
    return getNode(d, headB, headA);
  }
}




In Java : 



/*
  Insert Node at the end of a linked list 
  head pointer input could be NULL as well for empty list
  Node is defined as 
  class Node {
     int data;
     Node next;
  }
*/
int FindMergeNode(Node headA, Node headB) {
    // Complete this function
    // Do not write the main method. 
      
    int countA=0;
    int countB=0;
    
    Node tempA=headA;
    Node tempB=headB;

    while(tempA!=null)
        {
        countA++;
        tempA=tempA.next;
    }
    
    
    while(tempB!=null)
        {
        countB++;
        tempB=tempB.next;
    }
    int diff=0;
    if(countA>countB)
        diff=countA-countB;
    else
        diff=countB-countA;
    tempA=headA;
    tempB=headB;
    if(countA>countB)
        {
         while(diff >0)
         {tempA=tempA.next;
         diff--;}
        
    }
    else
        {while(diff >0)
        { tempB=tempB.next;
          diff--;}
        
        
        }
    
    while(tempA!=null && tempB!=null)
    {
        
        tempA=tempA.next;
        tempB=tempB.next;
        if(tempA==tempB)
            return tempA.data;
        
    }
    return 0;
    

}



In python3 :



"""
 Find the node at which both lists merge and return the data of that node.
 head could be None as well for empty list
 Node is defined as
 
 class Node(object):
 
   def __init__(self, data=None, next_node=None):
       self.data = data
       self.next = next_node

 
"""

def FindMergeNode(a, b):
    h = {}
    while a != None:
        h[a.data] = a.data
        a = a.next
    while b != None:
        if b.data in h:
            return h[b.data]
        b = b.next
    return None
  
  
  
  
  
  In C :


// Complete the findMergeNode function below.

/*
 * For your reference:
 *
 * SinglyLinkedListNode {
 *     int data;
 *     SinglyLinkedListNode* next;
 * };
 *
 */
#include <math.h>
int findMergeNode(SinglyLinkedListNode *headA, SinglyLinkedListNode *headB)
{
    // Complete this function
    // Do not write the main method. 
    int countA = 0;
    int countB = 0;
    struct SinglyLinkedListNode *tempHeadA, *tempHeadB;
    tempHeadA = headA;
    tempHeadB = headB;
    
    while(tempHeadA != NULL){
        countA++;
        tempHeadA = tempHeadA->next;
    }
    while(tempHeadB != NULL){
        countB++;
        tempHeadB = tempHeadB->next;
    }
    
    // printf("%d %d", countA,countB);
    int biggerNodeExtraNodes = abs(countA - countB);
    // printf("%d", biggerNodeExtraNodes);
    while(biggerNodeExtraNodes--){
         printf("33333333333");
        if(countA > countB){
            headA = headA->next;
        } else{
             headB = headB->next;
        }
    }
    while(headA != NULL){
        printf("asdfghjklpoiuytredxdcfgh");
        if(headA == headB){
            return headA->data;
        }else{
             headA = headA->next;
             headB = headB->next;
        }
    }
    return 1;
}