Logo Logo
InfoHome Themen Projekte Links Software
Themen
JavaHamster
BlueJ
Java
HTML
XHTML
CSS
XML
Datenbanken
MySQL
Theoretische Informatik
PHP
Kara
Lego-Roboter
Algorithmen
Dijkstra
Definitionen
Einfache Datentypen
Flussdiagramme
Einfache Algorithmen
Arrays
Mehrdim. Arrays

Mehrdimensionale Arrays - Arrays aus Arrays

Mehrdimensionale Arrays werden als Arrays von Arrays angelegt, indem zwei oder mehr Paare eckiger Klammern bei der Deklaration angegeben werden. Die Erzeugung erfolgt analog zu eindimensionalen Arrays durch Angabe der Anzahl der Elemente je Dimension. Ein zweidimensionales Array kann als Matrix dargestellt werden.

// die erste Dimensionsangabe lässt sich als Anzahl der Zeilen der Matrix interpretieren,
// die zweite Dimensionsangabe als Anzahl der Spalten. Hier wird also eine 2x3 Matrix erzeugt.
int[][] matrix = new int[2][3];

Der Zugriff auf mehrdimensionale Arrays geschieht durch Angabe aller erforderlichen Indizes, jeweils in eckigen Klammern.

matrix[0][0] = 1;
matrix[1][2] = 5;

Auch bei mehrdimensionalen Arrays können Deklaration, Erzeugung und Initialisierung in verkürzter Syntax vorgenommen werden.

int[][] matrix = {{1,2,3},{4,5,6}};

Das folgende Programm erzeugt ein Array und füllt es mit (Unter-)Arrays:

public class ArrayOfCartoons {
   
    public static void main(String[] args) {

        String[][] cartoons =
        {
                { "Flintstones", "Fred", "Wilma", "Pebbles", "Dino" },
                { "Rubbles", "Barney", "Betty", "Bam Bam" },
                { "Jetsons", "George", "Jane", "Elroy", "Judy", "Rosie", "Astro" },
                { "Scooby Doo Gang", "Scooby Doo", "Shaggy", "Velma", "Fred", "Daphne" }
        };

        // mit cartoons.length bekommt man die Anzahl der Zeilen (hier 4)
        for (int i = 0; i<cartoons.length; i++) {
           
            // mit cartoons[0].length bekommt man die Länge der 1. Zeile (hier 5)
            // mit cartoons[1].length bekommt man die Länge der 2. Zeile (hier 4), usw.
            for (int j = 1; j<cartoons[i].length; j++) {
                // print macht keinen Zeilenwechsel, Wertausgabe mit angehängtem Leerzeichen
                System.out.print(cartoons[i][j] + " ");
            }
           
            // println (steht für "print line") macht Zeilenwechsel
            System.out.println();
        }       
    }
   
}

Und noch mal dasselbe ohne Verwendung der abkürzenden Schreibweise:

public class ArrayOfCartoons {
    
    public static void main(String[] args) {
        // deklarieren und Erzeugen einer 2-dim-Matrix für Zeichenketten (Strings)
        // so ensteht eine Matrix aus 4 Zeilen und 5 Spalten
        String[][] cartoons = new String[4][5];

        // Matrix füllen
        cartoons[0][0] = "Flintstones";
        cartoons[0][1] = "Fred";
        cartoons[0][2] = "Wilma";
        cartoons[0][3] = "Pebbles";
        cartoons[0][4] = "Dino";
        cartoons[1][0] = "Rubbles";
        cartoons[1][1] = "Barney";
        // ...

        // Matrix ausgeben
        for (int i = 0; i<cartoons.length; i++) {
            for (int j = 0; j<cartoons[i].length; j++) {
                System.out.print(cartoons[i][j] + " ");
            }
            System.out.println();
        }
    }

}

Aufgaben

Aufgabe 1: 

Ein magisches Quadrat ist eine Tabelle mit n Zeilen und n Spalten, gefüllt mit den ersten n2 natürlichen Zahlen (beginnend mit 1), wobei die Summe der Zahlen in jeder Zeile, Spalte und Diagonale gleich ist. Schreiben Sie ein Programm, das ein magisches Quadrat der Größe n x n erzeugt und auf dem Bildschirm ausgibt. Gehen Sie dabei wie folgt vor:

a) Im Eingabeteil soll zunächst eine ganze Zahl in die anfangs mit 0 initialisierte int-Variable n eingelesen werden. Dies soll eventuell wiederholt geschehen, bis sichergestellt ist, dass der Wert von n größer als 0, kleiner als 10 und ungerade ist.

b) Deklarieren und erzeugen Sie ein zweidimensionales int-Array der Größe n x n.

c) Definieren Sie eine int-Variable zeile und initialisieren Sie diese mit dem (ganzzahligen) Wert n/2.

d) Definieren Sie eine int-Variable spalte und initialisieren Sie diese mit dem (ganzzahligen) Wert n/2 + 1.

e) Initialisieren Sie eine int-Variable i mit dem Wert 1 und wiederholen Sie die folgenden Schritte, solange i kleiner oder gleich n*n ist:

  • Weisen Sie dem Element an der Stelle [zeile] [spalte] des Arrays quad den Wert i zu.
  • Erhöhen Sie spalte um 1, erniedrigen Sie zeile um 1.
  • Wenn zeile kleiner als 0 ist, weisen Sie zeile den Wert n-1 zu.
  • Wenn spalte gleich n ist, weisen Sie spalte den Wert 0 zu.
  • Wenn das Element an der Stelle [zeile][spalte] des Arrays nicht den Wert 0 hat, führen Sie folgende Schritte durch:
    - Erhöhen Sie zeile und spalte um 1.
    - Wenn zeile gleich n ist, weisen Sie zeile den Wert 0 zu.
    - Wenn spalte gleich n ist, weisen Sie spalte den Wert 0 zu.
  • Erhöhen Sie i um 1.

f) Überlegen Sie sich, wie eine geeignete Bildschirmausgabe des magischen Quadrates aussehen könnte, und realisieren Sie diese.

Wir wollen nun mit Hilfe geeigneter Methoden Zeilen-, Spalten- und Diagonalensummen automatisch berechnen lassen, um die Richtigkeit des obigen Algorithmus auch für Dimensionen >=5 leicht überprüfen zu können.

Ergänzen Sie Methoden zur Überprüfung der Spalten- und Diagonalensummen und wenden Sie diese auf das Quadrat an.

Lösung:

public class MagischesQuadrat {

    // Zahlenquadrat als globale Variable definieren
    public static int[][] quadrat;
   
    // Zeilensumme von Zeile i berechnen
    public static int zeilensumme(int i){
        int summe = 0;
        for(int j=0; j<quadrat[0].length; j++){
            summe += quadrat[i][j];
        }
        return summe;
    }
   
    // Spaltensumme von Spalte j berechnen
    public static int spaltensumme(int j){
        int summe = 0;
        for(int i=0; i<quadrat.length; i++){
            summe += quadrat[i][j];
        }
        return summe;
    }

    // Diagonale von links oben nach rechts unten
    public static int diagonaleLORU(){
        int summe = 0;
        for(int i=0; i<quadrat.length; i++){
            summe += quadrat[i][i];
        }
        return summe;
    }

    // Diagonale von rechts oben nach links unten
    public static int diagonaleROLU(){
        int summe = 0;
        for(int i=0; i<quadrat.length; i++){
            summe += quadrat[i][quadrat.length-1-i];
        }
        return summe;
    }

    // Hauptprogramm
    public static void main(String[] args) {
       
        int n = 11; // Eingabe "von Hand"
       
        quadrat = new int[n][n];
       
        // Magisches Quadrat erstellen
        int zeile  = n / 2;
        int spalte = n / 2 + 1;
       
        for(int i=1; i <= n*n; i++){
            quadrat[zeile][spalte] = i;
            spalte++; zeile--;
           
            if(zeile < 0) zeile = n - 1;
            if(spalte == n) spalte = 0;
           
            if(quadrat[zeile][spalte] != 0){
                zeile++; spalte++;
                if(zeile == n) zeile = 0;
                if(spalte == n) spalte = 0;
            }
        }
       
        // Quadrat ausgeben
        for(int i=0; i<quadrat.length; i++){
            for(int j=0; j<quadrat[0].length; j++){
                System.out.print(quadrat[i][j] + " ");
            }
            System.out.println();
        }
       
        System.out.println();
   
        // Zeilensummen ausgeben
        for(int i=0; i<quadrat.length; i++){
            System.out.println((i+1) + ". Zeile: " + zeilensumme(i));
        }
        System.out.println();
       
        // Spaltensummen ausgeben
        for(int j=0; j<quadrat[0].length; j++){
            System.out.println((j+1) + ". Spalte: " + zeilensumme(j));
        }
        System.out.println();

        // Diagonale LORU ausgeben
        System.out.println("Diagonale von links oben nach rechts unten: " + diagonaleLORU());
        System.out.println();

        // Diagonale ROLU ausgeben
        System.out.println("Diagonale von links oben nach rechts unten: " + diagonaleROLU());

    }

}

Aufgabe 2:

Ein digitales Graustufenbild enthält die Daten in Form eines zweidimensionalen Arrays, das Zahlenwerte aus dem Bereich 0 (schwarz) bis 255 (weiß) enthält. Gegeben ist ein solches Array "bild" mit den Dimensionen "breite" und "hoehe", wobei die Variablen "breite" und "hoehe" die Anzahl der Pixel in x-Richtung bzw. y-Richtung darstellen.

  • Geben Sie eine Deklaration des Arrays an und implmentieren Sie eine Operation, die das Negativ des Bildes erzeugt (dies ist die Differenz der jeweiligen Grauwerte zur Farbe weiß). Erläutern Sie den Algorithmus.
  • Implementieren Sie eine Operation, die das ganze Bild an einer vertikalen Achse durch die Bildmitte spiegelt. Erläutern Sie den Algorithmus.

Lösung:

public class Graustufenbild {

    public static int[][] bild = new int[5][5];
   
    // Bildausgabe als eigene Methode, weil die Bildmatrix
    // mehrfach ausgegeben werden soll...
    public static void bildmatrixAusgeben(){
        for(int i=0; i<bild.length; i++){
            for(int j=0; j<bild[0].length; j++){
                System.out.print(bild[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();
    }
   
    public static void invertieren(){
        for(int i=0; i<bild.length; i++){
            for(int j=0; j<bild[0].length; j++){
                bild[i][j] = 255 - bild[i][j];
            }
        }
    }
   
    public static void spiegelnAnVertikaleDurchBildmitte(){
        // wir müssen alle Zeilen durchgehen...
        for(int i=0; i<bild.length; i++){

            // aber nicht alle Spalten, da ja paarweise getauscht wird...
            // j muss im Fall n=5 die Werte 0 und 1 annehmen
            // die innere Schleife wird also genau zweimal durchlaufen
            // im Allgemeinen nimm n alle Werte an, die kleiner sind als n/2
            // im Falle n=5 ist n/2 gleich 2 (5 ganzzahlig durch 2)
            // wäre z.B. n=4 so ist n/2 auch gleich 2 (4 durch 2)
            // auch in diesem Fall tauschen zwei Zeichenpaare miteinander die Plätze.
            for(int j=0; j<bild[0].length/2; j++){
                // das Vertauschen erfordert jeweils ein Zwischenspeichern!
                // dazu dient hier die Variable k
                int k = bild[i][j];
                bild[i][j] = bild[i][bild.length-1-j];
                bild[i][bild.length-1-j] = k;
            }
        }
    }
   
   
    public static void main(String[] args) {
       
        // Matrix mit Werten füllen, zunächst alle Pixel auf 'weiß' setzen
        for(int i=0; i<bild.length; i++){
            for(int j=0; j<bild[0].length; j++){
                bild[i][j] = 255;
            }
        }
       
        // nun einzelne Pixel mit vorgegebenen Werten füllen
        bild[0][1] = 80;
        bild[1][1] = 100;
        bild[1][3] = 60;
        bild[2][1] = 0;
        bild[2][2] = 20;
        bild[2][3] = 150;
        bild[2][4] = 0;
        bild[3][3] = 150;
        bild[4][3] = 20;
       
        // Ausgabe
        bildmatrixAusgeben();
        //invertieren();
        spiegelnAnVertikaleDurchBildmitte();
        bildmatrixAusgeben();

    }

}

 

» drucken: pdf | html

© 2004-2022 M. Blanke · Ursulaschule · Kleine Domsfreiheit 11-18 · 49074 Osnabrück