class Prioritetskoe<E extends Comparable<E>> {
    // Dette er bare en gjennomgan av prioritetsk?en. Dette er ganske likt som det dere gjorde i oblig3.
    // Dette var mest for ? illusterer at vi kan bruke et interface til ? begrense hvilke elementer vi kan sette inn i 
    // beholderen. 

    Node foerste = null;
    class Node {
        E data;
        Node neste;
        public Node(E x) {
            data = x;
        }
    }

    public void settInn(E x) {
        // Fra tegningen min fant jeg tre tilfeller jeg m? ta hensyn til n?r jeg skal sette inn nye elementer. 
        
        // 1. N?r lista er tom:
        if (foerste == null) {
            foerste = new Node(x);
            return;
        }

        Node nyNode = new Node(x);
        
        // 2. N?r det nye elementet er mindre enn det f?rste elementet i lista:
    
        if (x.compareTo(foerste.data) <= 0) {
            // x.compareTo(y) -> returnerer typisk (x - y)
            nyNode.neste = foerste;
            foerste = nyNode;
            return;
        }

        // 3. N?r noden m? plasseres en eller annen plass inne i lista (kan v?re sist). 
        Node neste = foerste;
        Node forrige = null;

        // Finner den f?rste noden hvor x < neste.data, eller den siste node. 
        while (x.compareTo(neste.data) > 0 && neste != null) {
            forrige = neste;
            neste = neste.neste;
        }
        // Siden neste n? enten peker p? null, eller p? en node som er st?rre enn x, trenger jeg ? mellomlagre noden som kom f?r,
        // siden den nye noden m? plasseres mellom forrige og neste pekerene.
        forrige.neste = nyNode;
        // Siden jeg alltid skal plassere noden etter forrige, er det uvesentlig om neste peker p? null, s? jeg kan trygt sette
        // nyNode sin neste til ? peke p? den.
        nyNode.neste = neste;
    }
}