Jednorozměrné pole - konzole

1. JednorozmernePole

Úkolem je vytvořit aplikaci, která by dovedla pro jednorozměrné pole, tj. vektor, obsahující celá čísla:

• Naplnit vektor automaticky nulami
• Naplnit vektor automaticky náhodnými hodnotami v zadaném rozsahu
• Naplnit vektor jednotlivě zadávanými hodnotami pro zadaný index
• Zobrazit vektor jako text oddělený čárkami (prvky budou umístěny v řádku)
• Zobrazit vektor do sloupce (prvky budou umístěny pod sebou)
• Nalézt minimum z hodnot vektoru
  
• Nalézt maximum z hodnot vektoru
• Vypočítat průměr z hodnot vektoru
• Seřadit vektor vzestupně podle velikosti prvků

Účel příkladu

• Práce s jednorozměrným polem (vektorem)
  

Typ aplikace

• Konzolová aplikace

Popis úkolu 

• Základní operace s jednorozměrným polem 

Funkčnosti

• V hlavním programu může uživatel pomocí zavolaného podprogramu (funkce) RozmerPole změnit rozměr (počet prvků) vektoru
• V hlavním programu může uživatel pomocí zavolaného podprogramu (funkce) DolniMez změnit dolní mez, od které se budou pohybovat hodnoty prvků vektoru
• V hlavním programu může uživatel pomocí zavolaného podprogramu (funkce) HorniMez změnit horní mez, do které se budou pohybovat hodnoty prvků vektoru
• Z hlavního programu bude volán podprogram (procedura) PlnitPole, ve kterém uživatel volí způsob plnění vektoru:
• 0 ... Náhodně - náhodnými čísly
• 1 ... Jednotlivě - jednotlivě zadanými hodnotami uživatelem
• 2 ... Nulovat - plnění vektoru nulami
• V hlavním programu bude volán podprogram (funkce) PoleJakoText, pomocí kterého se prvky vektoru vypíší do řádku jako text, kde jednotlivé prvky budou od sebe odděleny čárkami
• V hlavním programu bude volán podprogram (funkce) ZobrazitPole, pomocí kterého se prvky vektoru vypíší do sloupce jako text, kde jednotlivé prvky jsou umístěny pod sebou a každý na samostatném řádku
• V hlavním programu bude volán podprogram (funkce) MinimumVPoli, pomocí kterého je vyhledáno minimum z hodnot ve vektoru. Ve výpisu také bude uveden index minima ve vektoru. Pro vyhledání pořadí použijte podprogram (funkci) IndexPrvku, který navrátí celočíselný index vyhledaného minima
• V hlavním programu bude volán podprogram (funkce) MaximumVPoli, pomocí kterého je vyhledáno maximum z hodnot ve vektoru. Ve výpisu také bude uveden index maxima ve vektoru. Pro vyhledání pořadí použijte podprogram (funkci) IndexPrvku, který navrátí celočíselný index vyhledaného maxima
• V hlavním programu bude volán podprogram (funkce) PrumerPole, pomocí kterého je vypočten aritmetický průměr z hodnot vektoru
• V hlavním programu bude volán podprogram SeraditPole, pomocí kterého jsou prvky vektoru seřazeny vzestupně podle jejich hodnoty. Seřazený vektor bude vypsán pomocí obou podprogramů určených pro výpis vektoru
• Po výpisu bude aplikace ukončena po stisku klávesy

Výstup programu

Výstup programu: Ukázka výpisu vektoru v hlavní metodě programu JednorozmernePole

2. Analýza a návrh řešení

Pole je datová struktura skládající se z prvků stejného datového typu. K těmto prvkům přistupujeme pomocí indexů, kde k počátečnímu prvku (v pořadí prvního prvku vektoru) přistupujeme pomocí indexu 0, k dalšímu prvku je přístup s indexem o 1 vyšší než předchozí, atd. - viz Obrázek 1. 

Obrázek 1: Jednorozměrné pole - princip

Velikost jednorozměrného pole (v našem případě n) je určena počtem prvků, do kterých lze ukládat hodnoty. Pro přístup k hodnotě uložené v prvku, nebo k uložení hodnoty do prvku (přiřazení hodnoty) využíváme název jednorozměrného pole s indexem uzavřeným v hranatých závorkách, např. pomocí příkazu pole[2] = 3 uložíme v jednorozměrném poli s názvem pole hodnotu 3 ve třetím prvku od začátku (index tohoto prvku je o 1 méně, tedy 2). Jak vidíme na příkladu, velikost pole je n = 4, tzn. pole obsahuje 4 prvky - viz Obrázek 2. Ve Flowgorithm lze využít pro návrat velikosti jednorozměrného pole funkci Size, jejímž parametrem je pole, pro které chceme zjistit velikost.

Obrázek 2: Příklad naplnění 3. prvku jednorozměrného pole (index = 2) hodnotou 3 

Pokud bychom chtěli číst hodnotu uloženou v prvku, stačí uvést název pole s hranatou závorkou obsahující index prvku, jehož hodnotu chceme načíst. 

V závislosti na dimenzi pole (počet os v prostoru) budeme využívat určitý počet indexů pro přístup k prvku. U jednorozměrného pole - vektoru, potřebujeme pro přístup k prvku jeden index, u dvourozměrného pole - matice - dva indexy, které jsou odděleny čárkou,  pro třírozměrné pole tři indexy, atd. 

V hlavním programu našeho algoritmu JednorozmernePole nejprve deklarujeme základní atributy jednorozměrného pole:

• pocetPrvku - rozměr vektoru (počet prvků ve vektoru)
• Max - maximální přípustná velikost vektoru (konstanta)
• minHodnota - přípustná minimální hodnota (dolní mez) prvků vektoru
• maxHodnota - přípustná maximální hodnota (horní mez) prvků vektoru

Po provedení inicializace všech vyjmenovaných atributů vektoru dáme uživateli možnost nastavit velikost pole pomocí funkce RozmerPole. Tato funkce navrací počet prvků, který bude vektor obsahovat. Funkce přijímá dva parametry - stávající počet prvků vektoru uložený v proměnné pocetPrvku, jejíž hodnotu inicializujeme celočíselnou maximální přípustnou hranicí velikosti pole, tj. Max. Tato hranice je druhým parametrem této funkce.

Pro deklaraci jednorozměrného pole je zapotřebí specifikovat datový typ prvků, které bude vektor obsahovat. Dále je zapotřebí definovat velikost pole. Pro specifikaci dolní meze, tj. minimální hodnoty, které může prvek nabýt, určíme pomocí funkce DolniMez. Naproti tomu horní mez určíme pomocí volání funkce HorniMez. 

Uživatel má možnost zvolit způsob plnění vektoru pomocí procedury PlnitPole. K dispozici má tři možnosti:

• 0 - Náhodně - náhodnými čísly - volání 
• 1 - Jednotlivě - jednotlivě zadanými hodnotami uživatelem
• 2 - Nulovat - plnění vektoru nulami

• PoleJakoText - slouží pro výpis hodnot prvků vektoru do řádku, kde jednotlivé prvky jsou od sebe odděleny čárkami
• ZobrazitPole - výpis prvků vektoru do sloupce, kde každý prvek je na nové řádce. Jednorozměrný vektor můžeme chápat i jako jeden sloupec, kde k jednotlivým prvkům znovu přistupujeme pomocí indexu - viz Obrázek 3.  

Obrázek 3: Jednorozměrné pole - otočené

Další volanou funkcí z hlavního programu je MinimumVPoli. Tato funkce vyhledá nejmenší hodnotu ze všech hodnot uložených ve vektoru. Ve výpisu je také využita funkce IndexPrvku, která vyhledá prvek ve vektoru a navrátí jeho index. Tato funkce přijímá dva parametry - prvek, který má být vyhledán a vektor, ve kterém budeme prvek hledat. V tomto případě hledáme index prvku obsahující minimum, proto jako parametr funkce IndexPrvku využijeme návratu funkce MinimumVPoli, která nám poskytne nejmenší prvek vektoru. Stejný přístup využijeme při hledání největšího prvku vektoru pomocí funkce MaximumVPoli.

Uživateli je také v hlavním programu vypsána vypočtená hodnota aritmetického průměru ze všech hodnot ve vektoru. Pro výpočet je volána funkce PrumerPole. 

Jednou z posledních operací prováděných s vektorem je jeho vzestupné setřídění prvků pomocí podprogramu SeraditPole. Tato procedura využívá princip algoritmu bublinkového řazení - anglicky "Bubble Sort". V závěru programu je seřazený vektor vypsán jak do řádky, tak i do sloupce - viz Obrázek 4.

Obrázek 4: Hlavní program JednorozmernePole pro plnění, zobrazení a aritmetických operací prováděných s jednorozměrným pole

Pojďme si nyní v dalších podkapitolách popsat podprogramy, které budeme v našem algoritmu JednorozmernePole využívat.  

2.1. Dolní a horní mez prvků

Dalšími dvěma volanými podprogramy jsou funkce DolniMez a HorniMez. Pomocí těchto funkcí může uživatel nastavit dolní a horní mez prvků vektoru, tj. minimální a maximální hodnotu, které mohou prvky vektoru nabývat - viz Obrázek 1.

Obrázek 1: Naplněné jednorozměrné pole - dolní a horní mez prvků vektoru

Funkce DolniMez a HorniMez využívají dva formální parametry:

• minHodnota - představuje hodnotu stávající dolní meze prvků vektoru
• maxHodnota - představuje hodnotu stávající horní meze prvků vektoru
  

Obrázek 2: Podprogram DolniMez - funkce pro specifikaci dolní meze intervalu hodnot

Ve funkci HorniMez použijeme obdobný postup, který jsme použili při definování dolní meze s tím rozdílem, že budeme specifikovat horní mez intervalu hodnot, kterých mohou nabývat prvky vektoru - viz Obrázek 3. 

Obrázek 3: Podprogram HorniMez - funkce pro specifikaci horní meze intervalu hodnot

2.2. Rozměr pole

Prvním podprogramem je RozmerPole - viz Obrázek 1. Tato funkce navrací rozměr pole, na jehož základě je následně generován vektor. Funkce přijímá stávající počet prvků, který je uložen do formálního parametru n. Dalším formálním parametrem je konstanta Max. Ve Flowgorithm nelze deklarovat konstantu, proto jsme pojmenovali konstantu velkým písmenem, abychom ji rozeznali od jiné proměnné, nebo parametru. Ve funkci jsou deklarovány následující proměnné:

• zmena - celočíselná hodnota představující informaci, zda má být provedena změna rozměru pole na základě uživatelem definované hodnoty
• novaHodnota - uživatelem zadaná hodnota představující nový rozměr vektoru

Po vypsání stávajícího počtu prvků vektoru je pomocí cyklu s podmínkou na konci realizováno čtení celého čísla představujícího informaci, zda chce uživatel provést změnu stávající hodnoty velikosti vektoru. Hodnota 0 uložená do proměnné zmena představuje volbu uživatele, že nechce změnit stávající počet prvků vektoru. Pokud chce uživatel měnit hodnotu velikosti pole zadá v konzoli hodnotu 1. Při zadávání hodnoty se mohlo stát, že uživatel omylem uvedl nevalidní (neplatnou) hodnotu, tj. hodnota je mimo povolený rozsah, nebo neodpovídá požadovanému datovému typu. V tomto případě hodnota uložená v proměnné zmena splní test v řídící podmínce cyklu, tj. jedna z částí řídící podmínky je vyhodnocena jako True a díky operátoru logického součtu || (zatímco platí první část podmínky nebo druhá část řídící podmínky), je celý proces zadávání hodnoty opakován. 

Pokud uživatel zadal hodnotu 1, má být provedena změna počtu prvků na novou hodnotu uloženou do proměnné novaHodnota. Před načtením je ve výpisu uvedena dolní (1) a horní mez (Max) intervalu, ve kterém se nová hodnota musí pohybovat. Pokud načtená hodnota neodpovídá intervalu, je do proměnné novaHodnota uložena maximální přípustná velikost vektoru uložená v konstantě Max. Pokud nová hodnota neodpovídá stávající hodnotě počtu prvků vektoru n, je do proměnné n přiřazena nově načtená hodnota. Tato proměnná n je následně přiřazena návratu funkce - viz Obrázek 1. 

Obrázek 1: Podprogram RozmerPole - funkce pro určení rozměru jednorozměrného pole

2.3. Plnění pole

Podstata podprogramu PlnitPole, ve formě procedury, je plnění vektoru celými čísly v rozsahu intervalu definovaného dolní a horní mezí. Pro tyto účely jsou přijímány následující parametry:

• n - aktuální rozměr vektoru (počet prvků)
• minHodnota - dolní mez prvků vektoru
• maxHodnota-  horní mez prvků vektoru
• pole - vektor, který má být naplněn

• 0 - Náhodně - náhodnými čísly - volání procedury NahodnePole
• 1 - Jednotlivě - jednotlivě zadanými hodnotami uživatelem - volání procedury NulovatPole (naplnění vektoru nulami) a následné volání PlnitJednotlive
• 2 - Nulovat - plnění vektoru nulami - volání procedury NulovatPole 

Po načtení indexu plnění vektoru jsou na základě rozhodovacích bloků v kaskádovém uspořádání volány jednotlivé podprogramy (procedury) s odlišnými způsoby plnění - viz Obrázek 1.

Obrázek 1: Podprogram PlnitPole - procedura pro plnění vektoru na základě zvoleného indexu typu plnění

První procedurou, která je volána když zpusobPlneni == 0, je procedura NahodnePole - viz Obrázek 2. Tato procedura na základě hodnot ve formálních parametrech plní náhodnými čísly jednotlivé prvky vektoru. Přístup k jednotlivým prvkům vektoru je zajištěn pomocí cyklu s krokem, jehož řídící proměnná i je využívána jako index jednotlivých prvků. Náhodné číslo, ukládané do proměnné rnd, je generováno na základě rovnoměrného rozdělení pomocí funkce Random. Tato funkce generuje hodnoty v polouzavřeném intervalu od 0 (včetně) do horní meze (bez této meze), kterou přijímá pouze jako jeden parametr. Proto je zapotřebí v podprogramu definovat další proměnnou, do které uložíme délku intervalu přípustných hodnot (tj. od dolní do horní meze) zvýšenou o 1, abychom u náhodných čísel dosáhli také horní meze. 

Náhodné číslo je generováno následujícím způsobem: minHodnota + Random(delkaIntervalu). Takto vygenerované náhodné celé číslo je přiřazeno do proměnné rnd. Následně je tato hodnota přiřazena do aktuálně procházeného prvku s indexem i. 

Je důležité upozornit, že ve Flowgorithm nelze navrátit pole. Naštěstí je s polem zacházeno jako s referenčním typem, proto pokud je pole formálním parametrem podprogramu, projeví se všechny modifikace prováděné na poli v rámci podprogramu i vně podprogramu po jeho ukončení. Proto podprogramy pro plnění pole byly deklarovány jako procedury.

Další možností plnění vektoru čísly, pokud uživatel zadal hodnotu indexu plnění 1, je plnění jednotlivých prvků na základě hodnot zadaných uživatelem pomocí procedury PlnitJednotlive. Před plněním vektoru uživatelem specifikovanými hodnotami však nejprve musíme zavolat proceduru NulovatPole, která přiřazuje 0 všem prvkům vektoru. V C# představuje pole referenční typ, tzn., že prvky pole jsou inicializovány počáteční hodnotou v závislosti na příslušném datovém typu všech prvků vektoru (např. u datového typu int je to 0). Ve Flowgorithm však takové pravidlo nastaveno není. Proto jsme před plněním jednotlivých prvků vektoru pomocí procedury zavolali proceduru NulovatPole, abychom pole předvyplnili nulami a dali uživateli možnost změnit jen některé prvky a nemusel plnit všechny prvky vektoru. 

Procedura NulovatPole přijímá pouze dva parametry určující počet prvků vektoru a pole samotné. V této proceduře jsou prvky procházeny pomocí cyklu s krokem, kde každému i-tému prvku je přiřazena hodnota 0, tj. příkaz pole[i] = 0 - viz Obrázek 3.

Obrázek 3: Podprogram NulovatPole - procedura pro plnění vektoru nulami

Procedura PlnitJednotlive přijímá stejné parametry jako předchozí procedura NahodnePole, tj. celkový počet prvků, minimální a maximální přípustná hodnota prvku a vektor, který byl v předchozí proceduře naplněn nulami - viz Obrázek 4. Pro tuto proceduru jsou deklarovány následující proměnné:

• index - index prvku, který má být naplněn
• hodnota - hodnota prvku, který má být naplněn
• plnit - celé číslo, které reprezentuje informaci, zda má být zadán (naplněn) další prvek (0 ... Ano, 1 ... Ne)

Pomocí prvního cyklu s podmínkou na konci je zajištěno zadání validní hodnoty pořadí prvku uloženého v proměnné index. Uživatel je v každé iteraci informován, jaké hodnoty mohou být zadány. Pokud byl zadán index, který nenáleží uzavřenému intervalu <0, n-1>, je pomocí těla cyklu zadávání opakováno do té doby, dokud nebude zadáno validní pořadí. 

Pomocí dalšího cyklu s podmínkou na konci je realizováno zadání validní hodnoty ukládané do prvku. Tato hodnota je uložena do proměnné hodnota. Ve výzvě k zadání hodnoty prvku je uvedena jak dolní, tak i horní mez, abychom redukovali chybovost uživatele při zadávání. Pokud by i přesto došlo k zadání nevalidní hodnoty prvku (hodnota je mimo uzavřený interval <minHodnota, maxHodnota> ), je vypsána informace o provedené chybě a celý cyklus načítání hodnoty je znovu opakován.  

Po načtení validní hodnoty je tato hodnota uložena do prvku vektoru se zadaným indexem, tj. pole[index] = hodnota. Po každém uložení hodnoty je uživateli vypsána informace o tom, jak vypadá modifikované pole (výpis prvků vektoru je prováděn jak do řádky, tak do sloupce). 

Další cyklus s podmínkou na konci je určen pro získání informace, zda uživatel chce plnit další prvky vektoru (celočíselná hodnota 1), nebo zda již chce s plněním skončit (hodnota 0). Tato hodnota je načtena do proměnné plnit. Pokud uživatel zadal nevalidní hodnotu, je o této chybě informován ve výpisu a celý proces zadávání této hodnoty je opakován. 

Všechny předchozí vyjmenované cykly jsou začleněny do cyklu s podmínkou na konci, v jehož řídící podmínce je testováno, zda má proběhnout další načtení prvku (pokud je hodnota v proměnné plnit rovna hodnotě 1), tj. opětovné zadání pořadí prvku a hodnoty v něm uložené. 

Obrázek 4: Podprogram PlnitJednotlive - procedura pro plnění uživatelem zadanými hodnotami

2.4. Výpis pole

V předchozí proceduře PlnitJednotlive jsme volali funkce s textovými návraty obsahující vypsané hodnoty jednotlivých prvků vektoru. Pojďme si tyto funkce popsat. První funkci s názvem PoleJakoText využíváme pro výpis prvků do řádku, kde jednotlivé prvky jsou od sebe odděleny čárkami (kvůli lepší čitelnosti). Funkce přijímá dva parametry, kde první parametr představuje velikost pole a druhý představuje pole, které chceme vypsat. Funkce využívá následující lokální proměnné:

• i - index prvku ve vektoru
• vystup - výstupní textový řetězec obsahující prvky vektoru oddělené čárkou

Po nezbytné deklaraci proměnných a inicializaci výstupního textového řetězce vystup pomocí počátečního prvku vektoru (index 0) pomocí konverzní funkce ToString, je v následujícím cyklu s krokem (probíhá v pořadí od druhého prvku a do konečného prvku) do výstupního textového řetězce, před každý vypsaný prvek, přidána čárka kvůli vizuálnímu oddělení jednotlivých hodnot (proto jsme první prvek vypsali samostatně a ne v cyklu). Po průchodu všemi prvky tento výstupní textový řetězec přiřadíme návratu funkce PoleJakoText - viz Obrázek 1.  

Obrázek 1: Podprogram PoleJakoText - funkce pro navrácení textového řetězce obsahujícího hodnoty všech prvků vypsaných do řádku a oddělených čárkami

Dalším podprogramem pro výpis prvků vektoru je funkce ZobrazitPole - viz Obrázek 2. Tato funkce navrací textový řetězec, kde jednotlivé prvky jsou uspořádány do sloupce, tzn. každý prvek je umístěn na samostatné řádce. Funkce přijímá dva parametry - první parametr představuje počet prvků vypisovaného vektoru, druhý parametr představuje pole, které má být vypsáno. Na rozdíl od předchozí funkce pro výpis jsou jednotlivé prvky procházeny od počátečního do koncového prvku (nepotřebujeme za prvky umísťovat čárky). Po výpisu hodnoty aktuálního prvku jsme v textovém řetězci za účelem vizuálního oddělení jednotlivých prvků použili vložení nového řádku pomocí vložení znaku z ASCII tabulky (řídící znak na pozici 13 v ASCII tabulce byl vložen pomocí funkce ToChar, která přijímá pozici znaku a navrací znak na určené pozici. Jedná se posunutí kurzoru na začátek řádku - anglicky "Carriage Return"). Výstupní text obsahující jednotlivé prvky umístěné pod sebou, je přiřazen návratu funkce ZobrazitPole.

Obrázek 2: Podprogram ZobrazitPole - funkce pro navrácení textového řetězce obsahujícího hodnoty všech prvků vypsaných pod sebou do sloupce

2.5. Minimum a maximum pole

Velmi často potřebujeme ze zaznamenaných hodnot v jednorozměrném poli nalézt nejmenší, nebo největší hodnotu, tj. minimum, nebo maximum. Mějme např. vektor s názvem pole a v něm chceme nalézt minimum a maximum - viz Obrázek 1. 

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

Abychom nalezli minimum, je zapotřebí nejprve přiřadit minimu počáteční hodnotu. V našem algoritmu minimu přiřadíme hodnotu prvního prvku. Dále tuto hodnotu porovnáváme s každým dalším prvkem vektoru až porovnáme minimum s posledním prvkem vektoru. Toto porovnání tedy proběhne n-1-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 jednorozměrného pole

Zkusme si popsat podprogram MinimumVPoli ve formě funkce, která navrací minimum vektoru - viz Obrázek 3. Tato funkce přijímá dva parametry - první definuje velikost vektoru a do druhého parametru je uložen vektor, ve kterém hledáme nejmenší hodnotu. Ve funkci deklarujeme následující lokální proměnné:

•  minimum - nalezená minimální hodnota ve vektoru
• i - index (pozice) prvku vektoru

Jako první krok je zapotřebí přiřadit proměnné minimum hodnotu počátečního prvku. Následně pro procházení dalších prvků využijeme cyklu s krokem, který bude procházet jednotlivé prvky v pořadí od druhého do posledního prvku. Uvnitř 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. Návratu funkce je přiřazeno nalezené minimum ze všech prvků.

Obrázek 3: Podprogram MinimumVPoli - funkce pro navrácení minima jednorozměrného pole

Obdobným postupem bychom procházeli jednotlivé prvky vektoru, pokud bychom hledali maximum. Zásadní rozdíl je v tom, že bychom porovnávali, zda je aktuálně procházený prvek větší, než dosud nalezené maximum. Pokud ano, přiřadíme tuto hodnotu do maxima - viz Obrázek 4.

Obrázek 4: Podprogram MaximumVPoli - funkce pro navrácení maxima jednorozměrného pole

Dalším možným přístupem při hledání minima je před prohledáváním vektoru si uložit maximální možnou hodnotu do minima (tím je zajištěno, že při procházení jednotlivých prvků, bude jejich hodnota menší, nebo rovna hodnotě uložené v minimu). Pokud bude hodnota aktuálního prvku menší než dosud nalezené minimum, přiřadíme minimu hodnotu aktuálního prvku. Toto porovnání proběhne n-krát (porovnání všech prvků vektoru s minimem).

Obrázek 5: Hledání minima jednorozměrného pole - jiný postup

Vzhledem k tomu, že ještě potřebujeme nalézt index hledaného minima, či maxima ve vektoru, je zapotřebí definovat funkci, které předáme prvek, který má být ve vektoru vyhledán spolu s vektorem. Tato funkce, kterou pojmenujeme IndexPrvku, nám navrátí index hledaného prvku - viz Obrázek 6. Funkce bude volána v hlavním programu ve výpisu s nalezenou hodnotou minima a maxima vektoru.

Obrázek 6: Podprogram IndexPrvku - funkce pro navrácení indexu hledaného prvku v poli

2.6. Průměr pole

Další aritmetickou operací prováděnou nad prvky jednorozměrného pole, je výpočet aritmetického průměru ze všech prvků pole. Na následujícím obrázku vidíme, že se jedná o součet hodnot všech prvků pole podělený jeho velikostí, tj. celkovým počtem prvků v poli - viz Obrázek 1.

Obrázek 1: Průměr prvků jednorozměrného pole

Pro výpočet průměru prvků vektoru v našem algoritmu použijeme volání podprogramu PrumerPole - viz Obrázek 2. Tato funkce navrací hodnotu vypočteného průměru. Funkce pro výpočet potřebuje dva parametry ve formě velikosti pole a druhý parametr je vektor obsahující jednotlivé prvky. Ve funkci jsou deklarovány následující lokální proměnné:

• prumer - průměrná reálná hodnota ze všech prvků vektoru
• suma - suma hodnot všech prvků vektoru
• i - index (pozice) prvku vektoru

Prvním příkazem provedeným ve funkci je inicializace proměnné suma na hodnotu 0. Pro procházení jednotlivých prvků vektoru je určen cyklus s krokem. V těle cyklu je prováděno přičtení jednotlivých prvků k hodnotě z předchozí iterace uložené v proměnné suma. Po opuštění cyklu jsou všechny prvky sečteny a stačí jen v ypočítat podíl této sumy a velikosti vektoru (počet prvků). Hodnota podílu je uložena do proměnné prumer, která je následně přiřazena jako návrat funkce PrumerPole ve formě reálného čísla.

Obrázek 2: Podprogram PrumerPole - funkce pro výpočet aritmetického průměru prvků pole  

2.7. Seřazení prvků pole

Algoritmů řazení prvků vektoru existuje celá řada (cca přes 10 + modifikace). Nejjednodušší známý algoritmus je bublinkové řazení (anglicky "Bubble Sort"). Algoritmus funguje na principu průchodů. V každém průchodu je prozkoumán celý vektor od začátku do konce. Vždy jsou porovnávány dva prvky. U vzestupného řazení prvků vektoru je testována podmínka, když je první z prvků větší než druhý, dojde k prohození prvků. Po každém průchodu se dostaneme do určité fáze seřazení. Vektor je seřazen, když v posledním průchodu nedošlo k žádnému prohození - viz Obrázek 1. 

Obrázek 1: Bublinkové řazení prvků jednorozměrného pole

Před popisem vývojového diagramu algoritmu bublinkového řazení je třeba ukázat, jak prohodit dva prvky. Prohození dvou prvků nemůže být prováděno přímo. Ukažme si příklad, kdy potřebujeme prohodit v pořadí druhý prvek (index 1) se třetím prvkem vektoru (index 2) - viz Obrázek 2. 

Obrázek 2: Prohození dvou prvků vektoru

Pokud bychom přímo napsali příkaz pole[1] = pole[2], znamená to, že bychom do prvku s indexem 1 (v pořadí druhého prvku) přiřadili obsah prvku s indexem 2 (v pořadí třetího prvku). Tím by se obsah prvku s indexem 1 úplně ztratil, tj. hodnota 4  se přepíše na hodnotu 3 a budeme mít dvě hodnoty 3. Je zapotřebí deklarovat si pomocnou proměnnou, kam jedno z čísel "schováme", vybereme např. prvek s indexem 1 a přiřadíme ho do pomocné proměnné - viz Obrázek 3.

Obrázek 3: Prohození dvou prvků - pomocná proměnná - kopírování hodnoty do pomocné proměnné

Pak již můžeme číslo 4 v prvku s indexem 1 "zapomenout". Proto do prvku s indexem 1 uložíme hodnotu 3 z prvku s indexem 2 - viz Obrázek 4.

Obrázek 4: Prohození dvou prvků - kopírování hodnoty mezi prvky 

Do prvku s indexem 2 již můžeme uložit číslo 4, které je nyní uloženo v pomocné proměnné - viz Obrázek 5. Tím došlo k úspěšnému prohození obou prvků.

Obrázek 5: Prohození dvou prvků - kopírování hodnoty z pomocné proměnné do prvku 

Podívejme se nyní na vývojový diagram procedury SeraditPole - viz Obrázek 6. Procedura přijímá dva parametry - v prvním parametru je uložena velikost vektoru, druhý obsahuje samotný vektor, který má být setříděn vzestupně. Procedura obsahuje následující lokální proměnné:

• pom - pomocná proměnná pro dočasné uložení prvku
• i - index (pozice) prvku vektoru
• b - logická proměnná obsahující informaci, zda došlo k prohození některých sousedních prvků (tj. zda je již vektor seřazen - pokud b == false)

Uvnitř procedury jsou umístěny dva cykly. Vnější cyklus s podmínkou na konci se stará o kontrolu, zda je již vektor kompletně seřazen. Před proběhnutím vnitřního vnořeného cyklus s krokem, pomocí kterého procházíme jednotlivé prvky a porovnáváme vždy dva prvky z řady, je zapotřebí provést nastavení proměnné b na hodnotu false, tj. b = false. Tím je řečeno, že ještě před proběhnutím porovnání dvojic prvků neproběhlo žádné prohození dvou sousedních prvků.

Uvnitř těla cyklu s krokem je potřeba vždy porovnávat dva prvky. U řídící proměnné cyklu je tedy potřeba se zastavit (jako horní mez intervalu hodnot indexu i) na předposledním prvku, kdy porovnáme předposlední a poslední prvek (pokud bychom nechali řídící proměnnou cyklu nastavit na velikost vektoru, porovnávali bychom uvnitř těla cyklu poslední prvek s dalším prvkem, který však neexistuje). Pokud je při vzestupném řazení aktuálně procházený prvek větší než následující prvek (s indexem o 1 větší), je zapotřebí tyto prvky prohodit na základě principu, který jsme již probírali v předchozím textu. V opačném případě není zapotřebí prvky prohazovat. Pokud došlo alespoň k jednomu vzájemnému prohození prvků, je do proměnné b přiřazena hodnota true a díky tomu bude ve vnějším cyklu provedena další iterace. V případě, že úvodní předpoklad (b == true) stále platí i na konci průchodu prvky, dojde k ukončení algoritmu.

Obrázek 6: Podprogram SeraditPole - procedura pro seřazení prvků pole vzestupně podle jejich hodnoty

3. C#

V hlavní metodě programu JednorozmernePole jsou nejprve deklarovány potřebné proměnné pro určení vlastností jednorozměrného pole - vektoru:

• pocetPrvku - rozměr vektoru (počet prvků ve vektoru)
• Max - konstanta maximální velikosti vektoru
• minHodnota - přípustná minimální hodnota (dolní mez) prvků vektoru
• maxHodnota - přípustná maximální hodnota (horní mez) prvků vektoru

Po inicializaci všech proměnných je volána metoda RozmerPole s celočíselným návratem, aby uživatel mohl změnit velikost vektoru, tj. počet prvků, které chce do vektoru umístit. Tato metoda přijímá dva parametry - počet prvků vektoru a maximální přípustnou velikost vektoru. 

Jelikož jsou potřebné atributy pole již naplněny, lze deklarovat vlastní celočíselný vektor. U deklarace je zapotřebí nejprve specifikovat datový typ všech prvků umísťovaných do vektoru. Za hranatými závorkami, které definují, že se jedná o pole, je definován název jednorozměrného pole. Vzhledem k tomu, že proměnná představuje objekt (instance třídy), je zapotřebí zavolat konstruktor (použití klíčového slova new), uvést datový typ pole (prvků pole) a ve hranaté závorce definovat velikost vytvářeného vektoru. 

Uživateli umožníme změnu dolní meze, které mohou nabývat prvky vektoru, pomocí volání metody s celočíselný návratem DolniMez. Dolní mez je uložena do proměnné minHodnota. Dále lze nastavit i horní mez prvků vektoru, pomocí metody HorniMez, jejíž návrat je uložen do proměnné maxHodnota.

Pro naplnění prvků vektoru je použita metoda bez návratu PlnitPole. Prvky mohou být plněny třemi způsoby - náhodně, jednotlivě, nebo vektor bude obsahovat pouze nuly. Pro všechny typy plnění je zapotřebí definovat počet prvků, které mají být naplněny. První dva typy plnění ještě potřebují informace o dolní a horní mezi, aby byly prvky ve vektoru validní. Pole je předáno do metod hodnotou. Je však důležité upozornit, že pole je referenční typ, tzn. že jakákoliv změna provedená na vektoru se odrazí i vně volané metody (bez nutnosti použití předání pole do metody jako parametru předaného odkazem, tj. pomocí klíčového slova ref). 

Po naplnění vektoru je uživateli vypsán vektor ve formě prvků umístěných v řádku (pomocí volání metody PoleJakoText) a zároveň prvků umístěných jednotlivě pod sebou (pomocí volání metody ZobrazitPole). Po výpisu prvků naplněného pole je pomocí metody MinimumVPoli, navrácena a vypsána hodnota minima vektoru včetně indexu prvku, kde minimum bylo nalezeno. Pro celočíselný návrat pořadí hledaného prvku ve vektoru je využita metoda IndexPrvku. Metoda přijímá dva parametry - první parametr představuje hledaný prvek (tento prvek je navrácená hodnota minima pomocí metody MinimumVPoli) a další parametr představuje pole, ve kterém bude prvek hledán. Stejný přístup je uplatněn i při hledání maxima vektoru. 

Výpočet aritmetického průměru z prvků vektoru je realizován pomocí metody s reálným návratem PrumerPole. Toto desetinné číslo reprezentující průměr, je uživateli vypsáno v následující řádce pod výpisem maxima.

Poslední operací prováděnou s vektorem je jeho vzestupné řazení podle hodnot v prvcích. Pro řazení vektoru je volána metoda bez návratu s názvem SeraditPole. Po seřazení prvků vektoru je seřazený vektor vypsán jak do řádku, tak i do sloupce - viz Kód 1.

static void Main(string[] args)
{
    /* Deklarace: 'pocetPrvku' ... rozměr vektoru (počet prvků ve vektoru); 'Max' ... konstantní hodnota 
     * maximální velikosti vektoru; 'minHodnota' ... přípustná minimální hodnota (dolní mez) prvků vektoru; 
     * 'maxHodnota' ... přípustná maximální hodnota (horní mez) prvků vektoru */
 
    // Maximální rozměr vektoru
    const int Max = 10;
 
    // Dolní mez, které může nabýt prvek vektoru
    int minHodnota = 1;
 
    // Horní mez, které může nabýt prvek vektoru
    int maxHodnota = 100;
 
    // Rozměr vektoru je roven maximální možné délce
    int pocetPrvku = Max;
 
    // Zavolání metody s celočíselným návratem pro změnu velikosti vektoru
    pocetPrvku = RozmerPole(pocetPrvku, Max);
 
    // Deklarace vektoru se zadaným rozměrem (počtem prvků)
    int[] pole = new int[pocetPrvku];
 
    // Zavolání metody s celočíselný návratem pro změnu dolní meze, které mohou nabývat prvky vektoru
    minHodnota = DolniMez(minHodnota, maxHodnota);
 
    // Zavolání metody s celočíselným návratem pro změnu horní meze, které mohou nabývat prvky vektoru
    maxHodnota = HorniMez(minHodnota, maxHodnota);
 
    /* Zavolání metody pro plnění vektoru (náhodnými čísly, jednotlivě zadanými hodnotami, 
     * plnění vektoru nulami) */
    PlnitPole(pocetPrvku, minHodnota, maxHodnota, pole);
 
    // Výpis prvků vektoru v řádku, kde jednotlivé prvky jsou odděleny čárkami
    Console.WriteLine("Výpis pole (do řádku): " + PoleJakoText(pocetPrvku, pole));
 
    // Výpis prvků vektoru do sloupce, kde každý prvek je na nové řádce
    Console.WriteLine("Výpis pole (do sloupce): ");
    Console.Write(ZobrazitPole(pocetPrvku, pole));
 
    // Výpis hodnoty minima vektoru, včetně jeho indexu
    Console.WriteLine("Minimum v poli: " + MinimumVPoli(pocetPrvku, pole) + " (index prvku: " + IndexPrvku(MinimumVPoli(pocetPrvku, pole), pole) + ")");
 
    // Výpis hodnoty maxima vektoru, včetně jeho indexu
    Console.WriteLine("Maximum v poli: " + MaximumVPoli(pocetPrvku, pole) + " (index prvku: " + IndexPrvku(MaximumVPoli(pocetPrvku, pole), pole) + ")");
 
    // Výpis průměru všech prvků vektoru
    Console.WriteLine("Průměr prvků pole: " + PrumerPole(pocetPrvku, pole));
 
    // Vzestupné řazení prvků podle metody Bubble Sort
    SeraditPole(pocetPrvku, pole);
 
    // Výpis seřazeného vektoru do řádku
    Console.WriteLine("Seřazené pole (výpis do řádku): " + PoleJakoText(pocetPrvku, pole));
 
    // Výpis seřazeného vektoru do sloupce
    Console.WriteLine("Seřazené pole (výpis do sloupce): ");
    Console.Write(ZobrazitPole(pocetPrvku, pole));
 
    // Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

 Kód 1: Program JednorozmernePole - deklarace hlavní statické metody Main 

V následujících podkapitolách budou popsány jednotlivé volané metody.

3.1. Rozměr pole

První statickou volanou metodou v hlavním programu je metoda RozmerPole. Vzhledem k tomu, že zdrojový kód programu obsahuje větší množství jednotlivých metod, je vhodné metody rozdělit do jednotlivých sekcí - regionů. Tyto sekce lze sbalit kliknutím na tlačítko − umístěné napravo od čísel řádek zdrojového kódu (tím se schovají jednotlivé metody umístěné v této sekci). Sekci lze zpětně rozbalit kliknutím na tlačítko +. Počáteční značka regionu je psána s mřížkou, tj.  #region. Za ní uvedeme název regionu - viz Kód 1.

#region Nastavení atributů pole

Kód 1: Počáteční značku regionu

Koncová značku bloku regionu je #endregion - viz Kód 2.

#endregion

Kód 2: Koncová značku regionu

Dále je vhodné umístit nad jednotlivé deklarace metod značky pro dokumentaci :

• Metody
• Formálních parametrů metody 
• Návratu metody 

Tyto popisky se budou zobrazovat v malém okně při volání metody a programátorovi pomohou rychle se orientovat v podstatě volané metody. Pro umístění značky do zdrojového kódu stačí vepsat nad metodu tři lomítka za sebou a Visual Studio nám automaticky doplní značky k dokumentaci ve formě XML prvků přidaných ke zdrojovému kódu. První vygenerovanou značkou je dokumentace k metodě, kde mezi počáteční značkou /// <summary> a konečnou značkou </summary> uvedeme za trojité lomítko poznámku o podstatě metody. Pokud je popis víceřádkový, stačí mezi počáteční a koncovou značku umístit kurzor a stisknout klávesu Enter. Visual Studio do značky přidá další řádku s trojitým lomítkem, kam lze umístit další popis.

/// <summary>
/// Metoda s celočíselným návratem - navrací velikost pole (počet prvků vektoru)
/// </summary>

Kód 1: Dokumentace k metodě

Další poznámkou uváděnou v kódu ve formě XML značky ve zdrojovém kódu je popisek podstaty formálního parametru metody - viz Kód 2. Tento popisek je v našem případu uváděn mezi značkou parametru s názvem n, tj. /// <param name="n"> a konečnou značkou </param>. 

/// <param name="n"> aktuální velikost vektoru (počet prvků) </param>

Kód 2: Dokumentace k parametru

Poslední značkou uvedenou nad deklarací metody RozmerPole je značka popisku výstupu (návratu) metody (neplatí pro metody bez návratu). Popisek výstupu metody je umístěn mezi značky /// <returns> a </returns> - viz Kód 3. 

/// <returns> Velikost vektoru </returns>

Kód 2: Dokumentace k výstupu metody

Podstata algoritmu byla nastíněna v kapitole Analýza a návrh řešení, není proto nutné detailně popisovat podstatu zdrojového kódu. 

Metoda RozmerPole obsahuje dva formální celočíselné parametry:

• n - aktuální velikost vektoru (počet prvků) 
• max - maximální rozměr vektoru

Metoda navrací velikost vektoru, podle níž bude generován objekt - vektor. Pro metodu jsou deklarovány následující celočíselné lokální proměnné:

• zmena - informace (celé číslo), zda má být provedena změna rozměru pole
• novaHodnota - nový rozměr vektoru

Uživateli je nejprve vypsána stávající velikost vektoru (počet jeho prvků, které může po naplnění obsahovat). První cyklus s podmínkou na konci je určen pro načtení celočíselné informace (0...Ne, 1...Ano), zda chce uživatel změnit stávající rozměr (ten byl nastaven v hlavním programu na maximální možný. Hodnota této konstanty z hlavního programu je v metodě uložena ve formálním parametru max). Načtení hodnoty je provedeno pomocí metody TryParse s výstupním parametrem zmena. V řídící podmínce cyklu je testováno, zda byla zadána validní hodnota této proměnné. Pokud ne, celé tělo cyklu je opakováno.

Další cyklus s podmínkou na konci je určen pro načtení nové hodnoty velikosti vektoru. Pokud nová hodnota není validní, je jí přiřazena maximální přípustná velikost vektoru uložena v parametru max. Pokud nová hodnota byla validní a není stejná jako stávající velikost vektoru, je tato hodnota uložena do formálního parametru n, který je následně přiřazen výstupu funkce RozmerPole - viz Kód 3. 

/// <summary>
/// Metoda s celočíselným návratem - navrací velikost pole (počet prvků vektoru)
/// </summary>
/// <param name="n"> aktuální velikost vektoru (počet prvků) </param>
/// <param name="max"> maximální rozměr vektoru </param>
/// <returns> Velikost vektoru </returns>
static int RozmerPole(int n, int max)
{
    /* Deklarace: 'zmena' ... informace (celé číslo), zda má být provedena změna rozměru 
     * pole; 'novaHodnota' ... nový rozměr vektoru */
    int zmena, novaHodnota;
 
    // Vypsání stávajícího rozměru vektoru
    Console.WriteLine("Počet prvků: {0}", n);
    do
    {
        // Výzva ke změně rozměru vektoru
        Console.Write("Změnit počet prvků vektoru (0...Ne, 1...Ano): ");
 
        // Načtení hodnoty, zda má dojít ke změně
        int.TryParse(Console.ReadLine(), out zmena);
 
        // Pokud načtená hodnota nebyla validní, cyklus zadání je znovu opakován
    }
    while ((zmena < 0) || (zmena > 1));
 
    // Pokud byl zadán index pro změnu ...
    if (zmena == 1)
    {
        // Výzva k zadání rozměru vektoru
        Console.Write("Zadejte počet prvků vektoru (1 - {0}): ", max);
 
        // Načtení rozměru vektoru
        int.TryParse(Console.ReadLine(), out novaHodnota);
 
        // Pokud nová hodnota je větší než maximum, nebo menší než 1 ...
        if ((novaHodnota > max) || (novaHodnota < 1))
        {
            // Přiřazení maximálního rozměru vektoru do lokální proměnné určující počet prvků vektoru
            novaHodnota = max;
        }
 
        // Pokud nový rozměr vektoru není stejný jako stávající počet prvků vektoru ...
        if (novaHodnota != n)
        {
            // Uložení nového rozměru pole do proměnné
            n = novaHodnota;
        }
 
        // Výpis nového zadaného rozměru vektoru
        Console.WriteLine("Rozměr pole: {0}", n);
    }
 
    // Návrat metody
    return n;
}

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

3.2. Dolní a horní mez prvků

Následující zdrojový kód obsahuje deklaraci metody s celočíselným návratem DolniMez - viz Kód 1. Tato metoda umožňuje uživateli nastavit dolní mez pro hodnoty prvků celočíselného vektoru. Uživatel může změnu odmítnout a stávající dolní mez nastavená v hlavní statické metodě Main tak zůstane platná. Detailní popis podstaty metody byl proveden již v rámci analýzy ve stejnojmenné podkapitole a proto jej není nutné znovu uvádět.

/// <summary>
/// Metoda s celočíselným návratem - návrat dolní meze pro všechny prvky vektoru
/// </summary>
/// <param name="minHodnota"> dolní mez prvků vektoru </param>
/// <param name="maxHodnota"> horní mez prvků vektoru </param>
/// <returns> Dolní mez pro všechny prvky vektoru </returns>
public static int DolniMez(int minHodnota, int maxHodnota)
{
    /* Deklarace: 'novaHodnota' ... nová dolní mez prvků vektoru; 'zmena' ... celočíselná 
     * informace, zda má být provedena změna dolní meze prvků ('0'...Ne, '1'...Ano) */
    int novaHodnota, zmena;
 
    // Výpis stávající hodnoty dolní meze
    Console.WriteLine("Dolní mez prvků vektoru: {0}", minHodnota);
    do
    {
        // Výzva ke změně dolní meze
        Console.Write("Změnit dolní mez prvků vektoru (0...Ne, 1...Ano): ");
 
        // Načtení hodnoty do proměnné 'zmena' (informace, zda má dojít ke změně)
        int.TryParse(Console.ReadLine(), out zmena);
 
        // Pokud načtená hodnota není validní, cyklus zadání probíhá znovu
    }
    while (zmena < 0 || zmena > 1);
 
    // Test, zda má proběhnout změna dolní meze prvků vektoru
    if (zmena == 1)
    {
        // Výzva k zadání nové dolní meze prvků vektoru
        Console.Write("Zadejte dolní mez prvků vektoru: ");
 
        // Načtení nové dolní meze prvků vektoru
        int.TryParse(Console.ReadLine(), out novaHodnota);
 
        // Pokud nová hodnota dolní meze je větší než horní mez ...
        if (novaHodnota > maxHodnota)
        {
            // Přiřazení horní meze do lokální proměnné určující dolní mez (horní a dolní mez budou stejné)
            novaHodnota = maxHodnota;
        }
 
        // Pokud nová dolní mez vektoru není stejná jako stávající dolní mez prvků vektoru ...
        if (novaHodnota != minHodnota)
        {
            // Přepsání stávající dolní meze prvků pole novou hodnotou
            minHodnota = novaHodnota;
        }
 
        // Výpis nové dolní meze pro prvky vektoru
        Console.WriteLine("Dolní mez prvků vektoru: {0}", minHodnota);
    }
 
    // Návrat metody
    return minHodnota;
}

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

Další zdrojový kód obsahuje deklaraci metody s celočíselným návratem HorniMez - viz Kód 2. Tato metoda umožňuje uživateli nastavit horní mez pro hodnoty prvků celočíselného vektoru. Princip metody je téměř totožný s předcházející metodou DolniMez.

/// <summary>
/// Metoda s celočíselným návratem - návrat horní meze pro všechny prvky vektoru
/// </summary>
/// <param name="minHodnota"> stávající horní mez prvků vektoru </param>
/// <param name="maxHodnota"> horní mez prvků vektoru </param>
/// <returns> Horní mez pro všechny prvky vektoru </returns>
static int HorniMez(int minHodnota, int maxHodnota)
{
    /* Deklarace: 'novaHodnota' ... nová horní mez prvků vektoru; 'zmena' ... celočíselná 
     * informace, zda má být provedena změna horní meze prvků ('0'...Ne, '1'...Ano) */
    int novaHodnota, zmena;
 
    // Výpis stávající hodnoty horní meze
    Console.WriteLine("Horní mez prvků vektoru: {0}", maxHodnota);
    do
    {
        // Výzva ke změně horní meze
        Console.Write("Změnit horní mez prvků vektoru (0...Ne, 1...Ano): ");
 
        // Načtení hodnoty do proměnné 'zmena' (informace, zda má dojít ke změně)
        int.TryParse(Console.ReadLine(), out zmena);
    }
    // Pokud načtená hodnota není validní, cyklus zadání probíhá znovu
    while ((zmena < 0) || (zmena > 1));
 
    // Test, zda má proběhnout změna horní meze prvků vektoru
    if (zmena == 1)
    {
        // Výzva k zadání nové horní meze prvků vektoru
        Console.Write("Zadejte horní mez prvků vektoru: ");
 
        // Načtení nové horní meze prvků vektoru
        int.TryParse(Console.ReadLine(), out novaHodnota);
 
        // Pokud nová hodnota horní meze je menší než dolní mez ...
        if (novaHodnota < minHodnota)
        {
            // Přiřazení dolní meze do lokální proměnné určující horní mez (horní a dolní mez budou stejné)
            novaHodnota = minHodnota;
        }
 
        // Pokud nová horní mez vektoru není stejná jako stávající horní mez prvků vektoru ...
        if (novaHodnota != maxHodnota)
        {
            // Přepsání stávající horní meze prvků pole novou hodnotou
            maxHodnota = novaHodnota;
        }
 
        // Výpis nové horní meze pro prvky vektoru
        Console.WriteLine("Horní mez prvků vektoru: {0}", maxHodnota);
    }
 
    // Návrat metody
    return maxHodnota;
}

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

3.3. Plnění pole

Následující zdrojový kód obsahuje deklaraci metody bez návratu PlnitPole - viz Kód 1. Tato metoda umožňuje uživateli zvolit typ plnění celočíselného vektoru. Oproti kaskádovému členění rozhodování ve vývojovém diagramu je ve zdrojovém kódu metody použito vícenásobné větvení pomocí příkazu switch. Pokud je hodnota uložená v proměnné zpusobPlneni rovna: 

• 0 - vektor pole je plněn náhodnými čísly pomocí metody bez návratu NahodnePole
• 1 - vektor pole je plněn celočíselnými hodnotami specifikovanými uživatelem. Uživatel zároveň definuje, kterému prvku vektoru patří tato jím zadaná hodnota. Plnění je prováděno pomocí metody bez návratu s názvem PlnitJednotlive. Oproti vývojovém diagramu ve Flowgorithm již není zapotřebí volat metodu NulovatPole, protože v C# pole představuje referenční datový typ, tzn. pokud není nastavena hodnota prvku pole, prvek je inicializován počáteční hodnotou v závislosti na příslušném datovém typu (např. u datového typu int je to 0)
• 2 - vektor pole je plněn nulami pomocí metody bez návratu NulovatPole

/// <summary>
/// Metoda bez návratu - výběr metody plnění vektoru
/// </summary>
/// <param name="n"> aktuální rozměr (počet prvků) vektoru </param>
/// <param name="minHodnota"> dolní mez prvků vektoru </param>
/// <param name="maxHodnota"> horní mez prvků vektoru </param>
/// <param name="pole"> vektor, který má být naplněn </param>
static void PlnitPole(int n, int minHodnota, int maxHodnota, int[] pole)
{
    /* Deklarace: 'zpusobPlneni' ... způsob plnění vektoru('0'...Náhodně, '1'...Jednotlivě, 
     * '2'...Nulovat) */
    int zpusobPlneni;
 
    do
    {
        // Výzva k zadání způsobu plnění vektoru
        Console.Write("Zvolte způsob plnění vektoru (0...Náhodně, 1...Jednotlivě, 2...Nulovat): ");
 
        // Načtení způsobu plnění
        int.TryParse(Console.ReadLine(), out zpusobPlneni);
    }
 
    // Načtení způsobu plnění proběhne znovu, pokud nebyl zadán validní celočíselný kód způsobu plnění
    while ((zpusobPlneni != 0) && (zpusobPlneni != 1) && (zpusobPlneni != 2));
 
    switch (zpusobPlneni) 
    {
        // Plnění vektoru náhodnými čísly
        case 0:
            // Zavolání metody pro plnění vektoru náhodnými čísly
            NahodnePole(n, minHodnota, maxHodnota, pole);
            break;
 
        // Plnění vektoru jednotlivými zadanými hodnotami uživatelem
        case 1:
            // Plnění vektoru jednotlivými uživatelem zadanými čísly
            PlnitJednotlive(n, minHodnota, maxHodnota, pole);
            break;
 
        case 2:
            // Všem prvkům vektoru přiřadíme hodnotu '0'
            NulovatPole(n, pole);
            break;
    }
}

Kód 1: Deklarace statické metody bez návratu s názvem PlnitJednotlive

Detailní popisy podstaty následujících metod byly provedeny již v rámci analýzy ve stejnojmenné podkapitole a proto jej není nutné znovu uvádět. Uvedeme si pouze rozdíly oproti vývojovému diagramu jednotlivých podprogramů.

Následující zdrojový kód obsahuje deklaraci metody bez návratu NahodnePole, která je volána z metody PlnitPole, pokud uživatel zadal do proměnné zpusobPlneni hodnotu 0 - viz Kód 2. V metodě je generováno náhodné číslo na základě rovnoměrného rozdělení, tj. objekt rnd odvozený od třídy Random (instance třídy Random). Abychom mohli vytvořit objekt rnd, je zapotřebí zavolat konstruktor objektu pomocí klíčového slova new. Pro generování náhodného čísla využijeme metodu Next přidruženou k objektu rnd (přístup k metodám je pomocí tečkové notace). Tato metoda je k dispozici ve třech přetížených verzích: 

• Next() -  metoda bez parametru navrací náhodné číslo v celém rozsahu datového typu int

• Next(maxHodnota) - metoda navrací nezáporná čísla menší než hodnota v parametru maxHodnota, např. rnd.Next(100); vrátí číslo od 0 do 99

• Next(minHodnota, maxHodnota) - metoda vrátí náhodné číslo náležící zleva uzavřenému intervalu <minHodnota, maxHodnota) ... dolní mez intervalu patří a horní mez již ne. Pokud potřebujeme pomocí objektu rnd generovat náhodné číslo např. od 1 do 100, uvedeme příkaz rnd.Next(1, 101);

V C# není při generování náhodného čísla zapotřebí definovat délku intervalu delkaIntervalu = maxHodnota - minHodnota + 1, kterou jsme využívali ve vývojových diagramech. Ve zdrojovém kódu jsme využili při generování náhodného čísla volání metody Next se dvěma parametry. Návrat této metody ve formě náhodného celého čísla přiřadíme i-tému aktuálnímu prvku pole, tj. pole[i] = rnd.Next(minHodnota, maxHodnota + 1);

V tomto i v dalších cyklech určených k procházení prvků vektoru je nahrazena podmínka dosažení horní meze u řídící proměnné, kterou jsme používali ve vývojových diagramech ve formě i <= n - 1 za jinak formulovanou, ale principiálně stejnou podmínku i < n (použití v metodách ZobrazitPole, PoleJakoText, MinimumVPoli, atd). Inkrementace řídící proměnné i je prováděna pomocí operátoru ++, tj. i++, namísto zdlouhavého zápisu příkazu i = i +1;

/// <summary>
/// Metoda bez návratu - plnění vektoru náhodnými čísly
/// </summary>
/// <param name="n"> počet prvků vektoru </param>
/// <param name="minHodnota"> dolní mez prvků vektoru </param>
/// <param name="maxHodnota"> horní mez prvků vektoru </param>
/// <param name="pole"> vektor, který má být naplněn </param>
static void NahodnePole(int n, int minHodnota, int maxHodnota, int[] pole)
{
    /* Deklarace: 'rnd' ... náhodné číslo (generované na základě rovnoměrného rozdělení); 
     * 'i' ... index (pozice) prvku vektoru */
 
    // Deklarace náhodného čísla (objektu) včetně inicializace
    Random rnd = new Random();
 
    // Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku
    for (int i = 0; i < n; i++)
    {
        /* Vygenerování náhodného čísla uloženého do 'rnd' v rozsahu 'minHodnota' až 'maxHodnota'
         * Přiřazení náhodného čísla do 'i'-tého prvku */
        pole[i] = rnd.Next(minHodnota, maxHodnota + 1);
    }
}

Kód 2: Deklarace statické metody bez návratu s názvem NahodnePole

Další možností plnění pole, je pomocí uvedení pořadí prvku a specifikace jeho hodnoty. Pro tuto metodu plnění je volána metoda bez návratu PlnitJednotlive. Je důležité upozornit, že uživatel zadává index prvku (index pozice začíná od 0) - viz Kód 3.

/// <summary>
/// Metoda bez návratu - plnění jednotlivých prvků vektoru uživatelem
/// </summary>
/// <param name="n"> počet prvků </param>
/// <param name="minHodnota"> stávající dolní mez prvků vektoru </param>
/// <param name="maxHodnota"> stávající horní mez prvků vektoru </param>
/// <param name="pole"> vektor, který má být naplněn </param>
static void PlnitJednotlive(int n, int minHodnota, int maxHodnota, int[] pole)
{
    /* Deklarace: 'index' ... index prvku, který má být naplněn; 'hodnota' ... hodnota 
     * prvku, který má být naplněn; 'plnit' ... informace, zda má zadán (naplněn) 
     * další prvek ('0'...Ano, '1'...Ne) */
    int index, hodnota, plnit;
 
    // Cyklus s podmínkou na konci pro plnění prvků
    do
    {
        // Cyklus s podmínkou na konci pro načtení indexu plněného prvku 
        do
        {
            // Výzva k zadání indexu prvku, včetně vypsání mezí
            Console.Write("Zadejte pořadové číslo prvku, který chcete naplnit (0 - {0}): ", 
                pole.Length-1);
 
            // Načtení indexu
            int.TryParse(Console.ReadLine(), out index);
 
            // Test, zda načtený index je mimo meze ...
            if ((index < 0) || (index > n-1))
            {
                // Výpis o chybě
                Console.WriteLine("Zadaná hodnota je mimo meze");
            }
        }
        /* Podmínka cyklu, zda načtený index je mimo meze. Pokud ano, opakovaní 
         * načtení indexu */
        while ((index < 0) || (index > n-1));
 
        // Cyklus s podmínkou na konci - validace zadané hodnoty zda je hodnota v rozsahu mezí 
        do
        {
            // Výzva k zadání hodnoty prvku, včetně vypsání dolní a horní meze pro všechny prvky
            Console.Write("Zadejte hodnotu prvku ({0} - {1}): ", minHodnota.ToString(), 
                maxHodnota.ToString());
 
            // Načtení hodnoty
            int.TryParse(Console.ReadLine(), out hodnota);
 
            // Test, zda načtená hodnota prvku je mimo meze ...
            if ((hodnota < minHodnota) || (hodnota > maxHodnota))
            {
                // Výpis o chybě
                Console.WriteLine("Zadaná hodnota je mimo meze");
            }
        }
        /* Podmínka cyklu, zda načtená hodnota prvku je mimo meze. Pokud ano, opakovaní 
         * načtení hodnoty */
        while ((hodnota < minHodnota) || (hodnota > maxHodnota));
 
        // Přiřazení hodnoty z lokální proměnné do prvku vektoru na pozici 'index'
        pole[index] = hodnota;
 
        // Zavolání metody pro zobrazení vektoru jako prvky v řádku oddělené čárkou
        Console.WriteLine(PoleJakoText(n, pole));
 
        // Zavolání metody pro zobrazení vektoru jako prvky pod sebou
        Console.WriteLine(ZobrazitPole(n, pole));
 
        // Cyklus s podmínkou na konci - validace informace o tom, zda dále plnit
        do
        {
            // Výzva, zda mají být plněny další prvky
            Console.Write("Chcete plnit další prvek (0...Ne, 1...Ano): ");
 
            // Načtení informace o dalším plnění
            int.TryParse(Console.ReadLine(), out plnit);
 
            // Test, zda načtená hodnota (informace o plnění) je mimo meze ...
            if ((plnit < 0) || (plnit > 1))
            {
                // Výpis chyby
                Console.WriteLine("Zadaná hodnota je mimo meze");
            }
        }
 
        /* Podmínka cyklu, zda načtená hodnota je mimo meze. Pokud ano, 
         * opakovaní načtení hodnoty */
        while ((plnit < 0) || (plnit > 1));
    }
 
    /* Podmínka cyklu, zda má být provedeno další načtení prvku. Pokud ano (hodnota '1'), 
     * opakovaní načtení hodnoty */
    while (plnit == 1);
}

Kód 3: Deklarace statické metody bez návratu s názvem PlnitJednotlive

Poslední možností, jak plnit pole, je do něj umístit samé nuly. Následující metodě NulovatPole proto pouze postačí jednoduchý cyklus s krokem, kde každému prvku pole je přiřazena hodnota 0 - viz Kód 4. 

/// <summary>
/// Metoda bez návratu - plnění prvků pole hodnotou nula
/// </summary>
/// <param name="n"> počet prvků vektoru </param>
/// <param name="pole"> vektor, který má být naplněn </param>
static void NulovatPole(int n, int[] pole)
{
    /* Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku;
     * 'i' ... index (pozice) prvku vektoru */
    for (int i = 0; i < n; i++)
    {
        // Přiřazení nuly 'i'-tému (aktuálně procházenému) prvku
        pole[i] = 0;
    }
}

Kód 4: Deklarace statické metody bez návratu s názvem NulovatPole

3.4. Výpis pole

Pro výpis naplněného pole jsou v programu použity dvě metody. První metoda PoleJakoText, navrací textový řetězec obsahující jednotlivé prvky oddělené čárkou, kde jednotlivé prvky jsou vypsány do řádky. Abychom zachovali stejný počet číslic vypsaných mezi čárky, použili jsme u výpisu hodnoty prvku namísto jednoduché konverze i-tého prvku, tj. pole[i].ToString(); formátovou specifikaci (anglicky "Format Specifier") třídy (datového typu) string, tj. string.Format(", {0:D3}", pole[i]); , kde:

• 0 ... hodnota 0 definuje pořadí proměnné v seznamu proměnných uvedených za čárkou
• D3 ... formát definuje, že textový řetězec reprezentující číslo (D znamená číselný formát Decimal, tedy desetinné číslo. Lze také uvádět malé písmeno d), má být doplněn vedoucími nulami, tak aby délka textového řetězce byla rovna 3, tj. počet vypsaných číslic 
  

Namísto zdlouhavého příkazu pro připojení textového řetězce do stávajícího řetězce např. vystup = vystup + pole[0].ToString(); jsme použili operátor += včetně formátové specifikace, tzn. vystup += string.Format("{0:D3}", pole[0]); - viz Kód 1.

/// <summary>
/// Výpis prvků vektoru v řádku, kde jednotlivé prvky jsou odděleny čárkami
/// </summary>
/// <param name="n"> aktuální velikost (počet prvků) vektoru </param>
/// <param name="pole"> vektor, který má být vypsán </param>
/// <returns> Text obsahující prvky v řádku </returns>
static string PoleJakoText(int n, int[] pole)
{
    /* Deklarace: 'vystup' ... výstupní textový řetězec obsahující prvky vektoru 
     * oddělené čárkou; 'i' ... index prvku ve vektoru */
    string vystup;
 
    // Inicializace - příprava textu  pro výpis v konzole
    vystup = "";
 
    // Vypsání počátečního prvku do textového řetězce
    vystup += string.Format("{0:D3}", pole[0]);
 
    // Pro všechny prvky od druhého prvku (včetně) do posledního ...
    for (int i = 1; i < n; i++)
    {
        // Výpis prvku do řádku odděleného čárkou
        vystup += string.Format(", {0:D3}", pole[i]);
    }
 
    // Přiřazení textu návratu metody
    return vystup;
}

Kód 1: Deklarace statické metody s textovým návratem s názvem PoleJakoText

Další metodou pro výpis prvků, tentokrát však do sloupce, je metoda s textovým návratem s názvem ZobrazitPole - viz Kód 2. Abychom docílili toho, že každý prvek pole bude umístěn na samostatnou řádku, použili jsme ve vývojovém diagramu vložení řídícího znaku do textového řetězce (anglicky "Carriage Return" - reprezentoval řídící znak na pozici 13 v ASCII tabulce). Tento znak navrací kurzor na začátek řádky a díky tomu bylo další číslo vypsáno na novém řádku. V C# je zapotřebí vložit ještě další znak reprezentující přechod na nový řádek (anglicky "Line Feed" - tento řídící znak je umístěn na pozici 10 v ASCII tabulce). Díky vložení těchto dvou řídících znaků do textu je zajištěno vypsání prvku na nové řádce.

/// <summary>
/// Výpis prvků vektoru do sloupce, kde každý prvek je na nové řádce
/// </summary>
/// <param name="n"> počet prvků vektoru </param>
/// <param name="pole"> vypisovaný vektor </param>
/// <returns> Text obsahující prvky ve sloupci </returns>
static string ZobrazitPole(int n, int[] pole)
{
    /* Deklarace: 'vystup' ... textový řetězec, kde jednotlivé prvky vektoru jsou 
     * umístěny pod sebou; 'i' ... index prvku ve vektoru */
    string vystup;
 
    // Inicializace - příprava textu  pro výpis v konzole
    vystup = "";
 
    // Pro všechny prvky od počátečního do koncového prvku ...
    for (int i = 0; i < n; i++)
    {
        /* Výpis prvku na novém řádku (návrat na počátek řádku ... znak na pozici '13' 
         * nový řádek ... znak na pozici '10' v ASCII tabulce); 
         * 0:D3 ... formátová specifikace, tj. 3 znaky (doplněno vedoucími nulami),
         * nula znamená index proměnné uvedené za čárkou */
        vystup += string.Format("{0:D3}", pole[i]) + (char)13 + (char)10;
    }
 
    // Přiřazení výstupního textu návratu metody
    return vystup;
}

Kód 2: Deklarace statické metody s textovým návratem s názvem ZobrazitPole

Existují ještě další možnosti vložení nového řádku, např. pomocí řídící posloupnosti, kde: 

• \r ... řídící posloupnost pro návrat na počátek řádku
• \n ... řídící posloupnost pro přechod na nový řádek

V podstatě jde o stejný přístup jako v metodě ZobrazitPole, ale je využito jiného zápisu - viz Kód 3.

// Vložení nové řádky do výsledného textu pomocí řídící posloupnosti
vystup += string.Format("{0:D3}", pole[i]) + "\r\n";

Kód 3: Použití řídící posloupnosti pro vloženého nového řádku

Dalším možným způsobem vložení řádky je využití metody NewLine implementované ve třídě Environment - viz Kód 4.

// Vložení nové řádky do výsledného textu
vystup += string.Format("{0:D3}", pole[i]) + Environment.NewLine;

Kód 4: Použití metody NewLine třídy Environment pro vloženého nového řádku

3.5. Minimum a maximum pole

Pro vyhledání nejmenšího prvku v poli je použita metoda MinimumVPoli s celočíselným návratem nalezeného minima. Počátečním krokem metody je prohlášení prvního prvku minimem. Dále jsou procházeny další prvky, které jsou porovnány 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. Po ukončení průchodu všemi prvky vektoru je hodnota minima přiřazena výstupu metody - viz Kód 1.

/// <summary>
/// Návrat hodnoty minima vektoru - nejmenší prvek
/// </summary>
/// <param name="n"> počet prvků vektoru </param>
/// <param name="pole"> prohledávaný vektor </param>
/// <returns> Minimum vektoru </returns>
static int MinimumVPoli(int n, int[] pole)
{
    // Deklarace: 'minimum' ... nalezená minimální hodnota ve vektoru; 'i' ... index (pozice) prvku vektoru
    int minimum;
 
    // Hodnotu prvního prvku prohlásíme minimem
    minimum = pole[0];
 
    // Pro všechny prvky od '1' (druhého prvku) do 'n-1'-tého (posledního) prvku
    for (int i = 1; i < n; i++)
    {
        // Pokud je aktuálně procházený prvek menší než minimum ...
        if (pole[i] < minimum)
        {
            // Uložené aktuálního prvku do minima
            minimum = pole[i];
        }
    }
 
    // 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 ve vektoru uloženou do proměnné s názvem maximum - viz Kód 2.

/// <summary>
/// Návrat hodnoty maxima vektoru - největší prvek
/// </summary>
/// <param name="n"> počet prvků pole </param>
/// <param name="pole"> prohledávaný vektor </param>
/// <returns> Maximum vektoru </returns>
public static int MaximumVPoli(int n, int[] pole)
{
    // Deklarace: 'maximum' ... nalezená maximální hodnota ve vektoru; 'i' ... index (pozice) prvku vektoru
    int maximum;
 
    // První prvek prohlásíme maximem
    maximum = pole[0];
 
    // Pro všechny prvky od '1' (druhého prvku) do 'n-1'-tého (posledního) prvku
    for (int i = 1; i < n; i++)
    {
        // Pokud je aktuálně procházený prvek větší než maximum ...
        if (pole[i] > maximum)
        {
            // Uložené hodnoty nalezeného prvku do maxima
            maximum = pole[i];
        }
    }
 
    // 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

Vzhledem k tomu, že má být uživateli vypsáno pořadí nalezeného minima a maxima, je zapotřebí deklarovat další metodu IndexPrvku, která navrací index hledaného prvku, který byl metodě předán jako parametr - viz Kód 3. V cyklu s krokem implementovaným v těle metody je použita v řídící podmínce hodnota horní meze vyjádřená jako pole.Length. Tato metoda přidružená k poli navrací velikost pole (počet prvků pole). Základním kamenem metody je podmínka, v níž je porovnána hodnota aktuálně procházeného prvku s hodnotou hledaného prvku na rovnost. Pokud nastane rovnost, je zaznamenáná do lokální proměnné index. Je také vhodné upozornit, že proměnná index bude v sobě mít uloženou hodnotu posledního výskytu hledané hodnoty. Pokud bychom chtěli hledat pouze první výskyt hledaného prvku, museli bychom za příkaz přiřazení indexu aktuálně procházeného prvku i do proměnné index umístit příkaz break, který by ukončil cyklus pro procházení jednotlivých prvků vektoru. Hodnota uložená v proměnné index je návratem metody IndexPrvku.  

/// <summary>
/// Metoda s návratem - návrat indexu hledaného prvku vektoru
/// </summary>
/// <param name="prvek"> prvek, jehož index má být vyhledán </param>
/// <param name="pole"> prohledávaný vektor </param>
/// <returns> Návrat posledního indexu hledaného prvku (prvek nebyl nalezen návrat -1) </returns>
static int IndexPrvku(int prvek, int[] pole)
{
    // Deklarace: 'index' ... index nalezeného prvku ve vektoru; 'i' ... index (pozice) prvku vektoru
    int index;
 
    // Inicializace - žádný prvek nenalezen, tj. index = -1
    index = -1;
 
    /* Pro všechny prvky od počátečního prvku do posledního (index zjištěn pomocí návratu funkce 
     * rozměru pole) prvku */
    for (int i = 0; i < pole.Length; i++)
    {
        // Pokud je aktuálně procházený prvek shodný s předaným prvkem ...
        if (pole[i] == prvek)
        {
            // Přiřazení indexu aktuálního prvku do indexu hledaného prvku 
            index = i;
        }
    }
    // Přiřazení idnexu prvku do návratu metody
    return index;
}

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

Asi si říkáte, že tuto metodu jsme nemuseli vůbec používat. Na rozdíl od Flowgorithm, totiž metoda v C# umožňuje návrat více hodnot. Stačilo tedy přímo v metodě MinimumVPoli uložit pořadí do nějaké deklarované celočíselné proměnné v případě, že bylo nalezeno nové minimum. Pořadí bychom pak mohli deklarovat jako výstupní parametr metody MinimumVPoli. To samé platí i pro metodu MaximumVPoli.

3.6. Průměr pole

Pro výpočet aritmetického průměru ze všech prvků v poli je použita metoda PrumerPole. Tato metoda navrací reálné číslo reprezentující vypočtený průměr. Počátečním krokem metody je inicializace lokální celočíselné proměnné suma, která nám slouží pro uložení součtu všech dosud procházených prvků. Po ukončení průchodu všemi prvky vektoru je tato suma přetypována na reálné číslo (na typ double), abychom mohli provést podíl sumy a počtu prvků vektoru uloženým ve formálním parametru n, jehož výsledek je desetinné číslo (jinak bychom prováděli celočíselné dělení). Výsledek této operace je přiřazen výstupu metody - viz Kód 1.

/// <summary>
/// Navrát aritmetického průměru prvků vektoru
/// </summary>
/// <param name="n"> počet prvků vektoru </param>
/// <param name="pole"> prohledávaný vektor </param>
/// <returns> Průměr vektoru </returns>
static double PrumerPole(int n, int[] pole)
{
    /* Deklarace: 'prumer' ... průměrná reálná hodnota ze všech prvků vektoru; 
     * 'suma' ... suma hodnot všech prvků vektoru; 'i' ... index (pozice) 
     * prvku vektoru */
    double prumer;
    int suma;
 
    // Inicializace - suma prvků je 0
    suma = 0;
 
    // Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku
    for (int i = 0; i < n; i++)
    {
        // Přičtení dalšího prvku vektoru do sumy
        suma += pole[i];
    }
 
    // Výpočet průměru
    prumer = (double)suma / n;
 
    // Přiřazení vypočteného průměru návratu metody
    return prumer;
}

Kód 1: Deklarace statické metody s reálným návratem s názvem PrumerPole

3.7. Seřazení prvků pole

Pro seřazení prvků pole vzestupně je v hlavním programu volána metoda bez návratu s názvem SeraditPole. Tato metoda využívá třídění Bubble Sort, kde jsou porovnány jednotlivé dvojice sousedních prvků. Pokud je aktuálně procházený prvek větší než následující prvek, jsou tyto prvky vzájemně prohozeny. Pokud došlo alespoň k jednomu prohození sousedních prvků, celý vnitřní cyklus s krokem pro procházení od prvního do předposledního prvku je znovu opakován. Pokud nedošlo k prohození ani v jedné porovnávané dvojici sousedních prvků, není již vnější cyklus s podmínkou na konci prováděn. Následující zdrojový kód obsahuje deklarace metody SeraditPole - viz Kód 1.

/// <summary>
/// Metoda bez návratu - vzestupné řazení prvků pole
/// </summary>
/// <param name="n"> počet prvků </param>
/// <param name="pole"> vektor, který má být setříděn vzestupně </param>
static void SeraditPole(int n, int[] pole)
{
    /* Deklarace: 'pom' ... pomocná proměnná pro dočasné uložení prvku; 'b' ... logická proměnná 
     * obsahující informaci, zda došlo k prohození některých sousedních prvků; 'i' ... index (pozice) 
     * prvku vektoru */
    int pom;
    bool b;
 
    do
    {
        // Nedošlo k prohození sousedních prvků
        b = false;
 
        // Pro všechny prvky od počátečního do předposledního prvku
        for (int i = 0; i < n - 1; i++)
        {
            // Pokud je hodnota sousedícího prvku větší než hodnota aktuálně testovaného prvku
            if (pole[i] > pole[i + 1])
            {
                // Ulož hodnotu aktuálního prvku do pomocné proměnné
                pom = pole[i];
 
                // Ulož hodnotu sousedícího prvku do aktuálního prvku
                pole[i] = pole[i + 1];
 
                // Ulož hodnotu z pomocné proměnné do sousedícího prvku
                pole[i + 1] = pom;
 
                // Došlo k prohození sousedních prvků
                b = true;
            }
        }
        
    }
 
    // Testování, zda došlo k prohození některých sousedních prvků
    while (b == true);
}

Kód 1: Deklarace statické metody bez návratu s názvem SeraditPole

4. Výsledný kód

Následující zdrojový kód je kompletací předešlých kódů programu JednorozmernePole, který je umístěn v souboru Program.cs - viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace JednorozmernePole
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Deklarace: 'pocetPrvku' ... rozměr vektoru (počet prvků ve vektoru); 'Max' ... konstantní hodnota 
             * maximální velikosti vektoru; 'minHodnota' ... přípustná minimální hodnota (dolní mez) prvků vektoru; 
             * 'maxHodnota' ... přípustná maximální hodnota (horní mez) prvků vektoru */
 
            // Maximální rozměr vektoru
            const int Max = 10;
 
            // Dolní mez, které může nabýt prvek vektoru
            int minHodnota = 1;
 
            // Horní mez, které může nabýt prvek vektoru
            int maxHodnota = 100;
 
            // Rozměr vektoru je roven maximální možné délce
            int pocetPrvku = Max;
 
            // Zavolání metody s celočíselným návratem pro změnu velikosti vektoru
            pocetPrvku = RozmerPole(pocetPrvku, Max);
 
            // Deklarace vektoru se zadaným rozměrem (počtem prvků)
            int[] pole = new int[pocetPrvku];
 
            // Zavolání metody s celočíselný návratem pro změnu dolní meze, které mohou nabývat prvky vektoru
            minHodnota = DolniMez(minHodnota, maxHodnota);
 
            // Zavolání metody s celočíselným návratem pro změnu horní meze, které mohou nabývat prvky vektoru
            maxHodnota = HorniMez(minHodnota, maxHodnota);
 
            /* Zavolání metody pro plnění vektoru (náhodnými čísly, jednotlivě zadanými hodnotami, 
             * plnění vektoru nulami) */
            PlnitPole(pocetPrvku, minHodnota, maxHodnota, pole);
 
            // Výpis prvků vektoru v řádku, kde jednotlivé prvky jsou odděleny čárkami
            Console.WriteLine("Výpis pole (do řádku): " + PoleJakoText(pocetPrvku, pole));
 
            // Výpis prvků vektoru do sloupce, kde každý prvek je na nové řádce
            Console.WriteLine("Výpis pole (do sloupce): ");
            Console.Write(ZobrazitPole(pocetPrvku, pole));
 
            // Výpis hodnoty minima vektoru, včetně jeho indexu
            Console.WriteLine("Minimum v poli: " + MinimumVPoli(pocetPrvku, pole) + 
                " (index prvku: " + IndexPrvku(MinimumVPoli(pocetPrvku, pole), pole) + ")");
 
            // Výpis hodnoty maxima vektoru, včetně jeho indexu
            Console.WriteLine("Maximum v poli: " + MaximumVPoli(pocetPrvku, pole) + 
                " (index prvku: " + IndexPrvku(MaximumVPoli(pocetPrvku, pole), pole) + ")");
 
            // Výpis průměru všech prvků vektoru
            Console.WriteLine("Průměr prvků pole: " + PrumerPole(pocetPrvku, pole));
 
            // Vzestupné řazení prvků podle metody Bubble Sort
            SeraditPole(pocetPrvku, pole);
 
            // Výpis seřazeného vektoru do řádku
            Console.WriteLine("Seřazené pole (výpis do řádku): " + PoleJakoText(pocetPrvku, pole));
 
            // Výpis seřazeného vektoru do sloupce
            Console.WriteLine("Seřazené pole (výpis do sloupce): ");
            Console.Write(ZobrazitPole(pocetPrvku, pole));
 
            // Čekání na stisk klávesy -> ukončení programu
            Console.ReadKey();
        }
 
        #region Nastavení atributů pole
 
        /// <summary>
        /// Metoda s celočíselným návratem - navrací velikost pole (počet prvků vektoru)
        /// </summary>
        /// <param name="n"> aktuální velikost vektoru (počet prvků) </param>
        /// <param name="max"> maximální rozměr vektoru </param>
        /// <returns> Velikost vektoru </returns>
        static int RozmerPole(int n, int max)
        {
            /* Deklarace: 'zmena' ... informace (celé číslo), zda má být provedena změna rozměru 
             * pole; 'novaHodnota' ... nový rozměr vektoru */
            int zmena, novaHodnota;
 
            // Vypsání stávajícího rozměru vektoru
            Console.WriteLine("Počet prvků: {0}", n);
            do
            {
                // Výzva ke změně rozměru vektoru
                Console.Write("Změnit počet prvků vektoru (0...Ne, 1...Ano): ");
 
                // Načtení hodnoty, zda má dojít ke změně
                int.TryParse(Console.ReadLine(), out zmena);
 
                // Pokud načtená hodnota nebyla validní, cyklus zadání je znovu opakován
            }
            while ((zmena < 0) || (zmena > 1));
 
            // Pokud byl zadán index pro změnu ...
            if (zmena == 1)
            {
                // Výzva k zadání rozměru vektoru
                Console.Write("Zadejte počet prvků vektoru (1 - {0}): ", max);
 
                // Načtení rozměru vektoru
                int.TryParse(Console.ReadLine(), out novaHodnota);
 
                // Pokud nová hodnota je větší než maximum, nebo menší než 1 ...
                if ((novaHodnota > max) || (novaHodnota < 1))
                {
                    // Přiřazení maximálního rozměru vektoru do lokální proměnné určující počet prvků vektoru
                    novaHodnota = max;
                }
 
                // Pokud nový rozměr vektoru není stejný jako stávající počet prvků vektoru ...
                if (novaHodnota != n)
                {
                    // Uložení nového rozměru pole do proměnné
                    n = novaHodnota;
                }
 
                // Výpis nového zadaného rozměru vektoru
                Console.WriteLine("Rozměr pole: {0}", n);
            }
 
            // Návrat metody
            return n;
        }
 
        /// <summary>
        /// Metoda s celočíselným návratem - návrat dolní meze pro všechny prvky vektoru
        /// </summary>
        /// <param name="minHodnota"> dolní mez prvků vektoru </param>
        /// <param name="maxHodnota"> horní mez prvků vektoru </param>
        /// <returns> Dolní mez pro všechny prvky vektoru </returns>
        public static int DolniMez(int minHodnota, int maxHodnota)
        {
            /* Deklarace: 'novaHodnota' ... nová dolní mez prvků vektoru; 'zmena' ... celočíselná 
             * informace, zda má být provedena změna dolní meze prvků ('0'...Ne, '1'...Ano) */
            int novaHodnota, zmena;
 
            // Výpis stávající hodnoty dolní meze
            Console.WriteLine("Dolní mez prvků vektoru: {0}", minHodnota);
            do
            {
                // Výzva ke změně dolní meze
                Console.Write("Změnit dolní mez prvků vektoru (0...Ne, 1...Ano): ");
 
                // Načtení hodnoty do proměnné 'zmena' (informace, zda má dojít ke změně)
                int.TryParse(Console.ReadLine(), out zmena);
 
                // Pokud načtená hodnota není validní, cyklus zadání probíhá znovu
            }
            while (zmena < 0 || zmena > 1);
 
            // Test, zda má proběhnout změna dolní meze prvků vektoru
            if (zmena == 1)
            {
                // Výzva k zadání nové dolní meze prvků vektoru
                Console.Write("Zadejte dolní mez prvků vektoru: ");
 
                // Načtení nové dolní meze prvků vektoru
                int.TryParse(Console.ReadLine(), out novaHodnota);
 
                // Pokud nová hodnota dolní meze je větší než horní mez ...
                if (novaHodnota > maxHodnota)
                {
                    // Přiřazení horní meze do lokální proměnné určující dolní mez (horní a dolní mez budou stejné)
                    novaHodnota = maxHodnota;
                }
 
                // Pokud nová dolní mez vektoru není stejná jako stávající dolní mez prvků vektoru ...
                if (novaHodnota != minHodnota)
                {
                    // Přepsání stávající dolní meze prvků pole novou hodnotou
                    minHodnota = novaHodnota;
                }
 
                // Výpis nové dolní meze pro prvky vektoru
                Console.WriteLine("Dolní mez prvků vektoru: " + minHodnota);
            }
 
            // Návrat metody
            return minHodnota;
        }
 
        /// <summary>
        /// Metoda s celočíselným návratem - návrat horní meze pro všechny prvky vektoru
        /// </summary>
        /// <param name="minHodnota"> stávající horní mez prvků vektoru </param>
        /// <param name="maxHodnota"> horní mez prvků vektoru </param>
        /// <returns> Horní mez pro všechny prvky vektoru </returns>
        static int HorniMez(int minHodnota, int maxHodnota)
        {
            /* Deklarace: 'novaHodnota' ... nová horní mez prvků vektoru; 'zmena' ... celočíselná 
             * informace, zda má být provedena změna horní meze prvků ('0'...Ne, '1'...Ano) */
            int novaHodnota, zmena;
 
            // Výpis stávající hodnoty horní meze
            Console.WriteLine("Horní mez prvků vektoru: {0}", maxHodnota);
            do
            {
                // Výzva ke změně horní meze
                Console.Write("Změnit horní mez prvků vektoru (0...Ne, 1...Ano): ");
 
                // Načtení hodnoty do proměnné 'zmena' (informace, zda má dojít ke změně)
                int.TryParse(Console.ReadLine(), out zmena);
            }
            // Pokud načtená hodnota není validní, cyklus zadání probíhá znovu
            while ((zmena < 0) || (zmena > 1));
 
            // Test, zda má proběhnout změna horní meze prvků vektoru
            if (zmena == 1)
            {
                // Výzva k zadání nové horní meze prvků vektoru
                Console.Write("Zadejte horní mez prvků vektoru: ");
 
                // Načtení nové horní meze prvků vektoru
                int.TryParse(Console.ReadLine(), out novaHodnota);
 
                // Pokud nová hodnota horní meze je menší než horní mez ...
                if (novaHodnota < minHodnota)
                {
                    // Přiřazení dolní meze do lokální proměnné určující horní mez (horní a dolní mez budou stejné)
                    novaHodnota = minHodnota;
                }
 
                // Pokud nová horní mez vektoru není stejná jako stávající horní mez prvků vektoru ...
                if (novaHodnota != maxHodnota)
                {
                    // Přepsání stávající horní meze prvků pole novou hodnotou
                    maxHodnota = novaHodnota;
                }
 
                // Výpis nové horní meze pro prvky vektoru
                Console.WriteLine("Horní mez prvků vektoru: " + maxHodnota);
            }
 
            // Návrat metody
            return maxHodnota;
        }
        #endregion
        
        #region Plnění pole
 
        /// <summary>
        /// Metoda bez návratu - výběr metody plnění vektoru
        /// </summary>
        /// <param name="n"> aktuální rozměr (počet prvků) vektoru </param>
        /// <param name="minHodnota"> dolní mez prvků vektoru </param>
        /// <param name="maxHodnota"> horní mez prvků vektoru </param>
        /// <param name="pole"> vektor, který má být naplněn </param>
        static void PlnitPole(int n, int minHodnota, int maxHodnota, int[] pole)
        {
            /* Deklarace: 'zpusobPlneni' ... způsob plnění vektoru('0'...Náhodně, '1'...Jednotlivě, 
             * '2'...Nulovat) */
            int zpusobPlneni;
 
            do
            {
                // Výzva k zadání způsobu plnění vektoru
                Console.Write("Zvolte způsob plnění vektoru (0...Náhodně, 1...Jednotlivě, 2...Nulovat): ");
 
                // Načtení způsobu plnění
                int.TryParse(Console.ReadLine(), out zpusobPlneni);
            }
 
            // Načtení způsobu plnění proběhne znovu, pokud nebyl zadán validní celočíselný kód způsobu plnění
            while ((zpusobPlneni != 0) && (zpusobPlneni != 1) && (zpusobPlneni != 2));
 
            switch (zpusobPlneni) 
            {
                // Plnění vektoru náhodnými čísly
                case 0:
                    // Zavolání procedury pro plnění vektoru náhodnými čísly
                    NahodnePole(n, minHodnota, maxHodnota, pole);
                    break;
 
                // Plnění vektoru jednotlivými zadanými hodnotami uživatelem
                case 1:
                    // Plnění vektoru jednotlivými uživatelem zadanými čísly
                    PlnitJednotlive(n, minHodnota, maxHodnota, pole);
                    break;
 
                case 2:
                    // Všem prvkům vektoru přiřadíme hodnotu '0'
                    NulovatPole(n, pole);
                    break;
            }
        }
 
 
        /// <summary>
        /// Metoda bez návratu - plnění prvků pole hodnotou nula
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> vektor, který má být naplněn </param>
        static void NulovatPole(int n, int[] pole)
        {
            /* Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku;
             * 'i' ... index (pozice) prvku vektoru */
            for (int i = 0; i < n; i++)
            {
                // Přiřazení nuly 'i'-tému (aktuálně procházenému) prvku
                pole[i] = 0;
            }
        }
 
        /// <summary>
        /// Metoda bez návratu - plnění vektoru náhodnými čísly
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="minHodnota"> dolní mez prvků vektoru </param>
        /// <param name="maxHodnota"> horní mez prvků vektoru </param>
        /// <param name="pole"> vektor, který má být naplněn </param>
        static void NahodnePole(int n, int minHodnota, int maxHodnota, int[] pole)
        {
            /* Deklarace: 'rnd' ... náhodné číslo (generované na základě rovnoměrného rozdělení); 
             * 'i' ... index (pozice) prvku vektoru */
 
            // Deklarace náhodného čísla (objektu) včetně inicializace
            Random rnd = new Random();
 
            // Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku
            for (int i = 0; i < n; i++)
            {
                /* Vygenerování náhodného čísla uloženého do 'rnd' v rozsahu 'minHodnota' až 'maxHodnota'
                 * Přiřazení náhodného čísla do 'i'-tého prvku */
                pole[i] = rnd.Next(minHodnota, maxHodnota + 1);
            }
        }
 
        /// <summary>
        /// Metoda bez návratu - plnění jednotlivých prvků vektoru uživatelem
        /// </summary>
        /// <param name="n"> počet prvků </param>
        /// <param name="minHodnota"> stávající dolní mez prvků vektoru </param>
        /// <param name="maxHodnota"> stávající horní mez prvků vektoru </param>
        /// <param name="pole"> vektor, který má být naplněn </param>
        static void PlnitJednotlive(int n, int minHodnota, int maxHodnota, int[] pole)
        {
            /* Deklarace: 'index' ... index prvku, který má být naplněn; 'hodnota' ... hodnota 
             * prvku, který má být naplněn; 'plnit' ... informace, zda má zadán (naplněn) 
             * další prvek ('0'...Ano, '1'...Ne) */
            int index, hodnota, plnit;
 
            // Cyklus s podmínkou na konci pro plnění prvků
            do
            {
                // Cyklus s podmínkou na konci pro načtení indexu plněného prvku 
                do
                {
                    // Výzva k zadání indexu prvku, včetně vypsání mezí
                    Console.Write("Zadejte index prvku, který chcete naplnit (0 - {0}): ", 
                        pole.Length-1);
 
                    // Načtení indexu
                    int.TryParse(Console.ReadLine(), out index);
 
                    // Test, zda načtený index je mimo meze ...
                    if ((index < 0) || (index > n-1))
                    {
                        // Výpis o chybě
                        Console.WriteLine("Zadaná hodnota je mimo meze");
                    }
                }
                /* Podmínka cyklu, zda načtený index je mimo meze. Pokud ano, opakovaní 
                 * načtení indexu */
                while ((index < 0) || (index > n-1));
 
                // Cyklus s podmínkou na konci - validace zadané hodnoty zda je hodnota v rozsahu mezí 
                do
                {
                    // Výzva k zadání hodnoty prvku, včetně vypsání dolní a horní meze pro všechny prvky
                    Console.Write("Zadejte hodnotu prvku ({0} - {1}): ", minHodnota.ToString(), 
                        maxHodnota.ToString());
 
                    // Načtení hodnoty
                    int.TryParse(Console.ReadLine(), out hodnota);
 
                    // Test, zda načtená hodnota prvku je mimo meze ...
                    if ((hodnota < minHodnota) || (hodnota > maxHodnota))
                    {
                        // Výpis o chybě
                        Console.WriteLine("Zadaná hodnota je mimo meze");
                    }
                }
                /* Podmínka cyklu, zda načtená hodnota prvku je mimo meze. Pokud ano, opakovaní 
                 * načtení hodnoty */
                while ((hodnota < minHodnota) || (hodnota > maxHodnota));
 
                // Přiřazení hodnoty z lokální proměnné do prvku vektoru na pozici 'index'
                pole[index] = hodnota;
 
                // Zavolání metody pro zobrazení vektoru jako prvky v řádku oddělené čárkou
                Console.WriteLine(PoleJakoText(n, pole));
 
                // Zavolání metody pro zobrazení vektoru jako prvky pod sebou
                Console.WriteLine(ZobrazitPole(n, pole));
 
                // Cyklus s podmínkou na konci - validace informace o tom, zda dále plnit
                do
                {
                    // Výzva, zda mají být plněny další prvky
                    Console.Write("Chcete plnit další prvek (0...Ne, 1...Ano): ");
 
                    // Načtení informace o dalším plnění
                    int.TryParse(Console.ReadLine(), out plnit);
 
                    // Test, zda načtená hodnota (informace o plnění) je mimo meze ...
                    if ((plnit < 0) || (plnit > 1))
                    {
                        // Výpis chyby
                        Console.WriteLine("Zadaná hodnota je mimo meze");
                    }
                }
 
                /* Podmínka cyklu, zda načtená hodnota je mimo meze. Pokud ano, 
                 * opakovaní načtení hodnoty */
                while ((plnit < 0) || (plnit > 1));
            }
 
            /* Podmínka cyklu, zda má být provedeno další načtení prvku. Pokud ano (hodnota '1'), 
             * opakovaní načtení hodnoty */
            while (plnit == 1);
        }
 
        #endregion
 
        #region Zobrazení pole
 
        /// <summary>
        /// Výpis prvků vektoru do sloupce, kde každý prvek je na nové řádce
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> vypisovaný vektor </param>
        /// <returns> Text obsahující prvky ve sloupci </returns>
        static string ZobrazitPole(int n, int[] pole)
        {
            /* Deklarace: 'vystup' ... textový řetězec, kde jednotlivé prvky vektoru jsou 
             * umístěny pod sebou; 'i' ... index prvku ve vektoru */
            string vystup;
 
            // Inicializace - příprava textu  pro výpis v konzole
            vystup = "";
 
            // Pro všechny prvky od počátečního do koncového prvku ...
            for (int i = 0; i < n; i++)
            {
                /* Výpis prvku na novém řádku (návrat na počátek řádku ... znak na pozici '13' 
                 * nový řádek ... znak na pozici '10' v ASCII tabulce); 
                 * 0:D3 ... formátová specifikace, tj. 3 znaky (doplněno vedoucími nulami),
                 * nula znamená bez desetinných míst */
                vystup += string.Format("{0:D3}", pole[i]) + (char)13 + (char)10;
 
                /* Vložení nové řádky do výsledného textu pomocí řídící posloupnosti -
                 * \r ... návrat na počátek řádku; \n ... přechod na nový řádek */
                //vystup += string.Format("{0:D3}", pole[i]) + "\r\n";
 
                // Vložení nové řádky do výsledného textu
                //vystup += string.Format("{0:D3}", pole[i]) + Environment.NewLine;
            }
 
            // Přiřazení výstupního textu návratu metody
            return vystup;
        }
 
        /// <summary>
        /// Výpis prvků vektoru v řádku, kde jednotlivé prvky jsou odděleny čárkami
        /// </summary>
        /// <param name="n"> aktuální velikost (počet prvků) vektoru </param>
        /// <param name="pole"> vektor, který má být vypsán </param>
        /// <returns> Text obsahující prvky v řádku </returns>
        static string PoleJakoText(int n, int[] pole)
        {
            /* Deklarace: 'vystup' ... výstupní textový řetězec obsahující prvky vektoru 
             * oddělené čárkou; 'i' ... index prvku ve vektoru */
            string vystup;
 
            // Inicializace - příprava textu  pro výpis v konzole
            vystup = "";
 
            // Vypsání počátečního prvku do textového řetězce
            vystup += string.Format("{0:D3}", pole[0]);
 
            // Pro všechny prvky od druhého prvku (včetně) do posledního ...
            for (int i = 1; i < n; i++)
            {
                // Výpis prvku do řádku odděleného čárkou
                vystup += string.Format(", {0:D3}", pole[i]);
            }
 
            // Přiřazení textu návratu metody
            return vystup;
        }
 
        #endregion
 
        #region Výpočty s polem
 
        /// <summary>
        /// Návrat hodnoty minima vektoru - nejmenší prvek
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> prohledávaný vektor </param>
        /// <returns> Minimum vektoru </returns>
        static int MinimumVPoli(int n, int[] pole)
        {
            // Deklarace: 'minimum' ... nalezená minimální hodnota ve vektoru; 'i' ... index (pozice) prvku vektoru
            int minimum;
 
            // Hodnotu prvního prvku prohlásíme minimem
            minimum = pole[0];
 
            // Pro všechny prvky od '1' (druhého prvku) do 'n-1'-tého (posledního) prvku
            for (int i = 1; i < n; i++)
            {
                // Pokud je aktuálně procházený prvek menší než minimum ...
                if (pole[i] < minimum)
                {
                    // Uložené aktuálního prvku do minima
                    minimum = pole[i];
                }
            }
 
            // Přiřazení minima návratu metody
            return minimum;
        }
 
        /// <summary>
        /// Návrat hodnoty maxima vektoru - největší prvek
        /// </summary>
        /// <param name="n"> počet prvků pole </param>
        /// <param name="pole"> prohledávaný vektor </param>
        /// <returns> Maximum vektoru </returns>
        public static int MaximumVPoli(int n, int[] pole)
        {
            // Deklarace: 'maximum' ... nalezená maximální hodnota ve vektoru; 'i' ... index (pozice) prvku vektoru
            int maximum;
 
            // První prvek prohlásíme maximem
            maximum = pole[0];
 
            // Pro všechny prvky od '1' (druhého prvku) do 'n-1'-tého (posledního) prvku
            for (int i = 1; i < n; i++)
            {
                // Pokud je aktuálně procházený prvek větší než maximum ...
                if (pole[i] > maximum)
                {
                    // Uložené hodnoty nalezeného prvku do maxima
                    maximum = pole[i];
                }
            }
 
            // Přiřazení maxima návratu metody
            return maximum;
        }
 
        /// <summary>
        /// Metoda s návratem - návrat indexu hledaného prvku vektoru
        /// </summary>
        /// <param name="prvek"> prvek, jehož index má být vyhledán </param>
        /// <param name="pole"> prohledávaný vektor </param>
        /// <returns> Návrat posledního indexu hledaného prvku (prvek nebyl nalezen návrat -1) </returns>
        static int IndexPrvku(int prvek, int[] pole)
        {
            // Deklarace: 'index' ... index nalezeného prvku ve vektoru; 'i' ... index (pozice) prvku vektoru
            int index;
 
            // Inicializace - žádný prvek nenalezen, tj. index = -1
            index = -1;
 
            /* Pro všechny prvky od počátečního prvku do posledního (index zjištěn pomocí návratu funkce 
             * rozměru pole) prvku */
            for (int i = 0; i < pole.Length; i++)
            {
                // Pokud je aktuálně procházený prvek shodný s předaným prvkem ...
                if (pole[i] == prvek)
                {
                    // Přiřazení indexu aktuálního prvku do indexu hledaného prvku 
                    index = i;
                }
            }
            // Přiřazení idnexu prvku do návratu metody
            return index;
        }
 
        /// <summary>
        /// Navrát aritmetického průměru prvků vektoru
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> prohledávaný vektor </param>
        /// <returns> Průměr vektoru </returns>
        static double PrumerPole(int n, int[] pole)
        {
            /* Deklarace: 'prumer' ... průměrná reálná hodnota ze všech prvků vektoru; 
             * 'suma' ... suma hodnot všech prvků vektoru; 'i' ... index (pozice) 
             * prvku vektoru */
            double prumer;
            int suma;
 
            // Inicializace - suma prvků je 0
            suma = 0;
 
            // Pro všechny prvky od '0' (počátečního) do 'n-1'-tého (posledního) prvku
            for (int i = 0; i < n; i++)
            {
                // Přičtení dalšího prvku vektoru do sumy
                suma += pole[i];
            }
 
            // Výpočet průměru
            prumer = (double)suma / n;
 
            // Přiřazení vypočteného průměru návratu metody
            return prumer;
        }
 
        #endregion
 
        #region Úprava pole
 
        /// <summary>
        /// Metoda bez návratu - vzestupné řazení prvků pole
        /// </summary>
        /// <param name="n"> počet prvků </param>
        /// <param name="pole"> vektor, který má být setříděn vzestupně </param>
        static void SeraditPole(int n, int[] pole)
        {
            /* Deklarace: 'pom' ... pomocná proměnná pro dočasné uložení prvku; 'b' ... logická proměnná 
             * obsahující informaci, zda došlo k prohození některých sousedních prvků; 'i' ... index (pozice) 
             * prvku vektoru */
            int pom;
            bool b;
 
            do
            {
                // Nedošlo k prohození sousedních prvků
                b = false;
 
                // Pro všechny prvky od počátečního do předposledního prvku
                for (int i = 0; i < n - 1; i++)
                {
                    // Pokud je hodnota sousedícího prvku větší než hodnota aktuálně testovaného prvku
                    if (pole[i] > pole[i + 1])
                    {
                        // Ulož hodnotu aktuálního prvku do pomocné proměnné
                        pom = pole[i];
 
                        // Ulož hodnotu sousedícího prvku do aktuálního prvku
                        pole[i] = pole[i + 1];
 
                        // Ulož hodnotu z pomocné proměnné do sousedícího prvku
                        pole[i + 1] = pom;
 
                        // Došlo k prohození sousedních prvků
                        b = true;
                    }
                }
                
            }
 
            // Testování, zda došlo k prohození některých sousedních prvků
            while (b == true);
        }
 
        #endregion
    }
}

Kód 1: Program JednorozmernePole - deklarace hlavní statické metody Main včetně deklarací dalších metod

5. Výstup programu

Na následujících výstupech týkajících se programu JednorozmernePole (viz kapitola 3 Program - Kód 1: Program JednorozmernePole) budou zobrazeny jednotlivé výstupy konzolové aplikace pro různá nastavení atributů vektoru a případy plnění jednorozměrného pole.  

Rozměr pole

V následujícím výstupu programu JednorozmernePole vidíme změnu velikosti (rozměru) jednorozměrného pole (vektoru) - viz Výstup programu 1.  

Výstup programu 1 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Změna velikosti pole na 5 prvků

Pokud uživatel stiskl klávesu Enter, bez zadání hodnoty číselného indexu operace, která má být provedena, je provedena operace s indexem 0. Jak je to možné? Pro načítání a konverzi zadané hodnoty jsme použili příkaz int.TryParse(Console.ReadLine(), out zmena); . Jak vidíme, v příkazu je použit výstupní parametr zmena. Pokud uživatelem nebyla zadána žádná hodnota, která by mohla být konvertována, výstupní parametr nabyl přednastavené hodnoty pro příslušný datový typ, v tomto případě pro int je to 0 - viz Výstup programu 2. Vzhledem k tomu, že v parametru zmena je uložena hodnota 0 (pokud by měla být provedena změna velikosti vektoru, musela by se hodnota ve zmena rovnat hodnotě 1), již není proveden žádný z příkazů uvnitř následujícího rozhodovacího bloku v metodě RozmerPole. Díky tomu již nebyla znovu vypsána stávající velikost vektoru (která nebyla změněna) a jsou prováděny další instrukce v kódu.

Výstup programu 2 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Nezadání hodnoty indexu operace

Dolní a horní mez prvků

V následujícím výřezu výstupu programu vidíme změnu dolní meze specifikované pro všechny prvky jednorozměrného pole - viz Výstup programu 3.  

Výstup programu 3 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Změna dolní meze prvků pole

V následujícím výřezu výstupu programu vidíme změnu horní meze specifikované pro všechny prvky jednorozměrného pole - viz Výstup programu 4.  

Výstup programu 4 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Změna horní meze prvků pole

Plnění pole

Vzhledem k možnosti plnění pole různými způsoby, jsou v následujících odstavcích zobrazeny různé výřezy výstupů programu týkající se plnění vektorů na základě zvoleného indexu plnění. Pole jsou vypsány jak do řádku (metoda PoleJakoText), tak i do sloupce (metoda ZobrazitPole).

Náhodná čísla

Výstup programu 5 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Plnění pole náhodnými čísly

Plnění jednotlivých prvků pole

Další možností plnění pole je plnění prvku s určitým indexem pomocí hodnoty zadané uživatelem - viz Výstup programu 6. Před plněním jednotlivých prvků již není nutnost plnit všechny nenaplněné prvky nulami (tak jak tomu bylo zapotřebí ve vývojovému diagramu ve Flowgorithm). Jednotlivé prvky jsou inicializovány počáteční hodnotou v závislosti na příslušném datovém typu (např. pro datový typ int je přednastavená hodnota 0). Na výřezu výstupu programu vidíme postupné plnění celočíselného pole o 3 prvcích, kde po každém naplnění prvku je pole vypsáno. Plnění je ukončeno zadáním celočíselného indexu pro ukončení plnění.

Výstup programu 6 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Plnění jednotlivých prvků pole

Plnění nulami

Třetí možností plnění pole je všem prvkům přiřadit hodnotu 0. Následující výřez výstupu programu znázorňuje výpis pole o velikosti 10 prvků, kde jsou všechny prvky naplněny nulami - viz Výstup programu 7. 

Výstup programu 7 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Plnění všech prvků nulami

Minimum a maximum pole

Následující výřez výstupu programu konzolové aplikace ilustruje nalezení minima a maxima v poli o 10 prvcích. Ve výpisu je uvedeno i pořadí těchto dvou nalezených prvků. Pole bylo plněno náhodnými čísly v rozmezí celočíselných hodnot [1, 100] - viz Výstup programu 8.

Výstup programu 8 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Nalezené minimum a maximum v poli včetně jejich indexů ve vektoru

Průměr pole

Následující výřez výstupu programu konzolové aplikace ilustruje výpočet aritmetického průměru pole o 10 prvcích. Tyto prvky byly plněny náhodnými čísly v rozmezí celočíselných hodnot [1, 100] - viz Výstup programu 9.

Výstup programu 9 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Výpočet aritmetického průměru ze všech prvků pole

Seřazení prvků pole

Poslední výřez výstupu programu ilustruje seřazení prvků pole podle jejich hodnot ve vzestupném pořadí. Pole o 10 prvcích bylo naplněno náhodnými čísly v rozmezí celočíselných hodnot [1, 100] - viz Výstup programu 10. 

Výstup programu 10 - Kód 1 (viz kapitola 3 Program JednorozmernePole): Seřazení všech prvků pole vzestupně