SLL Java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class SpecialSLLJoin {


    public static void main(String[] args) throws IOException {
        // Initialization of SLL
        SLL<Integer> lista1 = new SLL<Integer>();
        SLL<Integer> lista2 = new SLL<Integer>();
        //
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        String s = stdin.readLine();
        int N = Integer.parseInt(s);
        s = stdin.readLine();
        String[] pomniza = s.split(" ");
        for (int i = 0; i < N; i++) {
            lista1.insertLast(Integer.parseInt(pomniza[i]));
        }
        s = stdin.readLine();
        N = Integer.parseInt(s);
        s = stdin.readLine();
        pomniza = s.split(" ");
        for (int i = 0; i < N; i++) {
            lista2.insertLast(Integer.parseInt(pomniza[i]));
        }
        lista1.specialJoin(lista1,lista2);

    }
}
class SLL<E extends Comparable<E>> implements Comparable<SLL<E>> {
    private SLLNode<E> header;
    public SLL() {
        this.header=null;
    }
    public SLL(SLL<E> e) {
        this.header=e.header;
    }
    public void printFirstToLast() {
        for(SLLNode<E> curr=header; curr!=null; curr=curr.succ) {
            System.out.print(curr.element + " ");
        }
    }
    public void insertLast(E in) {
        if (header != null) {
            SLLNode<E> tmp = header;
            while (tmp.succ != null)
                tmp = tmp.succ;
            SLLNode<E> ins = new SLLNode<E>(in,null);
            tmp.succ = ins;
        } else {
            SLLNode<E> ins = new SLLNode<E>(in,header);
            header = ins;
        }
    }
    //
    public SLLNode<E> getNode() {
        return header;
    }
    @Override
    public int compareTo(SLL<E> e) {
        return getNode().compareTo(e.getNode());
    }
    void removeDuplicates() {
        SLLNode<E> current = header;
        SLLNode<E> next_next;
        if (header == null)
            return;
        while (current.succ != null) {
            if (current.element == current.succ.element) {
                next_next = current.succ.succ;
                current.succ = null;
                current.succ = next_next;
            } else
                current = current.succ;
        }
    }
    public void joinLists(SLL<E> second) {
        SLL<E> result = new SLL<E>();
        SLLNode<E> curr1=this.header;
        SLLNode<E> curr2=second.header;
        while(curr1!=null&&curr2!=null) {
            if(curr1.element.compareTo(curr2.element) < 0) {
                result.insertLast(curr1.element);
                if(curr1.equals(curr2)) curr2=curr2.succ;//System.out.print("R ");//
                curr1=curr1.succ;
            } else {
                result.insertLast(curr2.element);
                if(curr2.equals(curr1)) curr1=curr1.succ;//System.out.print("R ");//
                curr2=curr2.succ;
            }
        }
        if(curr1!=null) {
            while(curr1!=null) {
                result.insertLast(curr1.element);
                curr1=curr1.succ;
            }
        }
        if(curr2!=null) {
            while(curr2!=null) {
                result.insertLast(curr2.element);
                curr2=curr2.succ;
            }
        }
        result.removeDuplicates();
        this.header=null;
        this.header=result.header;
    }
    //
    public void specialJoin(SLL<E> first,SLL<E> second) {
        SLL<E> result = new SLL<E>();
        SLLNode<E> curr1=first.header;
        SLLNode<E> curr2=second.header;
        boolean flag = true;
        while(curr1!=null&&curr2!=null) {
            if(flag) {
                result.insertLast(curr1.element);
                curr1=curr1.succ;
                if(curr1==null) break;
                result.insertLast(curr1.element);
                curr1=curr1.succ;
                flag=false;
            } else {
                result.insertLast(curr2.element);
                curr2=curr2.succ;
                if(curr2==null) break;
                result.insertLast(curr2.element);
                curr2=curr2.succ;
                flag=true;
            }
        }
        if(curr1!=null) {
            while(curr1!=null) {
                result.insertLast(curr1.element);
                curr1=curr1.succ;
            }
        }
        if(curr2!=null) {
            while(curr2!=null) {
                result.insertLast(curr2.element);
                curr2=curr2.succ;
            }
        }
        result.printFirstToLast();
    }
    //
}
class SLLNode<E extends Comparable<E>> implements Comparable<SLLNode<E>> {
    protected E element;
    protected SLLNode<E> succ;
    SLLNode(E elem, SLLNode<E> succ) {
        this.element=elem;
        this.succ=succ;
    }
    //
    public E getElement() {
        return element;
    }
    @Override
    public int compareTo(SLLNode<E> e) {
        return getElement().compareTo(e.getElement());
    }

    public boolean equals(SLLNode<E> e) {
        if(this.element==e.element) return true;
        return false;
    }
}