Dvourozměrné pole - konzole

Nalezení nejmenší, nebo největší hodnoty (minima, nebo maxima) v dvourozměrném poli je založené na stejném principu, jako hledání těchto prvků v jednorozměrném poli. Mějme např. čtvercovou matici s názvem pole o rozměrech m x n, tj. 3 x 3 (matice je symetrická, tzn. m = n) a v níž chceme nalézt minimum (prvek označen zelenou barvou) a maximum (prvek je označen modrou barvou) - viz Obrázek 1. Abychom nalezli minimum, je zapotřebí nejprve přiřadit minimu počáteční hodnotu. V našem případě minimu přiřadíme hodnotu počátečního prvku matice (tj. prvek, jehož oba indexy jsou rovny nule). 

Obrázek 1: Minimum a maximum dvourozměrného pole

Pro procházení všech prvků matice použijeme dva cykly s krokem. První vnější cyklus pro procházení jednotlivých řádků matice a druhý vnitřní cyklus pro procházení sloupců matice. Každý prvek pak porovnáváme s dosud nejlepším nalezeným prvkem (v případě minima s nejmenší nalezenou hodnotou a v případě maxima s největší nalezenou hodnotou). Toto porovnání tedy proběhne celkem m*n-krát - viz Obrázek 2. Samozřejmě je také možné procházet prvky opačným směrem, tj. od posledního prvku směrem k počátečnímu prvku a porovnávat tyto prvky s minimem, nebo maximem. 

Obrázek 2: Hledání minima dvourozměrného pole

Zkusme si popsat metodu MinimumVPoli umístěnou v regionu Operace s polem. Tato metoda navrací minimum matice - viz Kód 1. Tato metoda přijímá tři vstupní parametry - první definuje počet řádků matice, druhý počet sloupců matice a do třetího parametru je uložena matice, ve které hledáme nejmenší hodnotu. Dále metoda obsahuje výstupní parametry indexRadku a indexSloupce. První výstupní parametr naplněný v metodě představuje index řádku nalezeného minima matice. Druhý výstupní parametr představuje index sloupce nalezeného minima matice. V metodě jsou deklarovány následující proměnné:

• minimum - nalezená minimální hodnota v matici
• i - index řádku matice, ve které se nachází prvek (deklarace přímo v cyklu)
• j - index sloupce matice, ve které se nachází prvek (deklarace přímo v cyklu)
  

Jako první krok je zapotřebí přiřadit proměnné minimum hodnotu počátečního prvku matice. V dalším kroku je nastavena pozice, která zahrnuje index řádku a sloupce minima. Vzhledem k tomu, že jsme počáteční prvek prohlásili minimem, nastavíme index řádku a sloupce minima na hodnotu 0. Následně pro procházení dalších prvků využijeme dva cykly s krokem (první pro procházení řádků a vnitřní pro procházení sloupců matice), pomocí kterých budeme procházet jednotlivé prvky matice. 

Je vhodné podotknout, že bychom nemuseli předávat parametry vyjadřující rozměry pole v každé ose, tj. počet řádků, nebo počet sloupců. Namísto toho bychom mohli předat pouze matici. Ve třídě pro pole je totiž implementována metoda GetUpperBound. Tato metoda přidružená k poli, která lze vyvolat pomocí tečkové notace, tj. pole.GetUpperBound, navrací velikost pole pro jednotlivé osy. Index osy je předán jako parametr (v případě dvourozměrného pole jsou osy dvě - vertikální - řádky, tj. index 0 a horizontální - sloupce, tj. index 1). 

Uvnitř vnitřního cyklu je provedeno porovnání hodnoty aktuálního prvku s dosud nalezeným minimem. Pokud je nalezen prvek, jehož hodnota je menší než minimum, je tato hodnota prohlášena novým minimem, tj. hodnota prvku je přiřazena do proměnné minimum. Musí být také zaznamenán index řádku minima do výstupního parametru indexRadku (tj. indexRadku = i;). V dalším příkazu je zaznamenán index sloupce  minima do výstupního parametru indexSloupce (indexSloupce = j;). Návratu metody je přiřazeno nalezené minimum ze všech prvků matice - viz Kód 1.

/// <summary>
/// Návrat hodnoty minima matice - nejmenší prvek
/// </summary>
/// <param name="m"> počet řádků matice </param>
/// <param name="n"> počet sloupců matice </param>
/// <param name="pole"> prohledávaná matice </param>
/// <param name="indexRadku"> index řádku minima </param>
/// <param name="indexSloupce"> index sloupce minima </param>
/// <returns> Minimum matice </returns>
static int MinimumVPoli(int m, int n, int[,] pole, out int indexRadku, out int indexSloupce)
{
    /* Deklarace: 'minimum' ... nalezená minimální hodnota v matici; 'i' ... index řádku 
     * matice; 'j' ... index sloupce matice */
    int minimum;
 
    // Hodnotu počátečního prvku prohlásíme minimem
    minimum = pole[0, 0];
 
    // Přiřazení hodnoty 0 do indexu řádku minima
    indexRadku = 0;
 
    // Přiřazení hodnoty 0 do indexu sloupce minima
    indexSloupce = 0;
 
    // Pro všechny řádky matice
    for (int i = 0; i < m; i++)
    {
        // Pro všechny sloupce matice
        for (int j = 0; j < n; j++) 
        {
            // Pokud je aktuálně procházený prvek menší než minimum, pak...
            if (pole[i, j] < minimum)
            {
                // Uložené aktuálního prvku do minima
                minimum = pole[i, j];
 
                // Přiřazení indexu aktuálního řádku do indexu řádku minima
                indexRadku = i;
 
                //přiřazení indexu aktuálního sloupce do indexu sloupce minima
                indexSloupce = j;
            }
        }
    }
 
    // Přiřazení minima návratu metody
    return minimum;
}

Kód 1: Deklarace statické metody s celočíselným návratem s názvem MinimumVPoli

Stejnou podstatu používá metoda MaximumVPoli, která však porovnává všechny prvky s dosud nejvyšší nalezenou hodnotu v matici uloženou do proměnné s názvem maximum - viz Kód 2. Pokud je aktuálně procházený prvek větší, než dosud nalezené maximum, pak přiřadíme tuto hodnotu do maxima.

/// <summary>
/// Návrat hodnoty maxima matice - největší prvek
/// </summary>
/// <param name="m"> počet řádků matice </param>
/// <param name="n"> počet sloupců matice </param>
/// <param name="pole"> prohledávaná matice </param>
/// <param name="indexRadku"> index řádku maxima </param>
/// <param name="indexSloupce"> index sloupce maxima </param>
/// <returns> Maximum matice </returns>
static int MaximumVPoli(int m, int n, int[,] pole, out int indexRadku, out int indexSloupce)
{
    /* Deklarace: 'maximum' ... nalezená maximální hodnota v matici;  'i' ... index řádku 
    *matice; 'j'... index sloupce matice */
    int maximum;
 
    // Hodnotu prvního prvku prohlásíme maximem
    maximum = pole[0, 0];
 
    // Přiřazení hodnoty 0 do indexu řádku maxima
    indexRadku = 0;
 
    // Přiřazení hodnoty 0 do indexu sloupce maxima
    indexSloupce = 0;
 
    // Pro všechny řádky matice
    for (int i = 0; i < m; i++)
    {
        // Pro všechny sloupce matice
        for (int j = 0; j < n; j++)
        {
            // Pokud je aktuálně procházený prvek menší než maximum, pak...
            if (pole[i, j] > maximum)
            {
                // Uložené aktuálního prvku do maxima
                maximum = pole[i, j];
 
                // Přiřazení indexu aktuálního řádku do indexu řádku maxima
                indexRadku = i;
 
                //přiřazení indexu aktuálního sloupce do indexu sloupce maxima
                indexSloupce = j;
            }
        }
    }
 
    // Přiřazení maxima návratu metody
    return maximum;
}

Kód 2: Deklarace statické metody s celočíselným návratem s názvem MaximumVPoli