|
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
|
JavaHamster
Kara
Algorithmen
