Теория
Едномерният масив е редица от стойности, подредени една след друга. Много данни обаче са по природа таблица: шахматна дъска, седмично разписание, екран от пиксели, оценките на един клас по предмети. За тях C# предлага двумерния масив (two-dimensional array), който в математиката се нарича матрица: правоъгълник от елементи с еднакъв тип, подредени в редове и колони. Декларира се със запетая в квадратните скоби: int[,] matrix = new int[3, 4]; заделя 3 реда по 4 колони, а всичките 12 елемента получават стойността по подразбиране 0. Ако стойностите са известни предварително, записваме ги направо: int[,] m = { { 1, 2, 3 }, { 4, 5, 6 } }; — всяка вътрешна двойка скоби е един ред и всички редове трябва да са еднакво дълги.
До отделен елемент се стига с два индекса, разделени със запетая: matrix[1, 2] е елементът на ред 1, колона 2. И двата индекса започват от 0, така че в матрица 3 на 4 последният елемент е matrix[2, 3], а matrix[3, 0] хвърля IndexOutOfRangeException. Размерите не ги помним наизуст, а ги питаме от самия масив: GetLength(0) връща броя на редовете (първото измерение), GetLength(1) — броя на колоните, а Length — общия брой елементи. Свойството Rank показва броя на измеренията — при двумерен масив това е 2. Запомнете реда: първо ред, после колона, точно както четем таблица — по редове отгоре надолу, а във всеки ред отляво надясно.
Естественият начин за обхождане на матрица са вложените цикли (nested loops): външният for минава по редовете, вътрешният — по колоните на текущия ред. Тялото на вътрешния цикъл се изпълнява за всяка клетка, затова при 3 реда и 4 колони то работи 12 пъти. За отпечатване пишем Console.Write(matrix[r, c] + " ") във вътрешния цикъл и Console.WriteLine() след него — така всеки ред на матрицата излиза на отделен ред на екрана. foreach също минава през всички елементи (ред по ред), но не дава индекси, затова е удобен само за сума или за търсене на стойност. Когато задачата иска „по колони“, просто разменяме циклите: външният по c, вътрешният по r, а индексът в скобите си остава [r, c].
Четенето на матрица от конзолата следва същата схема. Първият ред на входа обикновено съдържа размерите — разделяме го със Split и преобразуваме с int.Parse. После с new int[rows, cols] заделяме масива и за всеки ред четем по един ред от входа, разделяме го на части и записваме числата в колоните. Опцията StringSplitOptions.RemoveEmptyEntries предпазва от двойни интервали, които иначе дават празен низ и FormatException в int.Parse. Същият подход работи и за матрици от double или string — сменят се само типът и методът за преобразуване.
Задачите с матрици се градят от няколко повтарящи се шаблона. Сума по редове — за всеки ред нулираме брояч, събираме колоните и извеждаме; сума по колони — същото с разменени цикли. Максимален елемент с координати — започваме от matrix[0, 0], пазим три променливи (max, maxRow, maxCol) и при по-голяма стойност обновяваме и трите. В квадратна матрица (брой редове = брой колони = n) има два диагонала: главният минава от горния ляв към долния десен ъгъл и за елементите му важи r == c, а вторичният (secondary diagonal, anti-diagonal) — от горния десен към долния ляв, с условие r + c == n - 1. Затова сумата на диагонал се събира с един-единствен цикъл: matrix[i, i] за главния и matrix[i, n - 1 - i] за вторичния.
Транспониране (transpose) означава редовете да станат колони: елементът от ред r, колона c отива на ред c, колона r. Ако матрицата е 2 на 3, транспонираната е 3 на 2, затова винаги създаваме нов масив new int[cols, rows] и записваме t[c, r] = m[r, c]. Опитът да се прави „на място“ работи само за квадратни матрици, и то внимателно — трябва да разменяме само двойките над главния диагонал, иначе всеки елемент се разменя два пъти и матрицата се връща в изходния си вид. Същата идея с нов масив се използва и при завъртане на матрица, обръщане на редовете или изрязване на подматрица. Двумерните масиви са частен случай на многомерните: int[,,] cube = new int[2, 3, 4]; има три измерения (Rank 3) и се обхожда с три вложени цикъла, но на практика се среща рядко.
Правоъгълният масив има едно ограничение: всички редове са еднакво дълги. Когато всеки ред трябва да е с различна дължина — оценките на ученици, които имат различен брой оценки, или триъгълникът на Паскал — използваме назъбен масив (jagged array): int[][] rows = new int[3][];. Това е масив от масиви: външният масив пази три препратки към едномерни масиви, но самите редове още не съществуват (те са null) и трябва да ги заделим поотделно: rows[0] = new int[5]; rows[1] = new int[2];. Достъпът е с две отделни двойки скоби rows[r][c], броят на редовете е rows.Length, а дължината на конкретен ред — rows[r].Length. Всеки ред е обикновен едномерен масив, затова върху него работят Array.Sort(rows[r]), foreach и методите на LINQ, а можем дори да заменим цял ред с нов масив. Разликата между [,] и [][] не е само в синтаксиса: правоъгълният масив е един непрекъснат блок с гарантирано еднакви редове и GetLength, а назъбеният е по-гъвкав и често по-бърз при достъп в .NET, но изисква да помним, че всеки ред се заделя отделно и може да е с различна дължина.
Златни правила
Първо ред, после колона
m[r, c] означава ред r, колона c; GetLength(0) е броят на редовете, GetLength(1) — броят на колоните. Размените ли ги, квадратната матрица ще мълчи, а правоъгълната ще хвърли IndexOutOfRangeException.
Размерите питайте масива
Не пишете for (int r = 0; r < 3; r++) с число от главата си, а r < m.GetLength(0). Така кодът работи за всяка матрица, а методите ви (например PrintMatrix) стават универсални.
Назъбеният масив се заделя на две стъпки
new int[n][] създава само външния масив — редовете са null. Всеки ред се създава отделно с rows[i] = new int[дължина], преди да запишете нещо в него.
Диагонали има само квадратната матрица
Главният диагонал е r == c, вторичният — r + c == n - 1. Формулата n - i вместо n - 1 - i е най-честата грешка и излиза извън масива още на първата стъпка.
Транспонирането иска нов масив с разменени размери
Матрица rows на cols се транспонира в new int[cols, rows] с t[c, r] = m[r, c]. Не се опитвайте да презапишете същата променлива елемент по елемент — размерът на масива е фиксиран.
Бърз справочник
Двумерен срещу назъбен масив
| Действие | Правоъгълен `int[,]` | Назъбен `int[][]` | Бележка |
|---|---|---|---|
| Деклариране и заделяне | int[,] m = new int[3, 4]; | int[][] j = new int[3][]; | При назъбения редовете са още null |
| Заделяне на ред | не е нужно — всички редове са готови | j[0] = new int[4]; j[1] = new int[2]; | Всеки ред може да е с различна дължина |
| Инициализация със стойности | int[,] m = { { 1, 2 }, { 3, 4 } }; | int[][] j = { new[] { 1, 2 }, new[] { 3 } }; | При [,] редовете са задължително еднакви |
| Достъп до елемент | m[r, c] | j[r][c] | Смесването на двата записа е грешка при компилация |
| Брой редове | m.GetLength(0) | j.Length | Първото измерение / дължината на външния масив |
| Брой колони | m.GetLength(1) | j[r].Length за всеки ред поотделно | Назъбеният няма „общ“ брой колони |
| Общ брой елементи | m.Length | сума от j[r].Length за всички редове | При [,] е произведението на размерите |
| Брой измерения | m.Rank е 2 | j.Rank е 1 — масив от масиви | int[,,] има Rank 3 |
| Работа с цял ред | няма директен достъп до ред | Array.Sort(j[r]), j[r].Sum(), j[r] = new int[5] | Редът е обикновен едномерен масив (Sum иска using System.Linq) |
Шаблони при задачи с матрици
| Задача | Условие или формула | Код | Бележка |
|---|---|---|---|
| Обхождане по редове | външен цикъл по r, вътрешен по c | for (r...) for (c...) m[r, c] | Стандартният ред за четене и печат |
| Обхождане по колони | външен цикъл по c, вътрешен по r | for (c...) for (r...) m[r, c] | Индексът в скобите остава [r, c] |
Сума на ред r | събираме всички колони на реда | sum += m[r, c] за c от 0 до GetLength(1) - 1 | Нулирайте sum за всеки ред |
| Главен диагонал | r == c | m[i, i] за i от 0 до n - 1 | Само в квадратна матрица |
| Вторичен диагонал | r + c == n - 1 | m[i, n - 1 - i] | n - i излиза извън масива |
| Над / под главния диагонал | c > r / c < r | for (c = r + 1; ...) / for (c = 0; c < r; ...) | Триъгълник без самия диагонал |
| Транспониране | t[c, r] = m[r, c] | new int[cols, rows] | Размерите се разменят |
| Максимум с координати | при m[r, c] > max помним r и c | max = m[r, c]; maxRow = r; maxCol = c; | Започнете от m[0, 0], не от 0 |
| Съсед в матрицата | r - 1, r + 1, c - 1, c + 1 | проверка r + 1 < m.GetLength(0) преди достъп | Първо границите, после достъпът |
Код за анализ и пренаписване
Четене на матрица, суми по редове и колони, максимум с координати
using System;
class Program
{
static void Main()
{
// Първи ред на входа: брой редове и брой колони, разделени с интервал
string[] size = Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries);
int rows = int.Parse(size[0]);
int cols = int.Parse(size[1]);
int[,] matrix = new int[rows, cols];
// Всеки следващ ред на входа съдържа cols числа
for (int r = 0; r < rows; r++)
{
string[] parts = Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries);
for (int c = 0; c < cols; c++)
{
matrix[r, c] = int.Parse(parts[c]);
}
}
Console.WriteLine("Матрицата:");
PrintMatrix(matrix);
// Сума по редове
for (int r = 0; r < matrix.GetLength(0); r++)
{
int rowSum = 0;
for (int c = 0; c < matrix.GetLength(1); c++)
{
rowSum += matrix[r, c];
}
Console.WriteLine($"Сума на ред {r}: {rowSum}");
}
// Сума по колони - външният цикъл е по колони
for (int c = 0; c < matrix.GetLength(1); c++)
{
int colSum = 0;
for (int r = 0; r < matrix.GetLength(0); r++)
{
colSum += matrix[r, c];
}
Console.WriteLine($"Сума на колона {c}: {colSum}");
}
// Най-голям елемент и координатите му
int max = matrix[0, 0];
int maxRow = 0;
int maxCol = 0;
for (int r = 0; r < matrix.GetLength(0); r++)
{
for (int c = 0; c < matrix.GetLength(1); c++)
{
if (matrix[r, c] > max)
{
max = matrix[r, c];
maxRow = r;
maxCol = c;
}
}
}
Console.WriteLine($"Максимум: {max} на позиция [{maxRow}, {maxCol}]");
}
static void PrintMatrix(int[,] m)
{
for (int r = 0; r < m.GetLength(0); r++)
{
for (int c = 0; c < m.GetLength(1); c++)
{
Console.Write(m[r, c] + " ");
}
Console.WriteLine();
}
}
}Какво се случва тук?
- Първият ред на входа (например
2 3) се разделя съсSplitи даваrows = 2,cols = 3; чак тогава създавамеnew int[rows, cols], защото размерът на масива трябва да е известен при заделянето. - Външният цикъл по
rчете по един ред от входа, а вътрешният поcпреобразува всяко число сint.Parseи го записва вmatrix[r, c];RemoveEmptyEntriesпази от двойни интервали. -
PrintMatrixе отделен метод, който приемаint[,]и ползваGetLength(0)иGetLength(1), затова работи за матрица с какъвто и да е размер;Console.WriteLine()без аргумент прекъсва реда след последната колона. - При сумата по редове броячът
rowSumсе нулира в началото на всяка итерация на външния цикъл — за входа1 5 3и7 2 9получаваме9и18. - При сумата по колони циклите са разменени: външният е по
c, но индексът оставаmatrix[r, c], защото позицията на елемента не се променя; резултатът е8,7,12. - За максимума започваме от истински елемент
matrix[0, 0], а не от 0 — иначе матрица само с отрицателни числа би дала грешен отговор; при по-голяма стойност обновяваме и трите променливи наведнъж. - Условието е
>(строго), затова при равни максимуми остава първият срещнат при обхождане по редове — за примера това е9на позиция[1, 2].
Диагонали, транспониране и назъбен масив (триъгълник на Паскал)
using System;
class Program
{
static void Main()
{
// 1. Квадратна матрица, зададена направо в кода
int[,] square =
{
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }
};
int n = square.GetLength(0);
int mainSum = 0;
int secondarySum = 0;
for (int i = 0; i < n; i++)
{
mainSum += square[i, i];
secondarySum += square[i, n - 1 - i];
}
Console.WriteLine($"Главен диагонал: {mainSum}");
Console.WriteLine($"Вторичен диагонал: {secondarySum}");
// 2. Транспониране на правоъгълна матрица 2x3 -> 3x2
int[,] a =
{
{ 1, 2, 3 },
{ 4, 5, 6 }
};
int[,] t = new int[a.GetLength(1), a.GetLength(0)];
for (int r = 0; r < a.GetLength(0); r++)
{
for (int c = 0; c < a.GetLength(1); c++)
{
t[c, r] = a[r, c];
}
}
Console.WriteLine("Транспонирана:");
PrintMatrix(t);
// 3. Назъбен масив: триъгълник на Паскал с 5 реда
int[][] pascal = new int[5][];
for (int r = 0; r < pascal.Length; r++)
{
pascal[r] = new int[r + 1];
pascal[r][0] = 1;
pascal[r][r] = 1;
for (int c = 1; c < r; c++)
{
pascal[r][c] = pascal[r - 1][c - 1] + pascal[r - 1][c];
}
}
Console.WriteLine("Триъгълник на Паскал:");
foreach (int[] row in pascal)
{
Console.WriteLine(string.Join(" ", row));
}
}
static void PrintMatrix(int[,] m)
{
for (int r = 0; r < m.GetLength(0); r++)
{
for (int c = 0; c < m.GetLength(1); c++)
{
Console.Write(m[r, c] + " ");
}
Console.WriteLine();
}
}
}Какво се случва тук?
-
squareе зададена с инициализатор — всяка вътрешна двойка скоби е ред;n = square.GetLength(0)е 3 и понеже матрицата е квадратна, същото връща иGetLength(1). - Един цикъл по
iстига и за двата диагонала:square[i, i]дава 1, 5, 9 (главен), аsquare[i, n - 1 - i]— 3, 5, 7 (вторичен); и двете суми са 15. - Транспонираната матрица
tсе създава с разменени размериnew int[a.GetLength(1), a.GetLength(0)], тоест 3 на 2, и всеки елемент се копира сt[c, r] = a[r, c]. - Изходът на
PrintMatrix(t)е1 4,2 5,3 6— първият ред наaе станал първа колона наt. -
new int[5][]създава само външния масив на триъгълника на Паскал; на всяка итерация редътrсе заделя сnew int[r + 1], затова нулевият ред има 1 елемент, а четвъртият — 5. - Крайните елементи на всеки ред са 1, а вътрешните се пресмятат от предишния ред:
pascal[r - 1][c - 1] + pascal[r - 1][c]; приr = 0иr = 1вътрешният цикъл не се изпълнява изобщо. -
foreach (int[] row in pascal)обхожда редовете като обикновени едномерни масиви, аstring.Join(" ", row)ги слепва за печат — така излизат1,1 1,1 2 1,1 3 3 1,1 4 6 4 1.
Внимавай! Чести грешки
Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.
Разменени GetLength(0) и GetLength(1)
Грешно
int[,] m = new int[2, 3];
for (int r = 0; r < m.GetLength(1); r++)
{
for (int c = 0; c < m.GetLength(0); c++)
{
Console.Write(m[r, c] + " ");
}
Console.WriteLine();
}Правилно
int[,] m = new int[2, 3];
for (int r = 0; r < m.GetLength(0); r++)
{
for (int c = 0; c < m.GetLength(1); c++)
{
Console.Write(m[r, c] + " ");
}
Console.WriteLine();
}При квадратна матрица грешката не се вижда, защото двете дължини са равни. При 2 на 3 обаче r стига до 2 и m[2, 0] хвърля IndexOutOfRangeException. GetLength(0) е винаги първото измерение — редовете.
Назъбен масив без заделени редове
Грешно
int[][] grades = new int[3][];
grades[0][0] = 6;Правилно
int[][] grades = new int[3][];
grades[0] = new int[4];
grades[0][0] = 6;new int[3][] създава само външния масив с три null препратки. grades[0][0] се опитва да индексира null и хвърля NullReferenceException — всеки ред на назъбения масив се заделя отделно.
Смесен синтаксис за достъп
Грешно
int[,] m = new int[3, 3];
m[1][2] = 5;
int[][] j = new int[3][];
j[1, 2] = 5;Правилно
int[,] m = new int[3, 3];
m[1, 2] = 5;
int[][] j = new int[3][];
j[1] = new int[3];
j[1][2] = 5;Правоъгълният масив се индексира с една двойка скоби и запетая, назъбеният — с две отделни двойки скоби. Компилаторът спира с грешка CS0022: Wrong number of indices inside [], така че грешката поне не стига до изпълнение.
Вторичен диагонал с n - i
Грешно
int n = m.GetLength(0);
int sum = 0;
for (int i = 0; i < n; i++)
{
sum += m[i, n - i];
}Правилно
int n = m.GetLength(0);
int sum = 0;
for (int i = 0; i < n; i++)
{
sum += m[i, n - 1 - i];
}При i = 0 изразът n - i е равен на n, а последният валиден индекс е n - 1 — програмата хвърля IndexOutOfRangeException още на първата итерация. Проверете формулата с ъглите: i = 0 трябва да даде горния десен елемент [0, n - 1].
Задачи за самостоятелна работа
Опитай първо сам — подсказката е там само ако наистина закъсаш.
Суми по редове и най-тежкият ред
Прочетете от конзолата размерите на матрица (rows cols на първия ред) и после rows реда с по cols цели числа, разделени с интервал. Изведете сумата на всеки ред във вида Ред 0: 9, общата сума на всички елементи и номера на реда с най-голяма сума (при равни суми — първия).
Диагонали и симетрична матрица
Прочетете число n и квадратна матрица n на n. Изведете сумата на главния диагонал, сумата на вторичния диагонал и сумата на елементите над главния диагонал (без самия диагонал). Накрая проверете дали матрицата е симетрична — тоест дали съвпада с транспонираната си (m[r, c] == m[c, r] за всички r и c) — и изведете Симетрична или Не е симетрична. Примерен вход: 3, след това 1 2 3, 2 5 6, 3 6 9 — матрицата е симетрична, диагоналите дават 15 и 11, а над главния диагонал сумата е 11.
Оценки в назъбен масив
Прочетете брой ученици n, а след това n реда — на всеки ред са оценките на един ученик, разделени с интервал; учениците имат различен брой оценки, а някой ред може да е и празен. Запазете данните в назъбен масив int[][]. За всеки ученик изведете броя на оценките и средния успех с два знака след десетичния разделител (или няма оценки). Накрая изведете кой ученик има най-много оценки и коя е най-високата оценка изобщо — с номера на ученика и номера на оценката в неговия ред.
Мини-тест за проверка
Отговори си наум (или на глас!) и чак тогава разкрий отговора.
1. За `int[,] m = new int[3, 5];` какво връщат `m.GetLength(0)`, `m.GetLength(1)` и `m.Length`?
2. Квадратна матрица има `n` реда. Защо `m[i, n - i]` не е вторичният диагонал и коя е правилната формула?
3. Какво ще се случи при `int[][] j = new int[3][]; j[0][0] = 1;` и защо същото не се случва с `int[,] m = new int[3, 3]; m[0, 0] = 1;`?
4. Матрица `a` е 2 реда на 3 колони. Какви са размерите на транспонираната ѝ, как се записва всеки елемент и защо не може да се транспонира „на място“ в същата променлива?
Речник на термините
Виж пълния речник на курсаint[,]. Всички редове са с еднаква дължина, а елементите се достъпват с m[r, c].[,] (и [,,]): един непрекъснат блок памет, в който всеки ред има еднакъв брой колони.int[][]. Всеки ред е отделен едномерен масив със собствена дължина и трябва да бъде заделен поотделно.int[] има ранг 1, int[,] — 2, int[,,] — 3. Назъбеният int[][] има ранг 1, защото е едномерен масив от масиви.d: GetLength(0) е броят на редовете, GetLength(1) — броят на колоните.r == c.r + c == n - 1, където n е размерът на квадратната матрица.t[c, r] = m[r, c]; матрица rows на cols става cols на rows.Провери знанията
Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.
Провери знанията си
9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.
Материали от часовете
Задачи и тестове, давани в клас по тази тема.
Препоръки за този модул
- Преди да пишете код, начертайте матрицата на лист с номерата на редовете и колоните отстрани. Проверете на ръка кой елемент е
m[1, 2]и какво трябва да излезе за сумата на ред 1 — после сравнете с изхода на програмата. - Напишете си веднъж метод
PrintMatrix(int[,] m)и го извиквайте след всяка стъпка от задачата. Повечето грешки с матрици се виждат веднага, щом видите матрицата на екрана. - Тествайте винаги и с правоъгълна матрица (например 2 на 3), а не само с квадратна. Квадратната матрица прощава разменени
GetLength(0)иGetLength(1), правоъгълната — не. - Пазете примерния вход в текстов файл и го поставяйте наведнъж в конзолата (или го подайте с
dotnet run < input.txtот cmd или bash). Така не го пишете на ръка при всяко стартиране и лесно пробвате гранични случаи като матрица с един ред или ред без оценки.