Traversal in Linked List

import java.io.*;

class ListNode {
    int val; 
    ListNode next; 
    ListNode(int data1) {
        val = data1;
        next = null;
    }

    ListNode(int data1, ListNode next1) {
        val = data1;
        next = next1;
    }
}


class Solution {
     //Function for Linked List Traversal
    public List<Integer> LLTraversal(ListNode head) {
        //Storing a copy of the linked list
        ListNode temp = head;
        //To store the values sequentially
        List<Integer> ans = new ArrayList<>();
        
        //Keep traversing
        //Until null is encountered
        while (temp != null) {
            //Storing the values
            ans.add(temp.val);
            //Storing the address of the next node
            temp = temp.next;
        }
        //Return answer
        return ans;
    }
}

public class Main {
    public static void main(String[] args) {
        //Manual creation of nodes
        ListNode y1 = new ListNode(2);
        ListNode y2 = new ListNode(5);
        ListNode y3 = new ListNode(8);
        ListNode y4 = new ListNode(7);

        // Linking the nodes
        y1.next = y2;
        y2.next = y3;
        y3.next = y4;

        // Creating an instance of 
        //Solution class
        Solution solution = new Solution();

        // Calling LLTraversal method 
        //To get the values
        List<Integer> result = solution.LLTraversal(y1);

        // Printing the result
        System.out.println("Linked List Values:");
        for (int val : result) {
            System.out.print(val + " ");
        }
        System.out.println();
    }
}

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    # Function for Linked List Traversal
    def LLTraversal(self, head: ListNode) -> list:
        # Storing a copy 
        #Of the linked list
        temp = head
        #To store 
        #Values sequentially
        ans = []

        #Keep traversing
        #Until the None 
        #Is not encountered
        while temp is not None:
            #Storing of the values
            ans.append(temp.val)
            #Storing the address 
            #Of the next node
            temp = temp.next

        #Returning the answer 
        return ans

if __name__ == "__main__":
    #Manual creation of nodes
    y1 = ListNode(2)
    y2 = ListNode(5)
    y3 = ListNode(8)
    y4 = ListNode(7)

    #Linking the nodes
    y1.next = y2
    y2.next = y3
    y3.next = y4

    #Solution class
    sol = Solution()

    #Calling LLTraversal method
    result = sol.LLTraversal(y1)

    #Printing the result
    print("Linked List Values:")
    for val in result:
        print(val, end=" ")
    print()

class ListNode {
    constructor(val = 0, next = null) {
        this.val = val;
        this.next = next;
    }
}

class Solution {
    //Function for 
    //Linked List Traversal
    LLTraversal(head) {
        //Storing a copy 
        //Of the linked list
        let temp = head;
        //To store the 
        //Values sequentially
        let ans = [];

        //Keep traversing 
        //Until the null is 
        //Not encountered
        while (temp !== null) {
            // Storing of the values
            ans.push(temp.val);
            //Storing the address 
            //Of the next node
            temp = temp.next;
        }

        //Return answer 
        return ans;
    }
}

//Manual creation of nodes
let y1 = new ListNode(2);
let y2 = new ListNode(5);
let y3 = new ListNode(8);
let y4 = new ListNode(7);

//Linking the nodes
y1.next = y2;
y2.next = y3;
y3.next = y4;

//Solution instance
let sol = new Solution();

// Calling LLTraversal method to get the values
let result = sol.LLTraversal(y1);

// Printing the result
console.log("Linked List Values:");
for (let val of result) {
    console.log(val + " ");
}