Encuentre la suma de Nodes pares e impares en una lista vinculada

Dada una lista enlazada, la tarea es encontrar la suma de los Nodes pares e impares en ella por separado.
Ejemplos: 
 

Entrada: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 
Salida: 
Suma par = 12 
Suma impar = 16
Entrada: 5 -> 7 -> 8 -> 10 -> 15 
Salida: 
Suma par = 18 
Suma impar = 27 
 

Enfoque: recorrer toda la lista enlazada y para cada Node: – 
 

1. Si el elemento es par, entonces agregamos ese elemento a la variable que contiene la suma de los elementos pares.
2. Si el elemento es impar, agregamos ese elemento a la variable que contiene la suma de los elementos impares.

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <iostream>
using namespace std;
 
// Represents node of the linked list
struct Node {
    int data;
    Node* next;
};
 
// Function to insert a node at the
// end of the linked list
void insert(Node** root, int item)
{
    Node *ptr = *root, *temp = new Node;
    temp->data = item;
    temp->next = NULL;
 
    if (*root == NULL)
        *root = temp;
    else {
        while (ptr->next != NULL)
            ptr = ptr->next;
        ptr->next = temp;
    }
}
 
// Function to print the sum of even
// and odd nodes of the linked lists
void evenOdd(Node* root)
{
    int odd = 0, even = 0;
    Node* ptr = root;
    while (ptr != NULL) {
 
        // If current node's data is even
        if (ptr->data % 2 == 0)
            even += ptr->data;
 
        // If current node's data is odd
        else
            odd += ptr->data;
 
        // ptr now points to the next node
        ptr = ptr->next;
    }
 
    cout << "Even Sum = " << even << endl;
    cout << "Odd Sum = " << odd << endl;
}
 
// Driver code
int main()
{
    Node* root = NULL;
    insert(&root, 1);
    insert(&root, 2);
    insert(&root, 3);
    insert(&root, 4);
    insert(&root, 5);
    insert(&root, 6);
    insert(&root, 7);
 
    evenOdd(root);
 
    return 0;
}

// Java implementation of the approach
class GfG
{
 
// Represents node of the linked list
static class Node
{
    int data;
    Node next;
}
static Node root;
 
// Function to insert a node at the
// end of the linked list
static void insert(int item)
{
    Node ptr = root, temp = new Node();
    temp.data = item;
    temp.next = null;
 
    if (root == null)
        root = temp;
    else
    {
        while (ptr.next != null)
            ptr = ptr.next;
        ptr.next = temp;
    }
}
 
// Function to print the sum of even
// and odd nodes of the linked lists
static void evenOdd(Node root)
{
    int odd = 0, even = 0;
    Node ptr = root;
    while (ptr != null)
    {
 
        // If current node's data is even
        if (ptr.data % 2 == 0)
            even += ptr.data;
 
        // If current node's data is odd
        else
            odd += ptr.data;
 
        // ptr now points to the next node
        ptr = ptr.next;
    }
 
    System.out.println("Even Sum = " + even);
    System.out.println("Odd Sum = " + odd);
}
 
// Driver code
public static void main(String[] args)
{
    // Node* root = NULL;
    insert( 1);
    insert( 2);
    insert( 3);
    insert( 4);
    insert(5);
    insert(6);
    insert( 7);
 
    evenOdd(root);
}
}
 
// This code is contributed by Prerna Saini

# Python3 implementation of the approach
import math
 
# Represents node of the linked list
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
# Function to insert a node at the
# end of the linked list
def insert(root, item):
    ptr = root
    temp = Node(item)
    temp.data = item
    temp.next = None
 
    if (root == None):
        root = temp
    else:
        while (ptr.next != None):
            ptr = ptr.next
        ptr.next = temp
     
    return root
 
# Function to print the sum of even
# and odd nodes of the linked lists
def evenOdd(root):
    odd = 0
    even = 0
    ptr = root
    while (ptr != None):
 
        # If current node's data is even
        if (ptr.data % 2 == 0):
            even = even + ptr.data
 
        # If current node's data is odd
        else:
            odd = odd + ptr.data
 
        # ptr now points to the next node
        ptr = ptr.next
     
    print( "Even Sum = ", even)
    print( "Odd Sum = ", odd)
 
# Driver code
if __name__=='__main__':
    root = None
    root = insert(root, 1)
    root = insert(root, 2)
    root = insert(root, 3)
    root = insert(root, 4)
    root = insert(root, 5)
    root = insert(root, 6)
    root = insert(root, 7)
 
    evenOdd(root)
 
# This code is contributed by AbhiThakur

// C# implementation of the approach
using System;
 
class GfG
{
 
// Represents node of the linked list
public class Node
{
    public int data;
    public Node next;
}
static Node root;
 
// Function to insert a node at the
// end of the linked list
static void insert(int item)
{
    Node ptr = root, temp = new Node();
    temp.data = item;
    temp.next = null;
 
    if (root == null)
        root = temp;
    else
    {
        while (ptr.next != null)
            ptr = ptr.next;
        ptr.next = temp;
    }
}
 
// Function to print the sum of even
// and odd nodes of the linked lists
static void evenOdd(Node root)
{
    int odd = 0, even = 0;
    Node ptr = root;
    while (ptr != null)
    {
 
        // If current node's data is even
        if (ptr.data % 2 == 0)
            even += ptr.data;
 
        // If current node's data is odd
        else
            odd += ptr.data;
 
        // ptr now points to the next node
        ptr = ptr.next;
    }
 
    Console.WriteLine("Even Sum = " + even);
    Console.WriteLine("Odd Sum = " + odd);
}
 
// Driver code
public static void Main(String []args)
{
    // Node* root = NULL;
    insert( 1);
    insert( 2);
    insert( 3);
    insert( 4);
    insert(5);
    insert(6);
    insert( 7);
 
    evenOdd(root);
}
}
 
// This code is contributed by Arnab Kundu

<script>
 
// Javascript implementation of the approach
 
// Represents node of the linked list
class Node {
        constructor() {
                this.data = 0;
                this.next = null;
             }
        }
         
         
// Function to insert a node at the
// end of the linked list
function insert( item)
{
    var ptr = root, temp = new Node();
    temp.data = item;
    temp.next = null;
 
    if (root == null)
        root = temp;
    else
    {
        while (ptr.next != null)
            ptr = ptr.next;
        ptr.next = temp;
    }
}
 
// Function to print the sum of even
// and odd nodes of the linked lists
function evenOdd( root)
{
    let odd = 0, even = 0;
    let ptr = root;
    while (ptr != null)
    {
 
        // If current node's data is even
        if (ptr.data % 2 == 0)
            even += ptr.data;
 
        // If current node's data is odd
        else
            odd += ptr.data;
 
        // ptr now points to the next node
        ptr = ptr.next;
    }
 
    document.write("Even Sum = " + even);
    document.write("</br>");
    document.write("Odd Sum = " + odd);
}
 
 
// Driver Code
 
var root = null;
insert( 1);
insert( 2);
insert( 3);
insert( 4);
insert(5);
insert(6);
insert( 7);
 
evenOdd(root);
 
// This code is contributed by jana_sayantan.
</script>

Even Sum = 12
Odd Sum = 16