SLLJoinLists

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.NoSuchElementException;

//KLASA ZA JAZEL
class SLLNode<E> {
    // atributi
    protected E element;// kreirame jazel so seuste nepoznat value E
    protected SLLNode<E> succ;// link do sledniot jazel

    // konstruktor
    public SLLNode(E element, SLLNode<E> succ) {
        this.element = element;
        this.succ = succ;
    }
}

// KLASA ZA LISTA
class SLL<E extends Comparable<E>> {
    // atributi
    private SLLNode<E> first;// prv jazel
    // konstruktor - NE PRIMA ARGUMENTI

    public SLL() {
        // kreiranje prazna lista
        this.first = null;// go postavuvame prviot jazel da pokazuva na null
    }

    // vrakja SLLNode
    public SLLNode<E> getFirst() {
        return first;
    }

    public void insertFirst(E o) {
        // napravi nov jazel koj ima value o i pokazuva na first
        SLLNode<E> ins = new SLLNode<E>(o, first);
        first = ins;// prviot jazel e noviot jazel
    }

    public void insertLast(E o) {
        if (first != null) {// ako ne e posleden
            SLLNode<E> tmp = first;// kreiram temporary jazel
            while (tmp.succ != null)// dodeka temporary ne e posleden
                tmp = tmp.succ;// izminuvaj ja listata, noviot temporary e
                                // sledniot
            // ako stasas do posledniot
            // napravi nov jazel koj ima value o i pokazuva na null
            SLLNode<E> ins = new SLLNode<E>(o, null);
            tmp.succ = ins;// sledniot jazel na posledniot neka bide noviot
                            // jazel
        } else {// ako prviot e i posleden i e ednakov na null
            insertFirst(o);// vnesi kako prv i edinstven element
        }
    }

    // go povikuvame so lista2
    // metodata vrakja niza od jazli
    public SLL<E> joinLists(SLL<E> in) {
        // TODO Auto-generated method stub
        // deklarirame niza sto treba da ja vratime od metodata
        SLL<E> rezultat = new SLL<E>();

        // kreirame 2 novi jazli, prviot od prvata lista,
        // vtoriot od vtorata i prvicno pokazuvaat na prviot jazel
        SLLNode<E> nodeLista1 = this.getFirst();
        SLLNode<E> nodeLista2 = in.getFirst();

        while (nodeLista1 != null && nodeLista2 != null) {
            // ako e pomal od vtoriot element, ke vrati negativen broj
            // hence the < 0
            if (nodeLista1.element.compareTo(nodeLista2.element) < 0) {
                rezultat.insertLast(nodeLista1.element);// smesti vo novata nizaS
                                                        // // pomaliot
                nodeLista1 = nodeLista1.succ;// odi na sledniot jazel
            } else {// ako ne e pomal vrati go drugiot
                rezultat.insertLast(nodeLista2.element);
                nodeLista2 = nodeLista2.succ;// odi na sledniot jazel
            }
        }
        // sto ako edniot e null, a drugiot ne e ?
        // ako vtoriot dosol do kraj a prviot seuste ne
        if (nodeLista1 != null) {
            while (nodeLista1 != null) {// izmini gi site ostanati i smesti gi
                                        // vo lista
                rezultat.insertLast(nodeLista1.element);
                nodeLista1 = nodeLista1.succ;
            }
        }
        // soodvetno ako prviot dosol do kraj, smesti gi preostanatite jazli od
        // vtorata lista
        if (nodeLista2 != null) {
            while (nodeLista2 != null) {
                rezultat.insertLast(nodeLista2.element);
                nodeLista2 = nodeLista2.succ;
            }
        }

        // kreiraj nova prazna lista
        SLL<E> rezultatBezDuplikati = new SLL<E>();
        // kreiraj 2 novi nodes, prviot so prviot element od rezultat
        // vtoriot so negoviot sledbenik
        SLLNode<E> novNode = rezultat.getFirst();
        SLLNode<E> tmpNode = novNode.succ;
        while (tmpNode != null) {
            // ako prviot e ist so vtoriot
            if (novNode.element.compareTo(tmpNode.element) == 0) {
                novNode = novNode.succ;// primi ja vrednosta od vtoriot
                tmpNode = tmpNode.succ;// vtoriot na negoviot sledbenik
            } else {// ako se razlicni
                rezultatBezDuplikati.insertLast(novNode.element);
                novNode = novNode.succ;// odi na sleden
                tmpNode = tmpNode.succ;// odi na sleden
            }
        }
        rezultatBezDuplikati.insertLast(novNode.element);
        return rezultatBezDuplikati;
    }

    public Iterator<E> iterator() {
        // vraka iterator koj gi posetuva site elementi na listata od levo na
        // desno
        return new LRIterator<E>();
    }

    // //////////Inner class ////////////
    private class LRIterator<E> implements Iterator<E> {
        private SLLNode<E> place, prev, curr;

        private LRIterator() {
            place = (SLLNode<E>) first;
            curr = prev = null;
        }

        public boolean hasNext() {
            return (place != null);
        }

        public E next() {
            if (place == null)
                throw new NoSuchElementException();
            E nextElem = place.element;
            prev = curr;
            curr = place;
            place = place.succ;
            return nextElem;
        }

        public void remove() {
            // Not implemented
        }
    }

}

public class SLLJoinLists {
    public static void main(String[] args) throws IOException {

        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        String s = stdin.readLine();
        int N = Integer.parseInt(s);
        s = stdin.readLine();
        String[] pomniza = s.split(" ");
        SLL<Integer> lista1 = new SLL<Integer>();
        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(" ");
        SLL<Integer> lista2 = new SLL<Integer>();
        for (int i = 0; i < N; i++) {
            lista2.insertLast(Integer.parseInt(pomniza[i]));
        }

        SLL<Integer> spoeni = lista1.joinLists(lista2);
        Iterator<Integer> it = spoeni.iterator();
        while (it.hasNext()) {
            System.out.print(it.next());
            if (it.hasNext())
                System.out.print(" ");
        }
        System.out.println();
    }
}