Question

//  1. Add methods to get and set, Data and Link. Data should be any Comparable object.
class Node {
    Integer data; // Integer is Comparable
    Node link;

    public Node(Integer data, Node link) {
        this.data = data;
        this.link = link;
    }

    public Integer getData() {
        return data;
    }

    public void setData(Integer data) {
        this.data = data;
    }

    public Node getLink() {
        return link;
    }

    public void setLink(Node link) {
        this.link = link;
    }
}

//  b.  Create MyLinkedList class and write methods to do the following:
class MyLinkedList {
    Node head;

    //  Insert a node at the end of the list
    void insertLast(Integer data) {
        Node newNode = new Node(data, null);
        if (head == null) {
            head = newNode;
            return;
        }

        Node last = head;
        while (last.link != null) {
            last = last.link;
        }
        last.link = newNode;
    }

    //  Insert a node at the front of the list
    void insertFirst(Integer data) {
        Node newNode = new Node(data, null);
        if (head == null) {
            head = newNode;
            return;
        }
        newNode.link = head;
        head = newNode;
    }

    //  Display all nodes in the list
    void display() {
        if (head == null) {
            System.out.println("List is empty");
            return;
        }

        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + "    ");
            temp = temp.link;
        }
        System.out.println();
    }

    //  Method to check of the list is empty - isEmpty() (returns a Boolean)
    Boolean isEmpty() {
        return head == null;
    }

    //  Method to return the size of the list
    int size() {
        int size = 0;
        Node temp = head;
        while (temp != null) {
            size++;
            temp = temp.link;
        }
        return size;
    }

    //  Delete all nodes in the list
    void deleteAllNodes() {
        head = null;
    }

    //  Search List for a node with a certain value (returns the node if found, null if not found)
    Node search(Integer value) {
        Node temp = head;
        while (temp != null) {
            if (temp.data.equals(value))
                return temp;
            temp = temp.link;
        }
        return null;
    }

    // Delete a node with a specific value in the list if found
    void deleteIfFound(Integer value) {
        Node curr = head, prev = head;
        if (head.data.equals(value)) {
            head = head.link;
            return;
        }
        while (curr != null) {
            if (curr.data.equals(value)) {
                prev.link = curr.link;
            }
            prev = curr;
            curr = curr.link;
        }
    }

    //  Method to find the node with the largest value in the list – getLargest()
    void getLargest() {
        Node temp = head, largest = head;
        while (temp != null) {
            if (temp.data.compareTo(largest.data) > 0)
                largest = temp;
            temp = temp.link;
        }
        System.out.println("Largest Value:" + largest.data);
    }

    //  Method to return all the elements less than a certain value as a linked list of type MyLinkedList
    MyLinkedList findLessThan(Integer x) {
        MyLinkedList newList = new MyLinkedList();
        Node temp = head;
        while (temp != null) {
            if (temp.data.compareTo(x) < 0) {
                newList.insertLast(temp.data);
            }
            temp = temp.link;
        }
        return newList;
    }
}

// Main Method to test all Linked list methods
public class NodeTest {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.display();

        myLinkedList.insertLast(10);
        myLinkedList.insertLast(15);
        myLinkedList.insertLast(12);
        System.out.println("list size: " + myLinkedList.size());
        myLinkedList.display();

        myLinkedList.insertFirst(53);
        myLinkedList.insertLast(62);
        myLinkedList.insertFirst(82);
        myLinkedList.insertLast(102);
        myLinkedList.insertLast(14);
        System.out.println("list size: " + myLinkedList.size());
        myLinkedList.display();

        System.out.println("20 " + (myLinkedList.search(20) == null ? "Not Found" : "Found"));
        System.out.println("15 " + (myLinkedList.search(62) == null ? "Not Found" : "Found"));

        System.out.println("Delete 10 if found");
        myLinkedList.deleteIfFound(10);
        myLinkedList.display();

        myLinkedList.getLargest();

        System.out.println("Get New List less than 50");
        MyLinkedList newList = myLinkedList.findLessThan(50);
        System.out.println("Printing New List:");
        newList.display();

        System.out.println("Deleting all nodes");
        myLinkedList.deleteAllNodes();
        myLinkedList.display();
    }
}

based on the pervious, please do the following completely or don't since it is one question with several parts, language used is java on netbeans.

Problem 2:

Use MyLinkedList in previous problem to create a TestIntegers method. TestIntegers method is to be called it in the main method to do the following:

1. Create a new List (call it integerList) of type MyLinkedList

2. Insert five integer numbers to the end of the list (not ordered). Wrap the numbers in the class

   “Integer”

3. Display all the items in the List

4. Insert elements at the front of the List and display it

5. Display the size of the list

6. Display the largest element in the list

7. Search for a particular element in the List by printing true if found or false.

8. Get and display all elements less than the Integer 20

9. Delete a specific node in the List and display the list (in the beginning, middle and at the end)

10. Delete the entire List and display if the list is empty or not

Answer 1

public class Main {
    public static void TestIntegers()
    {
        MyLinkedList myLinkedList = new MyLinkedList();
        
        myLinkedList.insertLast(10);
        myLinkedList.insertLast(15);
        myLinkedList.insertLast(12);
        myLinkedList.insertLast(1);
        myLinkedList.insertLast(25);
        
        System.out.println("List:");
        myLinkedList.display();
        
        System.out.println("Adding New Emement(53) in front of list");
        myLinkedList.insertFirst(53);
        
        System.out.println("list size: " + myLinkedList.size());
        
        myLinkedList.getLargest();
        
        System.out.println("" + (myLinkedList.search(20) == null ? "False" : "True"));
        System.out.println("" + (myLinkedList.search(10) == null ? "False" : "True"));
        
        System.out.println("Elements less than 20");
        MyLinkedList newList = myLinkedList.findLessThan(20);
        newList.display();
        
        myLinkedList.display();
        System.out.println("Delete 53(first node) if found");
        myLinkedList.deleteIfFound(53);
        myLinkedList.display();
        System.out.println("Delete 12(middle node) if found");
        myLinkedList.deleteIfFound(12);
        myLinkedList.display();
        System.out.println("Delete 25(end node) if found");
        myLinkedList.deleteIfFound(25);
        myLinkedList.display();
        
        System.out.println("Deleting all nodes");
        myLinkedList.deleteAllNodes();
        myLinkedList.display();
        
    }
    
    public static void main(String[] args) {
        
        TestIntegers();

        // MyLinkedList myLinkedList = new MyLinkedList();
        // myLinkedList.display();

        // myLinkedList.insertLast(10);
        // myLinkedList.insertLast(15);
        // myLinkedList.insertLast(12);
        // System.out.println("list size: " + myLinkedList.size());
        // myLinkedList.display();

        // myLinkedList.insertFirst(53);
        // myLinkedList.insertLast(62);
        // myLinkedList.insertFirst(82);
        // myLinkedList.insertLast(102);
        // myLinkedList.insertLast(14);
        // System.out.println("list size: " + myLinkedList.size());
        // myLinkedList.display();

        // System.out.println("20 " + (myLinkedList.search(20) == null ? "Not Found" : "Found"));
        // System.out.println("15 " + (myLinkedList.search(62) == null ? "Not Found" : "Found"));

        // System.out.println("Delete 10 if found");
        // myLinkedList.deleteIfFound(10);
        // myLinkedList.display();

        // myLinkedList.getLargest();

        // System.out.println("Get New List less than 50");
        // MyLinkedList newList = myLinkedList.findLessThan(50);
        // System.out.println("Printing New List:");
        // newList.display();

        // System.out.println("Deleting all nodes");
        // myLinkedList.deleteAllNodes();
        // myLinkedList.display();
    }

}