find length of the linkedlist using recursive method

Find Length of a Linked List (Iterative and Recursive)

In this article, we will learn, how to calculate the length of a linked list using the iterative and recursive method.

Iterative method

An iterative method is the simplest way to calculate the length of the linked list. In the iterative method, we simply take a counter whose initial value is zero. Now we will trace the linked list till the last node using an iteration and increment the counter in each iteration.

STEPS

  • Initialize the counter with zero.
  • Initialize a node pointer with the head pointer, pTmpNode = head.
  • Trace the linked list until not getting the NULL pointer.
    pTmpNode = pTmpNode -> pNextNode
  • Increment counter on each iteration , iCounter ++.
/* This function use to prints the data of the list from the beginning
and get the length of list*/
 
void GetAndPrintTheList(NodePointer pNode,int *iLengthOfList)
{
  int iCounter = 0;
  NodePointer pTmpNode = pNode;
  printf("\nDisplay Linked List: \n\n");
  while (pTmpNode != NULL)
  {
     printf("\n %d\n",pTmpNode->iData);
     pTmpNode = pTmpNode->pNextNode;
     
     //Increment Countr for every itteration
     iCounter++;
  }
      
  (*iLengthOfList)    = iCounter;
      printf("\n\n");
  
}

Driver program to test the above function

#include<stdio.h>
#include<stdlib.h>
 
 
// Creating Node
 struct Node 
{
  int iData;
  struct Node *pNextNode;
};
 
 
// Define the new type Node type and Node pointer
typedef struct Node NodeType, * NodePointer;
 
 


 
/* Paas the reference of the head pointer of a list and 
  an integer data. This function use to add the node at the End*/
int InsertNodeAtEnd(NodePointer * pHead, int iUserData) 
{
  int iRetValue = -1;
  
  NodePointer pLastNode = NULL;
  NodePointer pNewNode = NULL;
  
  //Give the Address of first Node
  pLastNode = *pHead;
  
  // Call malloc to allocate memory in heap for the new node
  pNewNode = malloc(sizeof(NodeType));
  
  if( pNewNode != NULL) //Check allocated memory
  {
  pNewNode->iData = iUserData; //put the desire Data
  
  pNewNode->pNextNode = NULL; //Give the Address of first Node
  
  iRetValue = 0; // Update the return value
  
  }
  // If there is no node in beginning
  if(pLastNode == NULL)
  {
  *pHead = pNewNode;
  }
  else 
  {
  // Find the address of last node
  while( pLastNode ->pNextNode != NULL)
  {
  pLastNode = pLastNode ->pNextNode;
  }
  
  // Assign last node address
  pLastNode ->pNextNode = pNewNode;
 
  }
  
  return iRetValue;
}
 
/* Paas the reference of the head pointer of a list. This function use
to free the all allocated memory*/
void FreeAllocatedMemory(NodePointer *pHead)
{
  NodePointer pTmpNode = NULL;
  NodePointer pFirstNode = NULL;
  //Assign the Address of first node
  pFirstNode = *pHead;
  
/*check if pFirstNode is NULL, then now list is empty,
so assign NULL to head and return.*/
  while (pFirstNode != NULL)
  {
  /*Save the pFirstNode in a pTmpNode node pointer*/ 
 
  pTmpNode = pFirstNode ;
  
  /*Assign the address of next on your list*/ 
  pFirstNode = pFirstNode->pNextNode;
  
  //Free the allocated memory
  free(pTmpNode );
  }
  //Assign NULL to the head pointer
  *pHead = NULL;
 
}



 
/* This function use to prints the data of the list from the beginning
and get the length of list*/
 
void GetAndPrintTheList(NodePointer pNode,int *iLengthOfList)
{
  int iCounter = 0;
  NodePointer pTmpNode = pNode;
  printf("\nDisplay Linked List: \n\n");
  while (pTmpNode != NULL)
  {
  printf("\n %d\n",pTmpNode->iData);
  pTmpNode = pTmpNode->pNextNode;
  
  //Increment Countr for every itteration
  iCounter++;
  }
  
  (*iLengthOfList) = iCounter;
  printf("\n\n");
  
}




//Create a number of nodes
int CreateLinkedList(NodePointer *pHead, int iNumberofNode)
{
  int iData = 0;
  int iRetValue = -1;
  int iCount = 0;
  NodePointer pNewNode = NULL;
  
  for(iCount =0; iCount < iNumberofNode; iCount++)
  {
  /*Enter desire data*/
  printf("\n\nEnter the Data = ");
  scanf("%d",&iData);
  
  if((*pHead) == NULL)
  {
  // Call malloc to allocate memory in heap for the first node
  pNewNode = malloc(sizeof(NodeType));
  if( pNewNode != NULL) //Check allocated memory
  {
  pNewNode->iData = iData; //put the desire Data
  
  pNewNode->pNextNode = NULL; //Give the Address of first Node
  
  *pHead = pNewNode; /*Assign the address of 
  first node to the head pointer*/
  
  iRetValue = 0; // Update the return value
  
  }
  }
  else
  {
  //Add the Node at the End
  iRetValue = InsertNodeAtEnd(pHead,iData);
  
  }
  }
  
  return iRetValue;
}
 
 

int main(void)
{
  int iNumberNode =0;
  int LengthOfList = 0;
 
  
  /*Start with the empty list */
  NodePointer head = NULL;
  
  
  printf("\n\nEnter the number of nodes = ");
  scanf("%d",&iNumberNode);
  
  //Create a linked list of three node
  CreateLinkedList(&head,iNumberNode);
  


  //Print the created list and get the length
  GetAndPrintTheList(head,&LengthOfList);
  

  // Length of Linked List
  printf("Length of linked list = %d\n",LengthOfList);
  
  //Free the allocated memory 
  FreeAllocatedMemory(&head);
  
  return 0;
}

OutPut:




If you want to learn more about the c language, here 10 Free days (up to 200 minutes) C video course for you.

Your free trial is waiting

 

Recursive method

We can also find the length of the linked list using the recursive method. In which we will decrease the node and increase the counter in each recursive call.

Generally, people preferred the iterative method to calculate the length of the list because in the recursive method we are used stack memory in the calculation, if the size of the linked list is too long then might be you faced the stack overflow scenario.

STEPS:

  • If the head is NULL, return 0.
  • Else return 1 + GetAndPrintTheList(pNode->pNextNode).
/* Counts the no. of nodes */
int GetAndPrintTheList(NodePointer pNode)
{
    // Base case
    if (pNode == NULL)
        return 0;
 
    // count is 1 + count of remaining list
    return 1 + GetAndPrintTheList(pNode->pNextNode);
}

Driver program to test the above function

#include<stdio.h>
#include<stdlib.h>
 
 
// Creating Node
 struct Node 
{
  int iData;
  struct Node *pNextNode;
};
 
 
// Define the new type Node type and Node pointer
typedef struct Node NodeType, * NodePointer;
 
 


 
/* Paas the reference of the head pointer of a list and 
  an integer data. This function use to add the node at the End*/
int InsertNodeAtEnd(NodePointer * pHead, int iUserData) 
{
  int iRetValue = -1;
  
  NodePointer pLastNode = NULL;
  NodePointer pNewNode = NULL;
  
  //Give the Address of first Node
  pLastNode = *pHead;
  
  // Call malloc to allocate memory in heap for the new node
  pNewNode = malloc(sizeof(NodeType));
  
  if( pNewNode != NULL) //Check allocated memory
  {
  pNewNode->iData = iUserData; //put the desire Data
  
  pNewNode->pNextNode = NULL; //Give the Address of first Node
  
  iRetValue = 0; // Update the return value
  
  }
  // If there is no node in beginning
  if(pLastNode == NULL)
  {
  *pHead = pNewNode;
  }
  else 
  {
  // Find the address of last node
  while( pLastNode ->pNextNode != NULL)
  {
  pLastNode = pLastNode ->pNextNode;
  }
  
  // Assign last node address
  pLastNode ->pNextNode = pNewNode;
 
  }
  
  return iRetValue;
}
 
/* Paas the reference of the head pointer of a list. This function use
to free the all allocated memory*/
void FreeAllocatedMemory(NodePointer *pHead)
{
  NodePointer pTmpNode = NULL;
  NodePointer pFirstNode = NULL;
  //Assign the Address of first node
  pFirstNode = *pHead;
  
/*check if pFirstNode is NULL, then now list is empty,
so assign NULL to head and return.*/
  while (pFirstNode != NULL)
  {
  /*Save the pFirstNode in a pTmpNode node pointer*/ 
 
  pTmpNode = pFirstNode ;
  
  /*Assign the address of next on your list*/ 
  pFirstNode = pFirstNode->pNextNode;
  
  //Free the allocated memory
  free(pTmpNode );
  }
  //Assign NULL to the head pointer
  *pHead = NULL;
 
}



 
/* Counts the no. of nodes */
int GetAndPrintTheList(NodePointer pNode)
{
    // Base case
    if (pNode == NULL)
        return 0;
 
    // count is 1 + count of remaining list
    return 1 + GetAndPrintTheList(pNode->pNextNode);
}



//Create a number of nodes
int CreateLinkedList(NodePointer *pHead, int iNumberofNode)
{
  int iData = 0;
  int iRetValue = -1;
  int iCount = 0;
  NodePointer pNewNode = NULL;
  
  for(iCount =0; iCount < iNumberofNode; iCount++)
  {
  /*Enter desire data*/
  printf("\n\nEnter the Data = ");
  scanf("%d",&iData);
  
  if((*pHead) == NULL)
  {
  // Call malloc to allocate memory in heap for the first node
  pNewNode = malloc(sizeof(NodeType));
  if( pNewNode != NULL) //Check allocated memory
  {
  pNewNode->iData = iData; //put the desire Data
  
  pNewNode->pNextNode = NULL; //Give the Address of first Node
  
  *pHead = pNewNode; /*Assign the address of 
  first node to the head pointer*/
  
  iRetValue = 0; // Update the return value
  
  }
  }
  else
  {
  //Add the Node at the End
  iRetValue = InsertNodeAtEnd(pHead,iData);
  
  }
  }
  
  return iRetValue;
}
 
 

int main(void)
{
  int iNumberNode =0;
  int LengthOfList = 0;
 
  
  /*Start with the empty list */
  NodePointer head = NULL;
  
  
  printf("\n\nEnter the number of nodes = ");
  scanf("%d",&iNumberNode);
  
  //Create a linked list of three node
  CreateLinkedList(&head,iNumberNode);
  


  //Print the created list and get the length
  LengthOfList = GetAndPrintTheList(head);
  
 /*
 Linked list passed :1>2->3->4->5->Null ==============|
 Linked list passed :2->3->4->5->Null ===========|    |
 Linked list passed :3->4->5->Null =========|    |    |
 Linked list passed :4->5->Null ========|   |    |    |
 Linked list passed :5->Null ======|    |   |    |    |
 Linked list passed :Null ===|     |    |   |    |    |
                             |     |    |   |    |    |
 returned : 0            <===|     |    |   |    |    |
 returned : 1 + Recursive Call <===|    |   |    |    |
 returned : 1 + Recursive Call <========|   |    |    |
 returned : 1 + Recursive Call <============|    |    |
 returned : 1 + Recursive Call <=================|    |
 returned : 1 + Recursive Call <===================== |
 
 Now Length linked list = 1+1+1+1+1+0 
 
 */

  // Length of Linked List
  printf("\n\nLength of linked list = %d\n",LengthOfList);
  
  //Free the allocated memory 
  FreeAllocatedMemory(&head);
  
  return 0;
}

OutPut:

Note: In recursion, you can also use the static variable to find the length of the variable.

/* Counts the no. of nodes */
int GetAndPrintTheList(NodePointer pNode)
{
	//static variable
	static int iCount =0;
	
    // Base case
    if (pNode == NULL)
        return iCount;
 
     iCount++;
    // Recursive call of function
    GetAndPrintTheList(pNode->pNextNode);
   
}