Trang chủ » Blog » Mảng nhiều chiều trong C#

Mảng nhiều chiều trong C#

bởi CodeGym | 24/07/2024 15:08 | Blog

Nội dung

Giới thiệu về mảng nhiều chiều

Cơ bản về mảng hai chiều
Tạo ra biến mảng hai chiều và tạo ra mảng hai chiều
Cấp phát vùng nhớ
Lấy chiều dài các chiều của mảng hai chiều
Xử lý mảng hai chiều
Mảng nhiều chiều
Tổng kết

Giới thiệu về mảng nhiều chiều

Dữ liệu trong một bảng biểu là một ví dụ đặc trưng về mảng hai chiều. Ví dụ, dữ liệu trong bảng sau đây:

mảng nhiều chiều

Có thể được diễn giải vào một mảng hai chiều như sau:

double[,] distances = {
        {0, 983, 787, 714, 1375, 967, 1087},
        {983, 0, 214, 1102, 1763, 1723, 1842},
        {787, 214, 0, 888, 1549, 1548, 1627},
        {714, 1102, 888, 0, 661, 781, 810},
        {1375, 1763, 1549, 661, 0, 1426, 1187},
        {967, 1723, 1548, 781, 1426, 0, 239},
        {1087, 1842, 1627, 810, 1187, 239, 0},
};

Cơ bản về mảng hai chiều

Để tạo ra mảng hai chiều cần có thông tin về số hàng và số cột của mảng.

Vị trí của một phần tử trong mảng hai chiều được xác định bởi thông số hàng và cột. Thông qua vị trí, ta có thể lấy được giá trị của phần tử đó.

Tạo ra biến mảng hai chiều và tạo ra mảng hai chiều

Để khai báo một biến có kiểu là mảng hai chiều, ta có thể làm như sau:

<kiểu dữ liệu> [ , ] <tên mảng>;

Trong đó:

<kiểu dữ liệu> là kiểu dữ liệu của các phần tử trong mảng.
Cặp dấu [,] là ký hiệu cho khai báo mảng 2 chiều.
<tên mảng> là tên của mảng, cách đặt tên mảng cũng như cách đặt tên biến

Để sử dụng được mảng ta phải khởi tạo giá trị hoặc cấp phát vùng nhớ cho mảng.

Cấp phát vùng nhớ

Được thực hiện qua toán tử new. Khi cấp phát vùng nhớ cho mảng 2 chiều ta chỉ cần chỉ ra số dòng và số cột tối đa của mảng.

Ví dụ, tạo một biến tên matrix có kiểu là một mảng hai chiều của các số nguyên:

int[,] matrix

Để gán một mảng hai chiều thật sự vào biến matrix, ta làm như sau:

matrix = new int[5,5]

Như ta quan sát thấy, ta cần có thông tin về số dòng và số cột của mảng để có thể tạo ra mảng. C# sẽ bố trí sẵn một mảng như hình (2a). Lưu ý quan sát số dòng và số cột được đếm bắt đầu từ 0.

Để truy xuất và gán giá trị cho một phần tử ở hàng 2 cột 1 trong mảng, như được mô tả trong hình (2b), ta làm như sau:

matrix[2,1] = 7;

Bạn cũng có thể khởi tạo nhanh mảng hai chiều như được biểu thị ở hình (2c). Mã ở hình (3a) và (3b) dưới đây là tương đương nhau:

Lấy chiều dài các chiều của mảng hai chiều

Để lấy chiều dài các chiều của mảng hai chiều ta sử dụng phương thức GetLength(index);

index : 0 hoặc 1

GetLength(1) lấy ra chiều dài của hàng

GetLength(0) lấy ra chiều dài của cột

Ví dụ : với ảnh (3a) ta sử dụng đoạn mã sau để lấy ra chiều dài

  int row = array.GetLength(0); // Chiều dài của hàng là 3

  int col = array.GetLength(1); // Chiều dài của cột là 4

Xử lý mảng hai chiều

Những vòng lặp lồng nhau thường được sử dụng để xử lý trên một mảng hai chiều.

Đặt vấn đề chúng ta đã có một mảng được khai báo và tạo ra bởi dòng mã:

int[,] matrix = new int[10,10];

Dưới đây mã mẫu cho một số xử lý thường gặp trên mảng đó.

Nhập liệu các giá trị vào mảng

Chạy vòng lặp để đưa giá trị nhập liệu của người dùng vào mảng:

Console.WriteLine("Enter " + matrix.GetLength(0) + " rows and " + matrix.GetLength(1) + " columns: ");
for (int row = 0; row < matrix.GetLength(0); row++)
{
    for (int column = 0; column < matrix.GetLength(1); column++)
    {
        matrix[row, column] = Int32.Parse(Console.ReadLine());
    }
}

Nhập các giá trị ngẫu nhiên vào mảng

Thay vì sử dụng giá trị nhập liệu từ người dùng, tạo ra giá trị ngẫu nhiên để gán vào các phần tử của mảng:

Random rand = new Random();
for (int row = 0; row < matrix.GetLength(0); row++)
{
     for (int column = 0; column < matrix.GetLength(1); column++)
     {
         matrix[row, column] = rand.Next() * 100;
     }
}

In mảng

Sử dụng vòng lặp để in lần lượt từng phần tử một của mảng như trong khối lệnh dưới đây:

for (int row = 0; row < matrix.GetLength(0); row++)
{
     Console.WriteLine("\n");
     for (int column = 0; column < matrix.GetLength(1); column++)
     {
          Console.Write(matrix[row, column] + " ");
     }
}

Tính tổng tất cả các phần tử trong mảng

Sử dụng một biến total để lưu trữ giá trị tổng, được khởi tạo với giá trị 0. Sử dụng vòng lặp để cộng lần lượt từng phần tử một của mảng vào biến này:

int total = 0;
for (int row = 0; row < matrix.GetLength(0); row++)
{
     for (int column = 0; column < matrix.GetLength(1); column++)
     {
          total += matrix[row, column];;
     }
}

Tính tổng từng cột

Với mỗi cột, sử dụng một biến total để lưu trữ giá trị tổng, được khởi tạo với giá trị 0. Sử dụng vòng lặp để cộng lần lượt từng phần tử một của cột vào biến này:

for (int row = 0; row < matrix.GetLength(0); row++)
{
     int total = 0;
     for (int column = 0; column < matrix.GetLength(1); column++)
     {
        total += matrix[row, column];
        Console.WriteLine("Sum for column " + column + " is " + total);
     }
}

Tìm ra dòng có tổng các phần tử là lớn nhất

Sử dụng các biến maxRow và indexOfMaxRow để theo dấu tổng lớn nhất và định vị của dòng có tổng đó. Với mỗi dòng, tính tổng các phần tử của nó và cập nhật maxRow và indexOfMaxRow nếu dòng mới tính xong có tổng lớn hơn giá trị cũ:

int maxRow = 0;
int indexOfMaxRow = 0;
// Get sum of the first row in maxRow
for (int row = 0; row < matrix.GetLength(0); row++)
{
     maxRow += matrix[row, 0];
}

for (int row = 1; row < matrix.GetLength(0); row++)
{
     int totalOfThisRow = 0;
     for (int column = 0; column < matrix.GetLength(1); column++)
     {
          totalOfThisRow += matrix[row, column];
          if (totalOfThisRow > maxRow)
          {
             maxRow = totalOfThisRow;
             indexOfMaxRow = row;
          }
     }
}
Console.WriteLine("Row " + indexOfMaxRow + " has the maximum sum of " + maxRow);

Xáo trộn mảng

Với mỗi phần tử matrix[i,j], tạo ra ngẫu nhiên hai định vị i1 và j1 trong khoảng cho phép và tráo đổi giá trị của hai phần tử matrix[i,j] và matrix[i1,j1] với nhau:

Random rand = new Random();
for (int i = 0; i < matrix.GetLength(0); i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
         int i1 = (int)(rand.Next(0, matrix.GetLength(0)));
         int j1 = (int)(rand.Next(0, matrix.GetLength(1)));

         // Swap matrix[i,j] with matrix[i1,j1]
         int temp = matrix[i, j];
         matrix[i, j] = matrix[i1, j1];
         matrix[i1, j1] = temp;
      }
}

Mảng nhiều chiều

Mảng hai chiều là mảng của các mảng một chiều, và mảng ba chiều là mảng của các mảng hai chiều.

Đôi khi, ta gặp những dữ liệu cần được biểu diễn theo dạng mảng-n-chiều. Với C#, sử dụng cấu trúc mảng của các mảng, với bất cứ số nguyên dương n nào, ta có thể tạo ra mảng với n chiều.

Đặt vấn đề chúng ta cần lưu trữ điểm cho mỗi câu hỏi của của mỗi bài kiểm tra của các sinh viên. Dữ liệu đó là một mảng 3 chiều mà có thể được khai báo bằng câu lệnh sau đây:

double[,,] scores = new double[6,5,2];

Ta có thể tạo nhanh giá trị cho mảng scores bằng câu lệnh như dưới đây:

double[,,] scores = {
        {{7.5, 20.5}, {9.0, 22.5}, {15, 33.5}, {13, 21.5}, {15, 2.5}},
        {{4.5, 21.5}, {9.0, 22.5}, {15, 34.5}, {12, 20.5}, {14, 9.5}},
        {{6.5, 30.5}, {9.4, 10.5}, {11, 33.5}, {11, 23.5}, {10, 2.5}},
        {{6.5, 23.5}, {9.4, 32.5}, {13, 34.5}, {11, 20.5}, {16, 7.5}},
        {{8.5, 26.5}, {9.4, 52.5}, {13, 36.5}, {13, 24.5}, {16, 2.5}},
        {{9.5, 20.5}, {9.4, 42.5}, {13, 31.5}, {12, 20.5}, {16, 6.5}}};}

Ta có thể truy cập tới một giá trị điểm bất kỳ bằng cú pháp scores[0,1,2]. Nó chỉ tới điểm của câu hỏi số 3 của bài kiểm tra thứ 2 của sinh viên đầu tiên. Lược đồ sau làm rõ điều đó:

Tổng kết

Bài đọc này có những điểm đáng lưu ý sau:

Mảng hai chiều có thể được sử dụng để lưu trữ các “bảng”.
Một biến mảng hai chiều có thể được tạo ra bằng cú pháp elementType[,] arrayVar
Một mảng hai chiều có thể được tạo ra bằng cú pháp new elementType[ROW_SIZE,COLUMN_SIZE]
Mỗi phần tử trong mảng hai chiều được xác định bởi cú pháp arrayVar[rowIndex,columnIndex]
Mảng hai chiều có thể được khai báo nhanh với cú pháp elementType[,] arrayVar = {{row values}, . . . , {row values}}
Ta có thể sử dụng mảng của các mảng để cấu trúc nên mảng nhiều chiều.