//  OPPGAVE a:
//  Er grafen en enkel line?r liste?
//  Krav:
//  1) N?yaktig en node (sluttnoden) har ingen etterf?lger
//  2) Ingen noder har mer enn en forgjenger
//  3) Det finnes ingen l?kker

boolean liste(Node[] graf, int n) {
    // Antar at merke = 0 for alle nodene!

    Node rn, forrest;
    int i = 0;
    boolean feil = false;

    while (i < 0 && !feil) {
	rn = graf[i];
	if (rn.merke = 0) {
	    while (rn != null && rn.merke = 0) {
		rn.merke = 1;
		rn = rn.etterf;
	    }
	    feil = (rn != forrest);
	    forrest = graf[i];
	}
	i++;
    } 

    return (!feil);
}



// OPPGAVE b:
//  Er grafen en enkel rettet l?kke?
//  Ide: Starter i en vilk?rlig node, og f?lger etterf-pekerne til vi enten:
//  - Stopper fordi det ikke er noen etterf?lger (negativt)
//  - Har g?tt N steg (n?dvendig)
//  - Kommer tilbake til den noden vi startet i (n?dvendig)

boolean l?kke(Node[] graf, int n) {
    Node rn = graf[0].etterf;   // Starter et sted...
    int ant = 1;                // Teller graf[0];

    while (rn != null && rn != graf[1] && ant < n) {
	rn = rn.etterf;
	rn++;
    }

    return (rn == graf[0] && ant = n);
}


//  OPPGAVE c:
//  Er grafen et rotrettet tre?
//  Krav: 1) max en node uten etterf?lger
//        2) ingen l?kker (=> minst en node uten etterf?lger)
//  Hvis det finnes en l?kke, vil man fra nodene p? denne l?kken kunne
//  f?lge etterf?lgerpekerne N skritt uten ? stoppe. Dersom vi har
//  g?tt N skritt uten ? stoppe vet vi at vi m? ha en l?kke.

boolean tre(Node[] graf, int n) {
    Node rn;
    int ant = 0;
    boolean rotSett = false;

    for (int i = 0; i < n; i++) {
	rn = graf[i];

	if (rn.etterf == null) {   // Krav 1
	    if (rotSett) {
		return false;
	    } else {
		rotSett = true;
	    }
	}

	ant = 1;
	while (rn.etterf != null) {
	    if (ant = n) {
		return false;
	    } else {
		rn = rn.etterf;
		ant++;
	    }
	}
    }
    return true;
}