Dvourozměrné pole - WPF

Abychom mohli nalézt ve matici její nejmenší prvek, tj. minimum, musíme nejprve deklarovat metodu, která bude prohledávat a porovnávat prvky matice s dosud nejmenším nalezeným prvkem. Proto v regionu Operace s polem, která je součástí regionu Pomocné metody, budeme deklarovat metodu MinimumVPoli, která navrací celočíselnou hodnotu minima, a zároveň má tato metoda výstupní parametry (uvozený klíčovým slovem out), které představují index řádku a sloupce nalezeného minima - viz Kód 1. 

V metodě je deklarována lokální proměnná minimum, do níž je uložena hodnota nejmenšího prvku matice. My však oproti hledání minima v jednorozměrném poli nyní využijeme jiný princip. Na začátku do proměnné minimum uložíme co nejvyšší hodnotu, tj. maximální hodnotu příslušného datového typu int. Je tedy zřejmé, že jakýkoliv prvek v matici může být stejný, nebo menší (což je vysoce pravděpodobné). Jako další krok provedeme inicializaci hodnotou -1 výstupních parametrů metody, které představují  pozici minima v matici. 

V metodě tradičně použijeme pro procházení prvků matice dva cykly s krokem. První pro procházení řádků, druhý pro procházení sloupců. Ve vnitřním cyklu je porovnán aktuální prvek s nejmenším dosud nalezeným prvkem, jehož hodnota je uložena v proměnné minimum. Podstata metody tkví v podmínce, že pokud aktuálně procházený prvek je menší než minimum, je hodnota tohoto prvku uložena do proměnné minimum. Zároveň musí být uložen index řádku a sloupce tohoto prvku matice. 

Po ukončení průchodu všemi prvky matice je hodnota minima přiřazena výstupu metody.

/// <summary>
/// Metoda pro hledání nejmenšího prvku v matici
/// </summary>
/// <param name="m"> počet řádků matice </param>
/// <param name="n"> počet sloupců matice </param>
/// <param name="pole"> matice </param>
/// <param name="indexRadkuMinima"> index řádku minima </param>
/// <param name="indexSloupceMinima"> index sloupce minima </param>
/// <returns> celočíselná hodnota minima </returns>
private int MinimumVPoli(int m, int n, int[,] pole, out int indexRadkuMinima, out int indexSloupceMinima)
{
    // Lokální proměnné: 'i' - index řádku; 'j' - index sloupce; 'minimum' - hodnota minima
    int minimum;
    // Přiřazení maximální možné hodnoty datového typu int
    minimum = int.MaxValue;
    // Přiřazení hodnoty 0 do indexu řádku a sloupce minima - nutná inicializace
    indexRadkuMinima = indexSloupceMinima = -1;
    // Procházení řádků matice
    for (int i = 0; i < m; i++)
    {
        // Procházení sloupců matice
        for (int j = 0; j < n; j++)
        {
            // Pokud je nalezen prvek v matici, jehož hodnota je menší než minimum...
            if (pole[i, j] < minimum)
            {
                // Uložení hodnoty nalezeného prvku do minima
                minimum = pole[i, j];
                // Přiřazení indexu řádku aktuálního prvku do indexu řádku minima
                indexRadkuMinima = i;
                // Přiřazení indexu sloupce aktuálního prvku do indexu sloupce minima
                indexSloupceMinima = j;
            }
        }
    }
    // Přiřazení hodnoty nalezeného minima do výstupu metody
    return minimum;
}

Kód 1: Deklarace metody s návratem pro hledání minima matice včetně jeho pozice (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. V tomto případě však do proměnné maximum na začátku metody uložíme nejmenší možnou hodnotu datového typu int.

/// <summary>
/// Metoda pro hledání největšího prvku v matici
/// </summary>
/// <param name="m"> počet řádků matice </param>
/// <param name="n"> počet sloupců matice </param>
/// <param name="pole"> matice </param>
/// <param name="indRadkuMaxima"> index řádku maxima </param>
/// <param name="indexSloupceMaxima"> index sloupce maxima </param>
/// <returns> celočíselná hodnota maxima </returns>
private int MaximumVPoli(int m, int n, int[,] pole, out int indRadkuMaxima, out int indexSloupceMaxima)
{
    // Lokální proměnné: 'i' - index řádku; 'j' - index sloupce; 'maximum' - hodnota maxima
    int maximum;
    // Přiřazení nejmenší možné hodnoty datového typu int
    maximum = (-int.MaxValue - 1);
    // Přiřazení hodnoty 0 do indexu řádku a sloupce maxima - nutná inicializace
    indRadkuMaxima = indexSloupceMaxima = -1;
    // Procházení řádků matice
    for (int i = 0; i < m; i++)
    {
        // Procházení sloupců matice
        for (int j = 0; j < n; j++)
        {
            // Pokud je nalezen prvek v matici, jehož hodnota je větší než maximum...
            if (pole[i, j] > maximum)
            {
                // Uložení hodnoty nalezeného prvku do minima
                maximum = pole[i, j];
                // Přiřazení indexu řádku aktuálního prvku do indexu řádku maxima
                indRadkuMaxima = i;
                // Přiřazení indexu sloupce aktuálního prvku do indexu sloupce maxima
                indexSloupceMaxima = j;
            }
        }
    }
    // Přiřazení hodnoty nalezeného maxima do výstupu metody
    return maximum;
}

Kód 2: Deklarace metody s návratem pro hledání maxima matice včetně jeho pozice (MaximumVPoli)

Přemístíme se zpět do regionu Události a jeho části Operace s polem. V tomto regionu upravíme metodu obsluhy události stisknutí tlačítka BtnMinimum - viz Kód 3. V rámci těla metody budeme deklarovat lokální proměnnou minimum, do které uložíme návrat volané metody MinimumVPoli, které bude obsahovat pět parametrů. První a druhý parametr je počet řádků a počet sloupců matice, které jsou uloženy v datové složce třídy. Jako třetí parametr předáme matici. Čtvrtý výstupní parametr uvozený klíčovým slovem out představuje index řádku nalezeného minima v matici. Pátý výstupní parametr obsahuje index sloupce nalezeného minima. Obdržené celočíselné hodnoty hodnoty nalezeného minima a jeho pozice (uzavřené do hranatých závorek a oddělené čárkou) konvertujeme na text pomocí metody Format třídy string. Pro výpis hodnot použijeme indexaci prvků ve složených závorkách.

/// <summary>
/// Volání metody pro určení minima a jeho pozice v matici
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BtnMinimum_Click(object sender, RoutedEventArgs e)
{
    /* Lokální proměnné: 'minimum' - hodnota minima v matici; 'indexRadkuMinima' - 
        * index řádku minima; 'indexSloupceMinima' - index sloupce minima */
    int minimum;
    /* Přiřazení výstupu metody pro určení minima do lokální proměnné a výstupní parametry 
        * určující index řádku ('indexRadkuMinima') a sloupce ('indexSloupceMinima') minima */
    minimum = this.MinimumVPoli(this.pocetRadku, this.pocetSloupcu, this.pole, 
        out int indexRadkuMinima, out int indexSloupceMinima);
    /* Zobrazení textu spolu s hodnotou minima a indexu řádku a sloupce minima 
        * do objektu (TextBox) na formuláři */
    this.TxtVysledek.Text = string.Format("Minimum = {0} (na pozici [{1}, {2}])", 
        minimum, indexRadkuMinima, indexSloupceMinima);
}

Kód 3: Deklarace metody pro zavolání metody pro hledání minima a jeho pozice - výpis na formuláři (BtnMinimum_Click)

Stejně jako u předchozí metody postupujeme v metodě BtnMaximum_Click umístěné ve stejném regionu - viz Kód 4.

/// <summary>
/// Volání metody pro určení maxima a jeho pozice v matici
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BtnMaximum_Click(object sender, RoutedEventArgs e)
{
    /* Lokální proměnné: 'maximum' - hodnota maxima v matici; 'indexRadkuMaxima' - 
        * index řádku maxima; 'indexSloupceMaxima' - index sloupce maxima */
    int maximum;
    /* Přiřazení výstupu metody pro určení maxima do lokální proměnné a výstupní parametry 
        * určující index řádku ('indexRadkuMaxima') a sloupce ('indexSloupceMaxima') maxima */
    maximum = this.MaximumVPoli(this.pocetRadku, this.pocetSloupcu, this.pole,
        out int indexRadkuMaxima, out int indexSloupceMaxima);
    /* Zobrazení textu spolu s hodnotou maxima a indexu řádku a sloupce maxima 
        * do objektu (TextBox) na formuláři */
    this.TxtVysledek.Text = string.Format("Maximum = {0} (na pozici [{1}, {2}])",
        maximum, indexRadkuMaxima, indexSloupceMaxima);
}

Kód 4: Deklarace metody pro zavolání metody pro hledání maxima a jeho pozice - výpis na formuláři (BtnMaximum_Click)