Oppgave 2

  public static int[] nestMaks(int[] a)
  {
    int n = a.length;  // tabellens lengde

    // må ha minst to verdier i tabellen
    if (a.length < 2) throw new
      IllegalArgumentException("a.length(" + a.length + ") < 2!");

    int sist = a.length - 1; // siste posisjon i tabellen

    // starter med å se på første og siste verdi i tabellen
    int m = 0; // første posisjon
    int nm = sist; // siste posisjon

    // m skal være sist hvis a[sist] er større enn a[0]
    if (a[sist] > a[0]) { m = sist; nm = 0; }

    int maksverdi = a[m];  // største verdi
    int nestmaksverdi = a[nm];  // nest største verdi

    int temp = a[sist];            // tar vare på siste verdi
    a[sist] = 0x7fffffff;          // legger tallet 2147483647 sist

    for (int i = 1; ; i++)
    {
      if (a[i] >= nestmaksverdi)
      {
        if (i == sist)
        {
          a[sist] = temp; int[] b = {m,nm}; return b;
        }
        else if (a[i] > maksverdi)
        {
          nm = m; nestmaksverdi = maksverdi;
          m = i; maksverdi = a[m];
        }
        else
        {
          nm = i;
          nestmaksverdi = a[nm]; // ny nest størst
        }
      }
    } // for
  } // nestMaks

Oppgave 3

  public static int[] nestMin(int[] a)
  {
    int n = a.length;   // tabellens lengde

    if (n < 2) throw new IllegalArgumentException
                             ("a.length(" + n + ") < 2!");

    int m = Tabell.min(a);   // m er posisjonen til tabellens minste verdi

    int nm = 0;   // nm står for nestmin

    if (m == 0) nm = Tabell.min(a,1,n);              // leter i a[1:n>
    else if (m == n-1) nm = Tabell.min(a,0,n-1);     // leter i a[0:n-1>
    else
    {
      int mv = Tabell.min(a,0,m);                   // leter i a[0:m>
      int mh = Tabell.min(a,m+1,n);                 // leter i a[m+1:n>
      nm = a[mh] < a[mv] ? mh : mv;           // hvem er minst?
    }

    int[] b = {m,nm};
    return b;  // minste verdi i b[0], nest minste i b[1]

  } // nestMin

Oppgave 4

Ikke laget

  public static int[] tredjeMaks(int[] a)
  {
    int n = a.length;     // tabellens lengde

    if (n < 3)     // må ha minst tre verdier
    {
      throw new IllegalArgumentException("a.length(" + n + ") < 3!");
    }

    int m = 0;     // m er posisjonen til størst verdi
    int nm = 1;    // nm er posisjonen til nest størst verdi
    int tm = 2;    // tm er posisjonen til tredje størst verdi

    // vi bytter om slik at når vi starter er m posisjonen til
    // den største av de tre første, nm er posisjonen til den nest
    // største og tm posisjonen til den minste av de tre første

    if (a[nm] > a[m])
    {
      m = 1;
      nm = 0;
    }

    if (a[tm] > a[m])
    {
      int temp = tm;
      tm = m;
      m = temp;
    }

    if (a[tm] > a[nm])
    {
      int temp = tm;
      tm = nm;
      nm = temp;
    }

    int maksverdi = a[m];                // største verdi
    int nestmaksverdi = a[nm];           // nest største verdi
    int tredjemaksverdi = a[tm];         // tredje største verdi

    for (int i = 3; i < n; i++)
    {
      int verdi = a[i];

      if (verdi > tredjemaksverdi)
      {
        if (verdi > nestmaksverdi)
        {
          if (verdi > maksverdi)
          {
            tm = nm;
            tredjemaksverdi = nestmaksverdi;

            nm = m;
            nestmaksverdi = maksverdi;

            m = i;
            maksverdi = verdi;
          }
          else  // verdi <= maksverdi && verdi > nestmaksverdi
          {
            tm = nm;
            tredjemaksverdi = nestmaksverdi;

            nm = i;
            nestmaksverdi = verdi;
          }
        }
        else // verdi <= nestmaksverdi && verdi > tredjemaksverdi
        {
          tm = i;
          tredjemaksverdi = verdi;
        }
      }

    } // for

    return new int[] { m, nm, tm };
  }