Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Program to find size of Doubly Linked List

  • Difficulty Level : Basic
  • Last Updated : 23 May, 2021

Given a doubly linked list, the task is to find the size of that doubly linked list. For example, size of below linked list is 4.
 

dll

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 



 

A doubly linked list is a linked data structure that consists of a set of sequentially linked records called nodes. Each node contains two fields, called links, that are references to the previous and to the next node in the sequence of nodes.
Traversal of a doubly linked list can be in either direction. In fact, the direction of traversal can change many times, if desired.

For example the function should return 3 for the above doubly linked list.
 

Algorithm :

1) Initialize size to 0. 
2) Initialize a node pointer, temp = head. 
3) Do following while temp is not NULL 
……a) temp = temp -> next 
……b) size++; 
4) Return size.
 

C++




// A complete working C++ program to
// find size of doubly linked list.
#include <bits/stdc++.h>
using namespace std;
 
// A linked list node
struct Node
{
    int data;
    struct Node *next;
    struct Node *prev;
};
 
/* Function to add a node to front of doubly
   linked list */
void push(struct Node** head_ref, int new_data)
{
    struct Node* new_node = new Node;
    new_node->data  = new_data;
    new_node->next = (*head_ref);
    new_node->prev = NULL;
    if ((*head_ref) !=  NULL)
      (*head_ref)->prev = new_node ;
    (*head_ref)    = new_node;
}
 
// This function returns size of linked list
int findSize(struct Node *node)
{
   int res = 0;
   while (node != NULL)
   {
       res++;
       node = node->next;
   }
   return res;
}
 
/* Driver program to test above functions*/
int main()
{
    struct Node* head = NULL;
    push(&head, 4);
    push(&head, 3);
    push(&head, 2);
    push(&head, 1);
    cout << findSize(head);
    return 0;
}

Java




// A complete working Java program to
// find size of doubly linked list.
import java.io.*;
import java.util.*;
 
// Represents a doubly linked list node
class Node
{
    int data;
    Node next, prev;
    Node(int val)
    {
        data = val;
        next = null;
        prev = null;
    }
}
 
class GFG
{
 
    /* Function to add a node to front of doubly
    linked list */
    static Node push(Node head, int data)
    {
        Node new_node = new Node(data);
        new_node.next = head;
        new_node.prev = null;
        if (head != null)
            head.prev = new_node;
        head = new_node;
             
        return head;
    }
 
    // This function returns size of doubly linked list
    static int findSize(Node node)
    {
        int res = 0;
        while (node != null)
        {
                res++;
                node = node.next;
        }
 
        return res;
    }
 
    // Driver Code
    public static void main(String args[])
    {
        Node head = null;
        head = push(head, 4);
        head = push(head, 3);
        head = push(head, 2);
        head = push(head, 1);
        System.out.println(findSize(head));
    }
}
 
// This code is contributed by rachana soma

Python3




# A complete working Python3 program to
# find size of doubly linked list.
 
# A linked list node
class Node:
    def __init__(self):
        self.data = None
        self.next = None
        self.prev = None
 
# Function to add a node to front of doubly
# linked list
def push( head_ref, new_data):
 
    new_node = Node()
    new_node.data = new_data
    new_node.next = (head_ref)
    new_node.prev = None
    if ((head_ref) != None):
        (head_ref).prev = new_node
    (head_ref) = new_node
    return head_ref
 
# This function returns size of linked list
def findSize(node):
 
    res = 0
    while (node != None):
        res = res + 1
        node = node.next
     
    return res
 
# Driver code
head = None
head = push(head, 4)
head = push(head, 3)
head = push(head, 2)
head = push(head, 1)
print(findSize(head))
 
# This code is contributed by Arnab Kundu

C#




// A complete working C# program to
// find size of doubly linked list.
 using System;
 
// Represents a doubly linked list node
public class Node
{
    public int data;
    public Node next, prev;
    public Node(int val)
    {
        data = val;
        next = null;
        prev = null;
    }
}
 
class GFG
{
 
    /* Function to add a node to front of doubly
    linked list */
    static Node push(Node head, int data)
    {
        Node new_node = new Node(data);
        new_node.next = head;
        new_node.prev = null;
        if (head != null)
            head.prev = new_node;
        head = new_node;
             
        return head;
    }
 
    // This function returns size of doubly linked list
    static int findSize(Node node)
    {
        int res = 0;
        while (node != null)
        {
                res++;
                node = node.next;
        }
 
        return res;
    }
 
    // Driver Code
    public static void Main(String []args)
    {
        Node head = null;
        head = push(head, 4);
        head = push(head, 3);
        head = push(head, 2);
        head = push(head, 1);
        Console.WriteLine(findSize(head));
    }
}
 
// This code is contributed by Arnab Kundu

Javascript




<script>
// A complete working javascript program to
// find size of doubly linked list.
// Represents a doubly linked list node
 class Node {
        constructor(val) {
            this.data = val;
            this.prev = null;
            this.next = null;
        }
    }
    /*
     * Function to add a node to front of doubly linked list
     */
    function push(head , data) {
var new_node = new Node(data);
        new_node.next = head;
        new_node.prev = null;
        if (head != null)
            head.prev = new_node;
        head = new_node;
 
        return head;
    }
 
    // This function returns size of doubly linked list
    function findSize(node) {
        var res = 0;
        while (node != null) {
            res++;
            node = node.next;
        }
 
        return res;
    }
 
    // Driver Code
     
var head = null;
        head = push(head, 4);
        head = push(head, 3);
        head = push(head, 2);
        head = push(head, 1);
        document.write(findSize(head));
 
// This code contributed by aashish1995
</script>
Output: 
4

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!