Модул 20

Двумерни и назъбени масиви (матрици)

Как се пази таблица от данни в C#: двумерният масив `int[,]` с редове и колони, `GetLength`, вложени цикли и четене на матрица от конзолата. Класическите задачи с матрици — суми по редове и колони, максимум с координати, главен и вторичен диагонал, транспониране — и назъбените масиви `int[][]`, при които всеки ред има своя дължина.

Теория

Едномерният масив е редица от стойности, подредени една след друга. Много данни обаче са по природа таблица: шахматна дъска, седмично разписание, екран от пиксели, оценките на един клас по предмети. За тях 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 е 2j.Rank е 1 — масив от масивиint[,,] има Rank 3
Работа с цял редняма директен достъп до редArray.Sort(j[r]), j[r].Sum(), j[r] = new int[5]Редът е обикновен едномерен масив (Sum иска using System.Linq)

Шаблони при задачи с матрици

ЗадачаУсловие или формулаКодБележка
Обхождане по редовевъншен цикъл по r, вътрешен по cfor (r...) for (c...) m[r, c]Стандартният ред за четене и печат
Обхождане по колонивъншен цикъл по c, вътрешен по rfor (c...) for (r...) m[r, c]Индексът в скобите остава [r, c]
Сума на ред rсъбираме всички колони на редаsum += m[r, c] за c от 0 до GetLength(1) - 1Нулирайте sum за всеки ред
Главен диагоналr == cm[i, i] за i от 0 до n - 1Само в квадратна матрица
Вторичен диагоналr + c == n - 1m[i, n - 1 - i]n - i излиза извън масива
Над / под главния диагоналc > r / c < rfor (c = r + 1; ...) / for (c = 0; c < r; ...)Триъгълник без самия диагонал
Транспониранеt[c, r] = m[r, c]new int[cols, rows]Размерите се разменят
Максимум с координатипри m[r, c] > max помним r и cmax = m[r, c]; maxRow = r; maxCol = c;Започнете от m[0, 0], не от 0
Съсед в матрицатаr - 1, r + 1, c - 1, c + 1проверка r + 1 < m.GetLength(0) преди достъпПърво границите, после достъпът

Код за анализ и пренаписване

Четене на матрица, суми по редове и колони, максимум с координати

Program.cs
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].

Диагонали, транспониране и назъбен масив (триъгълник на Паскал)

Program.cs
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 колони. Какви са размерите на транспонираната ѝ, как се записва всеки елемент и защо не може да се транспонира „на място“ в същата променлива?

Речник на термините

Виж пълния речник на курса
Двумерен масив (two-dimensional array)
Масив с два индекса — ред и колона, деклариран с int[,]. Всички редове са с еднаква дължина, а елементите се достъпват с m[r, c].
Матрица (matrix)
Математическото име на правоъгълна таблица от стойности с редове и колони. В C# се представя най-често с двумерен масив.
Правоъгълен масив (rectangular array)
Друго име на масива [,] (и [,,]): един непрекъснат блок памет, в който всеки ред има еднакъв брой колони.
Назъбен масив (jagged array)
Масив от масиви, деклариран с int[][]. Всеки ред е отделен едномерен масив със собствена дължина и трябва да бъде заделен поотделно.
Ранг (rank)
Броят на измеренията на масив: int[] има ранг 1, int[,] — 2, int[,,] — 3. Назъбеният int[][] има ранг 1, защото е едномерен масив от масиви.
GetLength(d)
Метод, който връща дължината на масива по измерение d: GetLength(0) е броят на редовете, GetLength(1) — броят на колоните.
Главен диагонал (main diagonal)
Елементите на квадратна матрица от горния ляв до долния десен ъгъл, за които r == c.
Вторичен диагонал (secondary diagonal)
Елементите от горния десен до долния ляв ъгъл, за които r + c == n - 1, където n е размерът на квадратната матрица.
Транспониране (transpose)
Получаване на нова матрица, в която редовете на изходната са станали колони: 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). Така не го пишете на ръка при всяко стартиране и лесно пробвате гранични случаи като матрица с един ред или ред без оценки.

Учебен наръчник — теория, примери, задачи и тестове по предметите от учебния план.

Натисни Ctrl K или / отвсякъде, за да търсиш.