Print all triplets with sum S in given sorted Linked List

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

// Define the Node class for the linked list
class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class TripletsInLinkedList {
    // Function to find triplets in the linked list that sum to S
    public static List<Triplet> findTriplets(Node head, int S) {
        List<Triplet> triplets = new ArrayList<>();
        Node ptr1 = head;

        while (ptr1 != null) {
            Node ptr2 = ptr1.next;

            while (ptr2 != null) {
                Node ptr3 = ptr2.next;

                while (ptr3 != null) {
                    if (ptr1.data + ptr2.data + ptr3.data == S) {
                        // Check if the triplet is distinct (all elements are unique)
                        if (ptr1.data != ptr2.data && ptr1.data != ptr3.data && ptr2.data != ptr3.data) {
                            Triplet triplet = new Triplet(ptr1.data, ptr2.data, ptr3.data);
                            triplets.add(triplet);
                        }
                    }
                    ptr3 = ptr3.next;
                }
                ptr2 = ptr2.next;
            }
            ptr1 = ptr1.next;
        }

        return triplets;
    }

    // Main function to test the code
    public static void main(String[] args) {
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(4);
        head.next.next.next = new Node(5);
        head.next.next.next.next = new Node(6);
        head.next.next.next.next.next = new Node(8);
        head.next.next.next.next.next.next = new Node(9);

        int S = 15;
        List<Triplet> triplets = findTriplets(head, S);

        for (Triplet triplet : triplets) {
            System.out.println("(" + triplet.first + ", " + triplet.second + ", " + triplet.third + ")");
        }
    }

    // Define a custom Triplet class to store the triplet values
    static class Triplet {
        int first, second, third;

        Triplet(int first, int second, int third) {
            this.first = first;
            this.second = second;
            this.third = third;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Triplet triplet = (Triplet) o;
            return first == triplet.first && second == triplet.second && third == triplet.third;
        }

        @Override
        public int hashCode() {
            return Objects.hash(first, second, third);
        }
    }
}

// Java code to find 
// all distinct triplets having sum S
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;

class GFG 
{
  
    // Structure of node of singly linked list
    static class Node {
        int data;
        Node next;

        public Node(int x) {
            data = x;
            next = null;
        }
    };

    // Function to print triplets
    // in a sorted singly linked list
    // whose sum is equal to given value 'S'
    public static ArrayList<ArrayList<Integer>> printTriplets(Node head, int S) {
        // Declare unordered map
        // to store the scanned value
        HashMap<Integer, Boolean> mp = new HashMap<Integer, Boolean>();

        // Vector to store the triplets
        ArrayList<ArrayList<Integer>> v = new ArrayList<ArrayList<Integer>>();

        // Declare two pointers 'p' and 'q'
        // for traversing singly linked list
        Node p;
        Node q;

        // Insert 1st node data into map
        // and start traversing from next node
        mp.put(head.data, true);

        // Outer loop terminates
        // when last node reached
        for (p = head.next; p.next != null; p = p.next) {

            // Inner loop terminates
            // when second pointer become null
            for (q = p.next; q != null; q = q.next) {

                // Temporary vector
                // to store the current triplet
                ArrayList<Integer> temp = new ArrayList<Integer>();
                int second = p.data;
                int third = q.data;

                // find the number required
                // to make triplet by subtracting
                // node1 and node2 data from S
                // and store it.
                int first = S - second - third;

                // Search if that value
                // is present in the map or not
                if (mp.containsKey(first)) {

                    // If 'first' is present
                    // in map, make a triplet of
                    // first,second & third
                    temp.add(first);
                    temp.add(second);
                    temp.add(third);

                    // Push current triplet
                    // stored in 'temp' to
                    // vector 'v'
                    v.add(temp);
                }
            }

            // Insert current node data into map
            mp.put(p.data, true);
        }

        // Return a vector of triplets.
        return v;
    }

    // Driver code
    public static void main(String args[]) {
        int S = 15;

        // Create an empty singly linked list
        Node head = null;
        ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();

        // Insert values in sorted order
        head = new Node(9);
        head.next = new Node(8);
        head.next.next = new Node(6);
        head.next.next.next = new Node(5);
        head.next.next.next.next = new Node(4);
        head.next.next.next.next.next = new Node(2);
        head.next.next.next.next.next.next = new Node(1);

        // Call printTriplets function
        // to find all triplets in
        // the linked list
        ans = printTriplets(head, S);

        // Sort and display
        // all possible triplets
        for (ArrayList<Integer> x : ans) {
            Collections.sort(x);
        }

        Collections.sort(ans, new Comparator<ArrayList<Integer>>() {
            @Override
            public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) {
                return o2.get(0) - (o1.get(0));
            }
        });
        Collections.reverse(ans);

        for (int i = 0; i < ans.size(); i++) {
            for (int j = 0; j < ans.get(i).size(); j++) {
                System.out.print(ans.get(i).get(j) + " ");
            }
            System.out.println("");
        }
    }
}

// This code is contributed by gfgking.