public class Lenkeliste<T> {

	// Privat, indre klasse Node.
	private class Node {
		public T elem;
		public Node neste;

		public Node(T elem){
			this.elem = elem;
		}
	}

	private Node hode; // F?rste 
	private Node hale; // Siste
	private int antallNoder = 0;


	public void leggTil(T t){
		Node nyNode = new Node(t);
		antallNoder ++;

		// F?rste er tom/ingen elementer i listen.
		if (hode == null) {
			hode = nyNode;
			hale = nyNode;
		} 
		else {
			hale.neste = nyNode;
			hale = nyNode;
		}
	}

	public void skrivUtListe() {
		Node tog = hode;
		while (tog != null) {
		//	System.out.println(tog.elem.toString());
			System.out.println(tog.elem);

			tog = tog.neste;
		}
	}


	public void fjernAlt() {
		hode = hale = null;
		antallNoder = 0;
	}

	public T hent(int indeks) {
		if (indeks < 0 || indeks >= antallNoder) {
			return null;
		}

		Node tog = hode;
		for (int i = 0; i < indeks; i++) {
			tog = tog.neste;
		}
		
		return tog.elem;		
	}

	/*
	Dette er fjern-metoden som vi lagde i timen. Den fungerer ikke optimalt. 
	En bedre variant er kommentert ut under denne metoden.
	*/
	public T fjern(int indeks) {
		if (indeks < 0 || indeks >= antallNoder) {
			return null;
		}

		// Hvis ett element i listen.
		// if (hode == hale) 
		if (antallNoder == 1) {
			T elem = hode.elem;
			fjernAlt();
			return elem;
		} 
		// Hvis f?rste element i listen
		else if (indeks == 0) { 
			T elem = hode.elem;
			hode = hode.neste;
			return elem;
		}
		// Hvis siste element i listen
		/*else if (indeks == antallNoder - 1) {
		}*/
		else {
			Node tog = hode.neste;
			Node forrige = hode;

			for (int i = 0; i < indeks; i++) {
				forrige = tog;
				tog = tog.neste;
				
				//forrige = forrige.neste;
			}

			T elem = tog.elem;
			forrige.neste = tog.neste;

			if (tog == hale) {
				hale = forrige;
			} 
			return elem;
		}

	}
	/*
	// Dette er kommentert ut, ettersom det ikke er kode fra timen i dag,
	// men det er en bedre implementasjonav fjern. 
	
	// Hjelpemetode for ? finne noder.
	private Node finnNode(int indeks) {
		// Hvis indeks ikke stemmer
		if (indeks < 0 || indeks >= antallNoder) {
			return null;
		}

		// Traverser listen, finn riktig node. 
		Node tog = hode;
		for (int i = 0; i < indeks; i++) {
			tog = tog.neste;
		}
		return tog;
	}

	public T fjern(int indeks) {
		Node fjerneNode = finnNode(indeks);
		// Indeks over eller under antallNoder.
		if (fjerneNode == null) {
			return null;
		} 
		antallNoder --;

		// Hvis bare ett element i listen
		if (antallNoder == 0) {
			fjernAlt();
			return fjerneNode.elem;
		}

		// Hvis fjerneNode er f?rste element i listen
		if (fjerneNode == hode) {
			hode = fjerneNode.neste;
			return fjerneNode.elem;
		}

		// Finn noden f?r fjerneNode
		Node forrige = finnNode(indeks - 1);

		// Hvis fjerneNode er siste element i listen
		if (fjerneNode == hale) {
			hale = forrige;
		}

		// Sett forrige til ? v?re fjerneNode sin neste
		forrige.neste = fjerneNode.neste;


		return fjerneNode.elem;
	} 

	*/

	public int storrelse(){
		return antallNoder;
	}

	public boolean erTom(){
		return antallNoder == 0;
	}
}