Question

In JAVA, please.
THANK YOU

In this project you will create a generic linked list using
Java Generics.



Description:

   Create a generic class called GenLinkedList.  GenLinkedList will use nodes
   that store a value of the generic type to store its contents.

   It should have the following methods.  The methods should 
   all operate on the object making the call (none are static).  

   Perform checking of the parameters and throw exceptions where 
   appropriate.

   The linked list should be singly-linked.

   It should not use sentinel nodes (empty header and tail nodes).  

   You should strive for an efficient implementation of each method.

   g.  swap
        receives two index positions as parameters, and swaps the nodes at
        these positions, provided both positions are within the current size

   h.  shift
        receives an integer as a parameter, and shifts the list forward or
        backward this number of nodes, provided it is within the current size

   k.  insertList
        receives a generic List (a Java List) and an index position as parameters, 
        and copies each value of the passed list into the current list starting
        at the index position, provided the index position does not exceed the size.
        For example, if list has a,b,c and another list having 1,2,3 is inserted at
        position 2, the list becomes a,b,1,2,3,c

   i.  removeMatching
        receives a value of the generic type as a parameter and removes all
        occurrences of this value from the list.

Answer 1

HI, Please find the solution and upvote the answer.

public class Node<X> {
    private X value;
    public Node<X> next;

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }

    public void setNext(Node<X> next) {
        this.next = next;
    }

    public X getValue() {
        return value;
    }

    public void setValue(X value) {
        this.value = value;
    }

    public Node(X val) {
        this.value = val;
        next = null;
    }
}

import java.util.Collections;
import java.util.List;

public class LinkedList<T> {
    private Node<T> head;

    public void printAll(){
        Node<T> temp= head;
        while(temp!=null){
            System.out.print(temp+", ");
            temp = temp.next;
        }
        System.out.println();
    }
    public int size(){
        int count = 0;
        Node<T> temp= head;
        while(temp!=null){
            temp=temp.next;
            count++;
        }
        return count;
    }
    void swap(int index1,int index2){
        int size = size();
        if(!(index1>=0 && index1< size && index2>=0 && index2< size)){
            return;//if indexes are not proper
        }
        Node<T> temp,temp1 = null,temp2=null;
        temp = head;
        for (int i = 0; i < size(); i++) {
            if(i==index1){
                temp1 = temp;
            }if(i==index2){
                temp2 = temp;
            }
            temp = temp.next;
        }
        T val = temp1.getValue();
        temp1.setValue(temp2.getValue());
        temp2.setValue(val);

    }

    void shift(int index){
        if(index<0 || index>size()){
            return;
        }
        for (int i = index; i < size(); i++) {
            Node<T> del = delete(i);
            addBeginning(del);
        }
    }
    void insertList(List<T> list, int index){
        int k=0;
        int size = size();
        Collections.reverse(list);
        for (int i = index; i < size && k<list.size(); i++) {
            insert(new Node<T>(list.get(k++)),index);
        }
    }

    void addBeginning(Node<T> node){
        if(node!=null) {
            node.next = head;
            head = node;
        }
    }
    void add(Node<T> node){
        node.next=null;
        if(head==null){
            head=node;
            return;
        }
        Node<T> temp = head;
        while(temp.next!=null){
            temp = temp.next;
        }
        temp.next = node;

    }
    void removeMatching(Node<T> remove){
        Node<T> temp = head;
        int i=0;
        LinkedList<Integer> ints = new LinkedList<>();
        while(temp!=null){//this loop adds all occurrences
            if(temp.getValue().equals(remove.getValue())){
                ints.add(new Node<>(i));
            }
            temp = temp.next;//moving pointers
            i++;
        }
        for (int j = 0; j < ints.size(); j++) {//this loop deletes them
            delete(ints.get(j).getValue());
        }
    }
    Node<T> get(int index){
        if(head==null){
            return null;
        }
        Node temp = head;
        int i=0;
        while(temp.next!=null && index!=i++){
            temp=temp.next;
        }
        if(i-1==index || i==index ){
            return new Node(temp.getValue());
        }
        else
            return null;//index not present
    }

    Node<T> delete(int index){
        if(index==0){
            Node<T> temp = head;
            head = head.next;
            temp.next = null;
            return temp;
        }
        Node<T> temp = head;
        Node<T> tempNext = head.next;
        int i=1;
        while(tempNext!=null && i++!=index){
            temp = temp.next;
            tempNext = tempNext.next;
        }
        temp.next = tempNext.next;//temp is pointing to index-1 node
        tempNext.next = null;
        return tempNext;

    }

    void set(Node<T> value,int index){
        value.next=null;
        value.next=null;
        if(head==null){
            head = value;
            head.next=null;
            return;
        }
        if(index==0){
            head.setValue(value.getValue());
            return;
        }
        Node temp = head;
        int i=0;
        while(temp.next!=null && index!=i++){
            temp=temp.next;
        }
        if(head!=temp && index!=0)
            temp.setValue(value.getValue());
    }

    void insert(Node<T> value,int index){
        value.next=null;
        if(head==null){
            head = value;
            head.next=null;
            return;
        }
        if(index==0){
            value.next=head;
            head=value;
        }
        Node<T> temp = head;
        Node<T> tempNext = head.next;
        int i=0;
        while(tempNext!=null && index!=i++){
            temp=temp.next;
            tempNext =  tempNext.next;
        }
        value.next = temp.next;
        temp.next=value;
    }

}

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        Node<Character> a = new Node<>('a');
        Node<Character> b = new Node<>('b');
        Node<Character> c = new Node<>('c');
        Node<Character> d = new Node<>('d');
        Node<Character> e = new Node<>('e');
        Node<Character> f = new Node<>('f');


        Node<Character> one = new Node<>('1');
        Node<Character> two = new Node<>('2');
        Node<Character> three = new Node<>('3');
        Node<Character> four = new Node<>('4');
        Node<Character> five = new Node<>('5');
        LinkedList<Character> list = new LinkedList<>();


        list.add(a);
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(e);
        list.add(f);
        System.out.println("List after adding");
        list.printAll();
        System.out.println();
        System.out.println("List after swap 0 with 5");
        list.swap(0,5);
        list.printAll();
        System.out.println();
        System.out.println("List after shifting 4");
        list.shift(4);
        list.printAll();
        System.out.println();
        System.out.println("List after inserting another list");
        list.insertList(Arrays.asList('t','u','v'),3);
        list.printAll();
        System.out.println("After removing node 't'");
        list.removeMatching(new Node<Character>('t'));
        list.printAll();;
    }
}

Some variables are unused.Feel free to use them in Main.java..

Sample output: