Oppgave 1

  String url = "https://www.cs.hioa.no/~ulfu/appolonius/kap11/1/graf1.txt";
  Graf graf = new Graf(url);

  for (String node : graf)  // bruker iteratoren i grafen
  {
    System.out.println(node + " -> " + graf.kanterFra(node));
  }

  Utskrift fra programkjøring:

  A -> [B, C, D]
  B -> [A, D, E]
  C -> [A, D, F]
  D -> [A, B, C, E, F, G]
  E -> [B, D, G]
  F -> [C, D, G]
  G -> [D, E, F]  

Oppgave 2

  String url = "https://www.cs.hioa.no/~ulfu/appolonius/kap11/1/graf2.txt";

  Utskrift fra programkjøring:

  A -> [B, C, D]
  B -> [D, E]
  C -> [D, F]
  D -> [E, F, G]
  E -> [G]
  F -> [G]
  G -> []  

Oppgave 3

graf3.txt eller "https://www.cs.hioa.no/~ulfu/appolonius/kap11/1/graf3.txt";

  Utskrift fra programkjøring:

  A -> [B, D, E]
  B -> [A, C, E]
  C -> [B, E, F]
  D -> [A, E, G]
  E -> [A, B, C, D, F, G, H, I]
  F -> [C, E, I]
  G -> [D, E, H, J, K]
  H -> [E, G, I, K]
  I -> [E, F, H, K, L]
  J -> [G, K, M]
  K -> [G, H, I, J, L, M, N, O]
  L -> [I, K, O]
  M -> [J, K, N]
  N -> [K, M, O]
  O -> [K, L, N]

Oppgave 4

graf4.txt eller "https://www.cs.hioa.no/~ulfu/appolonius/kap11/1/graf4.txt";

  Utskrift fra programkjøring:

  A -> [B, C, D, E, F, G]
  B -> [C, A, G]
  C -> [D, A, B]
  D -> [E, A, C]
  E -> [F, A, D]
  F -> [G, A, E]
  G -> [B, A, F]  

Oppgave 5

  Graf graf = new Graf();

  for (char c = 'A'; c <= 'Z'; c++) graf.leggInnNode(String.valueOf(c));

  for (char c = 'A'; c < 'Z'; c++)
  {
    String fra = String.valueOf(c);
    String til = String.valueOf((char)(c + 1));
    graf.leggInnKant(fra, til);  // kant den ene veien
    graf.leggInnKant(til, fra);  // kant motsatt vei
  }

  graf.leggInnKant("A", "Z");
  graf.leggInnKant("Z", "A");

  for (String node : graf)  // bruker iteratoren i grafen
  {
    System.out.println(node + " -> " + graf.kanterFra(node));
  }

  Utskrift:
  A -> [B, Z]
  B -> [A, C]
  C -> [B, D]
  D -> [C, E]
  E -> [D, F]
  F -> [E, G]
  G -> [F, H]
  H -> [G, I]
  I -> [H, J]
  J -> [I, K]
  K -> [J, L]
  L -> [K, M]
  M -> [L, N]
  N -> [M, O]
  O -> [N, P]
  P -> [O, Q]
  Q -> [P, R]
  R -> [Q, S]
  S -> [R, T]
  T -> [S, U]
  U -> [T, V]
  V -> [U, W]
  W -> [V, X]
  X -> [W, Y]
  Y -> [X, Z]
  Z -> [Y, A]  

Oppgave 6

  Graf graf = new Graf();

  String[] navn = new String[10];
  for (int i = 0; i < 10; i++) navn[i] = String.valueOf(i + 1);
  // navn = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

  for (String n : navn) graf.leggInnNode(n);  // legger inn alle nodene

  for (String fra : navn)  // oppretter kantene
  {
    for (String til : navn) if (!fra.equals(til)) graf.leggInnKant(fra, til);
  }

  for (String node : graf)  // bruker iteratoren i grafen
  {
    System.out.println("  " + node + " -> " + graf.kanterFra(node));
  }

  Legg merke til at 10 kommer rett etter 1 i utskriften. Det kommer av
  at 1 og 10 nå er tegnstrenger og da blir sorteringen 1, 10, 2, osv.

  1 -> [2, 3, 4, 5, 6, 7, 8, 9, 10]
  10 -> [1, 2, 3, 4, 5, 6, 7, 8, 9]
  2 -> [1, 3, 4, 5, 6, 7, 8, 9, 10]
  3 -> [1, 2, 4, 5, 6, 7, 8, 9, 10]
  4 -> [1, 2, 3, 5, 6, 7, 8, 9, 10]
  5 -> [1, 2, 3, 4, 6, 7, 8, 9, 10]
  6 -> [1, 2, 3, 4, 5, 7, 8, 9, 10]
  7 -> [1, 2, 3, 4, 5, 6, 8, 9, 10]
  8 -> [1, 2, 3, 4, 5, 6, 7, 9, 10]
  9 -> [1, 2, 3, 4, 5, 6, 7, 8, 10]  

Oppgave 7

  public int antallNoder()
  {
    return noder.size();
  }

Oppgave 8

  public boolean equals(Object o)
  {
    if (o == this) return true;   // sammenligner med seg selv
    if (o == null || getClass() != o.getClass()) return false;
    return navn.equals(((Node)o).navn);
  }

Oppgave 9

  public boolean erIsolert(String nodenavn)
  {
    Node p = noder.get(nodenavn);
    if (p == null) throw new NoSuchElementException(nodenavn + " er ukjent!");

    return p.kanter.size() == 0 && p.innkanter == 0;
  }

Oppgave 10

  public boolean erKant(String franode, String tilnode)
  {
    Node fra = noder.get(franode);
    if (fra == null) throw new IllegalArgumentException(franode + " er ukjent!");

    Node til = noder.get(tilnode);
    if (til == null) throw new IllegalArgumentException(tilnode + " er ukjent!");

    for (Node n : fra.kanter) if (n.navn.equals(tilnode)) return true;
    return false;
  }

Oppgave 11

  public int grad(String nodenavn)
  {
    Node p = noder.get(nodenavn);
    if (p == null) throw new NoSuchElementException(nodenavn + " er ukjent!");
    return p.kanter.size();
  }

Oppgave 12

  public void skrivGraf(String filnavn) throws IOException
  {
    PrintWriter ut = new PrintWriter(filnavn);

    for (String nodenavn : this)  // bruker iteratoren i grafen
    {
      ut.print(nodenavn);
      Node node = noder.get(nodenavn);

      // bruker iteratoren i kantlisten
      for (Node til : node.kanter) ut.print(" " + til.navn);
      ut.println();
    }

    ut.close();
  }

Oppgave 13

  public String[] kantTabellFra(String node)
  {
    Node fra = noder.get(node);
    if (fra == null) return null;
    String[] kanttabell = new String[fra.kanter.size()];
    int i = 0;
    for (Node p : fra.kanter) kanttabell[i++] = p.navn;
    return kanttabell;
  }

Oppgave 14

  public int antallInnkanter(String node)
  {
    Node p = noder.get(node);              // henter noden
    if (p == null) throw new IllegalArgumentException(node + " er ukjent!");
    return p.innkanter;
  }

Oppgave 15

  public String kanterTil(String nodenavn)
  {
    if (!nodeFinnes(nodenavn)) return "[]";

    StringJoiner sj = new StringJoiner(", ", "[", "]");
    for (String navn : this)
    {
      Node p = noder.get(navn);
      for (Node q : p.kanter) if (q.navn.equals(nodenavn)) sj.add(navn);
    }

    return sj.toString();
  }

  public String[] kantTabellTil(String nodenavn)
  {
    if (!nodeFinnes(nodenavn)) return new String[0];

    ArrayList<String> liste = new ArrayList<>();
    for (String navn : this)
    {
      Node p = noder.get(navn);
      for (Node q : p.kanter) if (q.navn.equals(nodenavn)) liste.add(navn);
    }

    return liste.toArray(new String[0]);
  }

Oppgave 16

  public String[] nodenavn()
  {
    String[] navntabell = new String[noder.size()];
    int i = 0;
    for (String navn : this) navntabell[i++] = navn;
    return navntabell;
  }

Oppgave 17

  public String erUrettet()
  {
    for (Node p : noder.values())
    {
      if (p.innkanter != p.kanter.size())
      {
        return p.navn + " har ulikt antall inn- og utkanter";
      }
    }

    for (Node p : noder.values())
    {
      for (Node q : p.kanter)
      {
        if (!q.kanter.contains(p))
        {
          return "Mangler kant fra " + q.navn + " til " + p.navn;
        }
      }
    }
    return null;
  }

Eksempel på bruk:

  String url = "https://www.cs.hioa.no/~ulfu/appolonius/kap11/1/graf1b.txt";
  Graf graf = new Graf(url);

  String resultat = graf.erUrettet();
  System.out.println(resultat == null ? "Er urettet!" : resultat);
  graf.leggInnKant("C", "A");            // en ny kant
  resultat = graf.erUrettet();
  System.out.println(resultat == null ? "Er urettet!" : resultat);