Print the alternate nodes of linked list (Iterative Method)

Last Updated : 20 Mar, 2023

Given a linked list, print the alternate nodes of the linked list.
Examples:

Input : 1 -> 8 -> 3 -> 10 -> 17 -> 22 -> 29 -> 42
Output : 1 -> 3 -> 17 -> 29
Alternate nodes : 1 -> 3 -> 17 -> 29

Input : 10 -> 17 -> 33 -> 38 -> 73
Output : 10 -> 33 -> 73
Alternate nodes : 10 -> 33 -> 73

Approach :

Traverse the whole linked list.
Set count = 0.
Print node when the count is even.
Visit the next node.

Implementation:

C++

// CPP code to print Alternate Nodes 
#include <iostream>
using namespace std;
 
/* Link list node */
struct Node
{ 
    int data; 
    struct Node* next; 
}; 
 
/* Function to get the alternate 
nodes of the linked list */
void printAlternateNode(struct Node* head) 
{ 
    int count = 0; 
 
    while (head != NULL)
    { 
 
        // when count is even print the nodes 
        if (count % 2 == 0) 
            cout  << head->data << " "; 
 
        // count the nodes 
        count++; 
 
        // move on the next node. 
        head = head->next; 
    } 
} 
 
// Function to push node at head 
void push(struct Node** head_ref, int new_data) 
{ 
    struct Node* new_node = 
        (struct Node*)malloc(sizeof(struct Node)); 
    new_node->data = new_data; 
    new_node->next = (*head_ref); 
    (*head_ref) = new_node; 
} 
 
// Driver code 
int main() 
{ 
    /* Start with the empty list */
    struct Node* head = NULL; 
 
    /* Use push() function to construct 
    the below list 8 -> 23 -> 11 -> 29 -> 12 */
    push(&head, 12); 
    push(&head, 29); 
    push(&head, 11); 
    push(&head, 23); 
    push(&head, 8); 
 
    printAlternateNode(head); 
 
    return 0; 
} 
 
// This code is contributed by shubhamsingh10

C

// C code to print Alternate Nodes
#include <stdio.h>
#include <stdlib.h>
 
/* Link list node */
struct Node {
    int data;
    struct Node* next;
};
 
/* Function to get the alternate
   nodes of the linked list */
void printAlternateNode(struct Node* head)
{
    int count = 0;
 
    while (head != NULL) {
 
        // when count is even print the nodes
        if (count % 2 == 0) 
            printf(" %d ", head->data);
 
        // count the nodes
        count++;
 
        // move on the next node.
        head = head->next;
    }
}
 
// Function to push node at head
void push(struct Node** head_ref, int new_data)
{
    struct Node* new_node = 
          (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
 
// Driver code
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;
 
    /* Use push() function to construct
       the below list 8 -> 23 -> 11 -> 29 -> 12 */
    push(&head, 12);
    push(&head, 29);
    push(&head, 11);
    push(&head, 23);
    push(&head, 8);
 
    printAlternateNode(head);
 
    return 0;
}

Java

// Java code to print Alternate Nodes 
class GFG
{
     
/* Link list node */
static class Node
{ 
    int data; 
    Node next; 
}; 
 
/* Function to get the alternate 
nodes of the linked list */
static void printAlternateNode( Node head) 
{ 
    int count = 0; 
 
    while (head != null)
    { 
 
        // when count is even print the nodes 
        if (count % 2 == 0) 
            System.out.printf(" %d ", head.data); 
 
        // count the nodes 
        count++; 
 
        // move on the next node. 
        head = head.next; 
    } 
} 
 
// Function to push node at head 
static Node push( Node head_ref, int new_data) 
{ 
    Node new_node = new Node(); 
    new_node.data = new_data; 
    new_node.next = (head_ref); 
    (head_ref) = new_node;
    return head_ref;
} 
 
// Driver code 
public static void main(String args[]) 
{ 
    /* Start with the empty list */
    Node head = null; 
 
    /* Use push() function to con 
    the below list 8 . 23 . 11 . 29 . 12 */
    head = push(head, 12); 
    head = push(head, 29); 
    head = push(head, 11); 
    head = push(head, 23); 
    head = push(head, 8); 
 
    printAlternateNode(head); 
}
} 
 
// This code is contributed by Arnab Kundu

Python3

# Python3 code to print Alternate Nodes
 
# Link list node
class Node : 
     
    def __init__(self, data = None) :
        self.data = data
        self.next = None
     
    # Function to push node at head
    def push(self, data) :
         
        new = Node(data)
        new.next = self
        return new
     
    # Function to get the alternate
    # nodes of the linked list     
    def printAlternateNode(self) :
        head = self
         
        while head and head.next != None :
             
            print(head.data, end = " ")
            head = head.next.next
 
 
# Driver Code        
node = Node()
 
# Use push() function to construct
# the below list 8 -> 23 -> 11 -> 29 -> 12
node = node.push(12)
node = node.push(29)
node = node.push(11)
node = node.push(23)
node = node.push(8)
 
node.printAlternateNode()

C#

// C# code to print Alternate Nodes
using System;
 
class GFG 
{ 
     
/* Link list node */
public class Node 
{ 
    public int data; 
    public Node next; 
}; 
 
/* Function to get the alternate 
nodes of the linked list */
static void printAlternateNode( Node head) 
{ 
    int count = 0; 
 
    while (head != null) 
    { 
 
        // when count is even print the nodes 
        if (count % 2 == 0) 
            Console.Write(" {0} ", head.data); 
 
        // count the nodes 
        count++; 
 
        // move on the next node. 
        head = head.next; 
    } 
} 
 
// Function to push node at head 
static Node push( Node head_ref, int new_data) 
{ 
    Node new_node = new Node(); 
    new_node.data = new_data; 
    new_node.next = (head_ref); 
    (head_ref) = new_node; 
    return head_ref; 
} 
 
// Driver code 
public static void Main(String []args) 
{ 
    /* Start with the empty list */
    Node head = null; 
 
    /* Use push() function to con 
    the below list 8 . 23 . 11 . 29 . 12 */
    head = push(head, 12); 
    head = push(head, 29); 
    head = push(head, 11); 
    head = push(head, 23); 
    head = push(head, 8); 
 
    printAlternateNode(head); 
} 
} 
 
// This code has been contributed by 29AjayKumar

Javascript

// JavaScript code to print alternate nodes
// link list node
class Node{
    constructor(data){
        this.data = data;
        this.next = null;
    }
}
 
// function to get the alternate
// nodes of the linked list
function printAlternateNode(head){
    let count = 0;
    while(head != null)
    {
     
        // when count is even print the nodes
        if(count % 2 == 0)
            console.log(head.data + " ");
         
        // increment the count
        count++;
         
        // move to the next node
        head = head.next;
    }
}
 
// function to push node at beginning
function push(head_ref, new_data){
    let new_node = new Node(new_data);
    new_node.next = head_ref;
    head_ref = new_node;
    return head_ref;
}
 
// driver code
let head = null;
 
// Use push() function to construct
// the below list 8 -> 23 -> 11 -> 29 -> 12
head = push(head, 12);
head = push(head, 29);
head = push(head, 11);
head = push(head, 23);
head = push(head, 8);
 
printAlternateNode(head);
 
// this code is contributed by Yash Agarwal(yashagarwal2852002)

Output

8 11 12

Time Complexity : O(n)
Auxiliary Space : O(1)

Asked in : Govivace

Efficient Approach(Without using extra variable count):
Follow the below steps to solve the given problem:
1) We simply traverse the linked list but rather moving to the next node we will move next to next node at each time and print the head data.
Below is the implementation of above approach:

C++

// C++ Program to print the alternates nodes 
// without using count variable
#include<bits/stdc++.h>
using namespace std;
 
// link list node
struct Node{
    int data;
    Node* next;
    Node(int data){
        this->data = data;
        this->next = NULL;
    }
};
 
// function to get the alternate
// nodes of the linked list
void printAlternateNode(Node* head){
    while(head != NULL){
        cout<<head->data<<" ";
        if(head->next != NULL){
            head = head->next->next;
        }
        else{
            head = head->next;
        }
    }
}
 
// driver program
int main(){
    Node* head = new Node(8);
    head->next = new Node(23);
    head->next->next = new Node(11);
    head->next->next->next = new Node(29);
    head->next->next->next->next = new Node(12);
     
    printAlternateNode(head);
    return 0;
}
 
// THIS CODE IS CONTRIBUTED BY KIRTI AGARWAL(KIRTIAGARWAL23121999)

Python3

# Python program to print the alternates node
# without using count variable
# link list node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
     
     
# function to get the alternate
# nodes of the linked list
def printAlternateNode(head):
    while(head is not None):
        print(head.data, end=" ")
        if(head.next is not None):
            head = head.next.next
        else:
            head = head.next
         
 
# driver program
head = Node(8)
head.next = Node(23)
head.next.next = Node(11)
head.next.next.next = Node(29)
head.next.next.next.next = Node(12)
 
printAlternateNode(head)

Java

// C++ Program to print the alternates nodes
// without using count variable
public class LinkedList {
    Node head;
    // link list node
    static class Node {
        int data;
        Node next;
        Node(int d)
        {
            data = d;
            next = null;
        }
    }
    // function to get the alternate
    // nodes of the linked list
    public void printAlternateNode(Node head)
    {
        while (head != null) {
            System.out.print(head.data + " ");
            if (head.next != null) {
                head = head.next.next;
            }
            else {
                head = head.next;
            }
        }
    }
    // driver program
    public static void main(String[] args)
    {
        LinkedList llist = new LinkedList();
        llist.head = new Node(8);
        Node second = new Node(23);
        Node third = new Node(11);
        Node fourth = new Node(29);
        Node fifth = new Node(12);
        llist.head.next = second;
        second.next = third;
        third.next = fourth;
        fourth.next = fifth;
        llist.printAlternateNode(llist.head);
    }
}

C#

// C# Program to print the alternates nodes
// without using count variable
using System;
 
// link list node
public class Node {
    public int data;
    public Node next;
    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}
 
public class Program {
    // function to get the alternate
    // nodes of the linked list
    public static void printAlternateNode(Node head)
    {
        while (head != null) {
            Console.Write(head.data + " ");
            if (head.next != null) {
                head = head.next.next;
            }
            else {
                head = head.next;
            }
        }
    } // driver program
    public static void Main()
    {
        Node head = new Node(8);
        head.next = new Node(23);
        head.next.next = new Node(11);
        head.next.next.next = new Node(29);
        head.next.next.next.next = new Node(12);
 
        printAlternateNode(head);
    }
}

Javascript

// C++ Program to print the alternates nodes
// without using count variable
// link list node
class Node{
    constructor(data){
        this.data = data;
        this.next = null;
    }
}
 
// function to get the alternate
// nodes of the linked list
function printAlternateNode(head){
    while(head != null){
        console.log(head.data + " ");
        if(head.next != null){
            head = head.next.next;
        }
        else{
            head = head.next;
        }
    }
}
 
// driver program
let head = new Node(8);
head.next = new Node(23);
head.next.next = new Node(11);
head.next.next.next = new Node(29);
head.next.next.next.next = new Node(12);
  
printAlternateNode(head);

Output

8 11 12

Time Complexity: O(N) where N is the number of nodes in the Linked List.
Auxiliary Space: O(1)

Product of the alternate nodes of linked list

shrikanth13

Improve

Print the alternate nodes of linked list (Iterative Method)

C++

C

Java

Python3

C#

Javascript

C++

Python3

Java

C#

Javascript

Similar Reads

What kind of Experience do you want to share?