SInglyLinkedLIst með swap

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;

import java.util.Iterator;

public class SinglyLinkedList<T> implements Iterable<T> {


    private class Node {

        Node next;
        T data;

        Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }

    private Node head;
    private int length;

    SinglyLinkedList() {
        /*
        Smiður sem upphafsstillir tóman lista.
         */
        this.head = null;
        this.length = 0;
    }

    public boolean isEmpty() {
        /*
        Skilar sönnu innihaldi listinn engin stök, annars ósönnu
         */
        return this.head == null;
    }

    public int size() {
        /*
        Skilar fjölda staka í listanum.
         */
        return this.length;
    }

    @Override
    public String toString() {
        /*
        Aðferð sem sýnir fallega strengjaframsetningu á listanum.
         */
        Node node = this.head;
        String representation = "";
        while (node != null) {
            representation += node.data.toString() + " -> "; // Ath. að þetta er ekki skilvirkt, dekkum seinna
            node = node.next;
        }
        return representation + "Ø";
    }

    public T get(int index) {
        /*
        Skilar staki númer <index> í listanum án þess að breyta honum.
         */
        if (index < 0 || this.size() <= index) {
            throw new ArrayIndexOutOfBoundsException("Vísað út fyrir lista");
        }

        Node node = this.head;
        int i = 0;
        while (node != null) {
            if (i == index) {
                return node.data;
            }
            node = node.next;
            i++;
        }
        return null;
    }

    public void insert(int index, T data) {
        /*
        Bætir staki við listann í sæti númer <index>, án þess að yfirskrifa stak.
        Öllum stökum sem koma á eftir nýja stakinu hliðrast í átt að enda listans.
         */
        if (index < 0 || this.size() < index) {
            throw new ArrayIndexOutOfBoundsException("Vísað út fyrir lista");
        }
        if (index == 0) {
            this.head = new Node(data, this.head);
        } else {
            Node node = this.head;
            int i = 0;
            while (node.next != null && i < index - 1) {
                node = node.next;
                i++;
            }
            node.next = new Node(data, node.next);
        }
        this.length++;
    }

    public void delete(int index) {
        /*
        Fjarlægir stak númer <index> úr listanum og uppfærir <this.length>.
        Númer allra staka sem komu á eftir stakinu sem var eytt skulu lækka.
         */
        if (index < 0 || this.size() <= index) {
            throw new ArrayIndexOutOfBoundsException("Vísað út fyrir lista");
        }

        // fyrsta stakið í listanum:
        if (index == 0) {
            Node del = this.head; // eyðum þessum hnút
            Node eftir = del.next; // hnúturinn á eftir
            del = null; // eyðum tilvísunum
            this.head = eftir;

        // síðasta stakið í listanum:
        } else if (index == this.size()-1) {
            Node undan = this.head;
            for (int i=0; i<index-1; i++) undan = undan.next; // hnúturinn á undan þeim sem við viljum eyða
            Node del = undan.next; // hnúturinn sem við viljum eyða
            undan.next = null;
            del = null; // eyðum tilvísunum

        // eyðum staki í miðjum lista:
        } else {
            Node undan = this.head;
            for (int i=0; i<index-1; i++) undan = undan.next; // hnúturinn á undan þeim sem við viljum eyða
            Node del = undan.next; // hnúturinn sem við viljum eyða
            Node eftir = del.next; // hnúturinn á eftir þeim sem við eyðum
            undan.next = eftir; // tengjum undan og eftir saman
            del = null; // eyðum tilvísunum
        }

        this.length--; // minnkum lengd listans um einn
    }

    public void swap(int index1, int index2) {
        /*
        Skiptir á staðsetningum hnúta númer <index1> og <index2> með
        því að uppfæra vísanir nágranna þeirra.
        Ekki er tryggt að <index1> sé minni en <index2>.
         */
        if (index1 < 0 || index2 < 0 || this.size() <= index1 || this.size() <= index2) {
            throw new ArrayIndexOutOfBoundsException("Vísað út fyrir lista");
        }

        // skilgreiningar
        Node undan = this.head;
        Node undan2 = this.head;
        Node swap = null;
        Node swap2 = null;
        Node eftir = null;
        Node eftir2 = null;

        if (index1 == index2) return; // ef jafnt þá gerum við ekkert

        // ef annaðhvort er fyrsta stak:
        if (index1 == 0) swap = this.head;
        if (index2 == 0) swap2 = this.head;

        for (int i=0; i<this.size(); i++) {
            // finnum hnúta á undan
            if (i < index1-1) undan = undan.next;
            if (i < index2-1) undan2 = undan2.next;

            if (i>=index1 && i>=index2) { // þegar búið er að finna hnúta á undan
                // finnum hnúta á eftir
                if (index1 != 0) swap = undan.next;
                if (index1 != this.size()-1) eftir = swap.next;
                if (index2 != 0) swap2 = undan2.next;
                if (index2 != this.size()-1) eftir2 = swap2.next;

                // skiptum á vísunum
                if (index1 != 0) undan.next = swap2;
                if (index1 != this.size()-1) swap2.next = eftir;
                if (index2 != 0) undan2.next = swap;
                if (index2 != this.size()-1) swap.next = eftir2;

                // ef við erum með síðasta hnút
                if (index1 == this.size()-1) swap2.next = null;
                if (index2 == this.size()-1) swap.next = null;

                // ef við erum með fyrsta hnút
                if (index1 == 0) this.head = swap2;
                if (index2 == 0) this.head = swap;

                return;
            }
        }


    }

    public Iterator<T> iterator() {
        /*
        Einfaldur ítrari fyrir SinglyLinkedList klasann, sjá ListIterator
        */
        return new ListIterator();
    }

    private class ListIterator implements Iterator<T> {
        private Node current = head;

        public boolean hasNext() {
            return this.current != null;
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

        public T next() {
            T item = this.current.data;
            this.current = this.current.next;
            return item;
        }
    }

    public static void main(String[] args) {
        SinglyLinkedList<Integer> list = new SinglyLinkedList<>();
        list.insert(0, 2);
        list.insert(0, 1);
        list.insert(2, 4);
        list.insert(2, 3);
        StdOut.println("Listinn er í upphafi:          " + list);
        StdOut.println("");

        // Prófum swap aðferðina
        StdOut.print("Skiptum á hnútum 1 og 3, ");
        list.swap(1, 3);
        StdOut.println("fáum: " + list);
        StdOut.print("Lagfærum listann aftur, ");
        list.swap(3, 1);
        StdOut.println("fáum:  " + list);
        StdOut.print("Prófum að skipta á endunum:    ");
        list.swap(0, list.size() - 1);
        StdOut.println(list);
        StdOut.print("Lagfærum aftur:                ");
        list.swap(list.size() - 1, 0);
        StdOut.println(list);

        // Prófum delete aðferðina
        StdOut.println("");
        StdOut.println("Hendum nú út öllum hnútunum í slembinni röð");

        int max = 10, count = 0; // Svo lykkjan keyri ekki endalaust þegar eyðingin er ókláruð
        int index = 0;
        while (!list.isEmpty() && count++ < max) {
            index = StdRandom.uniform(0, list.size()); // Veljum stak af handahófi
            StdOut.print("Hendum staki númer " + index);
            list.delete(index);
            StdOut.println(". Eftir eyðingu er listinn: " + list);
        }
    }
}