Oppgave 2

  Double[] d = {5.7,3.14,7.12,3.9,6.5,7.1,7.11};
  Tabell.innsettingssortering(d, Komparator.naturligOrden());

  System.out.println(Arrays.toString(d));
  // Utskrift: [3.14, 3.9, 5.7, 6.5, 7.1, 7.11, 7.12]

  Tabell.innsettingssortering(d, Komparator.omvendtOrden());

  System.out.println(Arrays.toString(d));
  // Utskrift: [7.12, 7.11, 7.1, 6.5, 5.7, 3.9, 3.14] 

Oppgave 3

  Boolean[] b = {false, true, true, false, false, true, false, true};
  Tabell.innsettingssortering(b, Komparator.naturligOrden());

  System.out.println(Arrays.toString(b));
  // Utskrift: [false, false, false, false, true, true, true, true]  

Oppgave 4

  Person[] p = new Person[5];                       // en persontabell
  p[0] = new Person("Kari", "Svendsen");            // Kari Svendsen
  p[1] = new Person("Boris", "Zukanovic");          // Boris Zukanovic
  p[2] = new Person("Ali", "Kahn");                 // Ali Kahn
  p[3] = new Person("Azra", "Zukanovic");           // Azra Zukanovic
  p[4] = new Person("Kari", "Pettersen");           // Kari Pettersen

  Tabell.innsettingssortering(p, Komparator.orden(Person::etternavn));
  System.out.println(Arrays.toString(p));

Oppgave 5

  Tabell.innsettingssortering(s, (x,y) -> y.length() - x.length());

eller

  Tabell.innsettingssortering(s, Komparator.orden(x -> -x.length()));

Oppgave 6

a) Bruk flg. versjon av toString:

  Tabell.innsettingssortering(a, Komparator.orden(x -> Integer.toString(x)));

Binærkoder:

  Integer[] a = {13,25,11,3,2,21,10,1,33,100};  // en Integer-tabell
  Tabell.innsettingssortering(a, Komparator.orden(x -> Integer.toBinaryString(x)));
  for (Integer x : a) System.out.print(Integer.toBinaryString(x) + " ");
  // Utskrift: 1 10 100001 1010 10101 1011 11 11001 1100100 1101
 

Sortering etter lengden på binærkoden.
For lesbarhetens skyld setter vi opp funksjonen og komparatoren separat:

  Integer[] a = {13,25,11,3,2,21,10,1,33,100};  // en Integer-tabell

  Funksjon<Integer,String> f = x -> Integer.toBinaryString(x);
  Komparator<String> c = Komparator.orden(String::length);

  Tabell.innsettingssortering(a, Komparator.orden(f, c));

  for (Integer x : a) System.out.print(Integer.toBinaryString(x) + " ");
  // Utskrift: 1 11 10 1101 1011 1010 11001 10101 100001 1100100

Oppgave 7

  Double[] d = {5.7,3.14,7.12,3.9,6.5,7.1,7.11};

  int m = Tabell.maks(d, Komparator.naturligOrden());
  System.out.println(d[m]);  // utskrift: 7.12

  m = Tabell.maks(d, Komparator.omvendtOrden());
  System.out.println(d[m]);  // utskrift: 3.14

Oppgave 8

Her brukes første versjon av innsettingssortering, dvs. den for sammenlignbare datatyper:

  Integer[] a = Tabell.randPermInteger(150000);
  long tid = System.currentTimeMillis();
  Tabell.innsettingssortering(a);
  System.out.println(System.currentTimeMillis() - tid);

Hvis en bruker komparatorversjonen av innsettingssortering, vil en nok se at den tar litt lenger tid. Kanskje 20% lenger tid. Vi kan imidlertid forbedre den ved å la den være object-basert istedenfor generisk. Bytt ut metoden naturligOrden() i grensesnittet Komparator med flg. versjon og sjekk tidsforbruket:

  @SuppressWarnings("unchecked")
  public static <T extends Comparable<? super T>> Komparator<T> naturligOrden()
  {
    return (Komparator<T>) new Komparator<Comparable<Object>>()
    {
      @Override
      public int compare(Comparable<Object> c1, Comparable<Object> c2)
      {
        return c1.compareTo(c2);
      }
    };
  }