Compare Two LinkedList in Java

LinkedLists are fundamental data structures in computer science that offer dynamic storage allocation and flexibility. They consist of nodes connected via pointers, and each node holds data and a reference to the next node. In this article, we'll explore various methods to compare two linked lists in Java.

We will cover three approaches to comparing linked lists:

Iterative Comparison
Recursive Comparison
Hashing Comparison

Before we delve into the code, let's first create a simple Linked List implementation in Java.

Linked List Implementation:

// Node class to represent a single node in the linked list
class Node {
    int data;
    Node next;
    // Constructor to initialize a node with given data
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}
// LinkedList class to represent a singly linked list
class LinkedList {
    Node head; // Points to the first node of the linked list
    // Constructor to initialize an empty linked list
    LinkedList() {
        this.head = null;
    }
    // Method to insert a new node at the end of the linked list
    void insert(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode; // If the list is empty, make the new node the head
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next; // Traverse to the last node
            }
            current.next = newNode; // Add the new node at the end
        }
    }
    // Method to display the elements of the linked list
    void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}
public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // Insert elements into the linked list
        list.insert(10);
        list.insert(20);
        list.insert(30);
        list.insert(40);
        // Display the linked list
        System.out.println("Linked List:");
        list.display();
    }
}

Output:

Linked List:
10 -> 20 -> 30 -> 40 -> null

1. Iterative Comparison:

The iterative approach involves traversing both linked lists simultaneously and checking if the data in each node is the same. If any data differs or the lengths of the lists are not equal, the lists are considered unequal. Otherwise, they are equal.

// Node class to represent a single node in the linked list
class Node {
    int data;
    Node next;
    // Constructor to initialize a node with given data
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}
// LinkedList class to represent a singly linked list
class LinkedList {
    Node head; // Points to the first node of the linked list
    // Constructor to initialize an empty linked list
    LinkedList() {
        this.head = null;
    }
    // Method to insert a new node at the end of the linked list
    void insert(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode; // If the list is empty, make the new node the head
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next; // Traverse to the last node
            }
            current.next = newNode; // Add the new node at the end
        }
    }
    // Method to display the elements of the linked list
    void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}
public class Main {
    // Method to compare two linked lists iteratively
    public static boolean iterativeCompare(LinkedList list1, LinkedList list2) {
        Node current1 = list1.head;
        Node current2 = list2.head;
        // Traverse both linked lists simultaneously
        while (current1 != null && current2 != null) {
            if (current1.data != current2.data) {
                return false; // Data in current nodes is different
            }
           current1 = current1.next;
            current2 = current2.next;
        }
        // Check if both lists have been fully traversed
        return current1 == null && current2 == null;
    }
    public static void main(String[] args) {
        LinkedList list1 = new LinkedList();
        list1.insert(1);
        list1.insert(2);
        list1.insert(3);
        LinkedList list2 = new LinkedList();
        list2.insert(1);
        list2.insert(2);
        list2.insert(3);
        System.out.println("List 1:");
        list1.display();
        System.out.println("List 2:");
        list2.display();
        boolean result = iterativeCompare(list1, list2);
        System.out.println("Lists are equal: " + result);
    }
}

Output:

List 1:
1 -> 2 -> 3 -> null
List 2:
1 -> 2 -> 3 -> null
Lists are equal: true

2. Recursive Comparison:

The recursive approach involves comparing the data of the nodes in both linked lists one by one, starting from the head node. If the current nodes have different data or one list reaches the end while the other doesn't, the lists are considered unequal. Otherwise, the recursion continues with the next nodes.

// Node class to represent a single node in the linked list
class Node {
    int data;
    Node next;
    // Constructor to initialize a node with given data
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}
// LinkedList class to represent a singly linked list
class LinkedList {
    Node head; // Points to the first node of the linked list
    // Constructor to initialize an empty linked list
    LinkedList() {
        this.head = null;
    }
    // Method to insert a new node at the end of the linked list
    void insert(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode; // If the list is empty, make the new node the head
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next; // Traverse to the last node
            }
            current.next = newNode; // Add the new node at the end
        }
    }
    // Method to display the elements of the linked list
    void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}
public class Main {
    // Method to compare two linked lists recursively
    public static boolean recursiveCompare(Node node1, Node node2) {
        if (node1 == null && node2 == null) {
            return true; // Both lists are empty, considered equal
        }
        if (node1 == null || node2 == null) {
            return false; // One list is empty, the other is not
        }
        if (node1.data != node2.data) {
            return false; // Data in current nodes is different
        }
        // Recur for the next nodes
        return recursiveCompare(node1.next, node2.next);
    }
    public static boolean recursiveCompare(LinkedList list1, LinkedList list2) {
        return recursiveCompare(list1.head, list2.head);
    }
    public static void main(String[] args) {
        LinkedList list1 = new LinkedList();
        list1.insert(1);
        list1.insert(2);
        list1.insert(3);
        LinkedList list2 = new LinkedList();
        list2.insert(1);
        list2.insert(2);
        list2.insert(3);
        System.out.println("List 1:");
        list1.display();
        System.out.println("List 2:");
        list2.display();
        boolean result = recursiveCompare(list1, list2);
        System.out.println("Lists are equal: " + result);
    }
}

Output:

List 1:
1 -> 2 -> 3 -> null
List 2:
1 -> 2 -> 3 -> null
Lists are equal: true

3. Hashing Comparison:

The hashing approach involves converting the linked list data into hash codes and then comparing the hash codes. The hash codes can be obtained by iterating through the linked list and combining the data from each node using a hash function. If the resulting hash codes are the same for both lists, they are considered equal.

public static int hashCode(Node node) {
    if (node == null) {
        return 0;
    }
    return node.data + 31 * hashCode(node.next);
}
public static boolean hashingCompare(LinkedList list1, LinkedList list2) {
    int hashCode1 = hashCode(list1.head);
    int hashCode2 = hashCode(list2.head);
    return hashCode1 == hashCode2;
}
public static void main(String[] args) {
    LinkedList list1 = new LinkedList();
    list1.insert(1);
    list1.insert(2);
    list1.insert(3);
    LinkedList list2 = new LinkedList();
    list2.insert(1);
    list2.insert(2);
    list2.insert(3);
    System.out.println("List 1:");
    list1.display();
    System.out.println("List 2:");
    list2.display();
    boolean result = hashingCompare(list1, list2);
    System.out.println("Lists are equal: " + result);
}

Output:

List 1:
1 -> 2 -> 3 -> null
List 2:
1 -> 2 -> 3 -> null
Lists are equal: true

In this section, we have explored three different approaches to compare two linked lists in Java. We learned about the iterative, recursive, and hashing methods, each with its own advantages and use cases. The iterative approach is simple and efficient, but it requires more memory as it traverses both lists simultaneously. The recursive approach provides an elegant solution and is memory-efficient, but it may not be suitable for extremely long lists due to the potential risk of a stack overflow.

The hashing approach is effective and can handle large lists, but there is a slight possibility of hash collisions. It's essential to choose the appropriate comparison method based on the specific requirements of our application. With this knowledge, we can now confidently compare linked lists and harness the power of these fundamental data structures in your Java programs.

Next TopicComparison of Autoboxed Integer objects in Java

← prev next →