MẢNG HAI CHIỀU & ĐA CHIỀU TRONG C++

Trong C ++, chúng ta có thể định nghĩa các mảng đa chiều đơn giản là mảng của một mảng. Dữ liệu trong các mảng đa chiều được lưu trữ ở dạng bảng (theo thứ tự chính hàng). Hãy cùng Hybrid Technologies tìm hiểu về chủ đề này trong bài viết dưới đây nhé!

Thao tác và ví dụ với mảng hai chiều

Ví dụ: 

int x[3][4]; 

Trong ví dụ trên, x là một mảng hai chiều. Nó có thể chứa tối đa 12 yếu tố.
Chúng ta có thể nghĩ mảng này là một bảng có 3 hàng và mỗi hàng có 4 cột như hình bên dưới.

Các phần tử trong mảng hai chiều trong Lập trình C ++

Xuất các phần tử mảng hai chiều

Để truy xuất giá trị của phần tử trong mảng, ta sử dụng cú pháp:

<tên biến mảng>[<chỉ số dòng thứ x>][<chỉ số cột thứ y>];

Ví dụ: Cho mảng như sau

int a[2][3] // 2 dòng, 3 cột​

Các truy xuất:

  • Hợp lệ: a[0][0], a[0][1], …, a[1][1], a[1][2]

  • Không hợp lệ: a[-1][0], a[0][-1], a[2][3], … => cho kết quả không như mong muốn (có thể gây chết chương trình).

Chú ý: khi truy xuất một phần tử mảng, luôn đảm bảo chỉ số của phần tử đó là hợp lệ trong phạm vi của mảng.

Nhập và xuất mảng hai chiều

Bên dưới là ví dụ về nhập, xuất dữ liệu cho mảng:

#include <iostream>
#include <cstdlib> // for srand() and rand()
#include <ctime> // for time()
using namespace std;

// định nghĩa số phần tử mảng
#define ROW 100
#define COL 100

// khai báo prototype
void nhapMang(int mt[][COL], int &m, int &n);
void xuatMang(int mt[][COL], int m, int n);

int main()
{
	int mt[ROW][COL]; // mảng myArray có MAX phần tử
	int nRow, nCol; // số phần tử dòng và cột được sử dụng

	// nhập xuất mảng tự động
	nhapMang(mt, nRow, nCol);
	xuatMang(mt, nRow, nCol);

	return 0;
}

// hàm nhập mảng
void nhapMang(int mt[][COL], int &m, int &n)
{
	// khởi tạo số ngẫu nhiên
	srand(time(NULL));

	cout << "Nhap so dong : ";
	cin >> m;
	cout << "Nhap so cot : ";
	cin >> n;

	// khởi tạo mảng ngẫu nhiên từ [0][0] đến [m-1][n-1].
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			mt[i][j] = rand() % 100;
		}
	}
}

// hàm xuất mảng
void xuatMang(int mt[][COL], int m, int n)
{
	// xuất từng phần tử cho mảng
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cout << mt[i][j] << "\t";
		}
		cout << endl;
	}
}

Output:

Nhap so dong : 2
Nhap so cot : 3
61	63	46	
37	92	40	

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

Yêu cầu: cho trước ma trận mt, kích thước mxn. Tính tổng các phần tử trên dòng d, cột c.

Ý tưởng: duyệt ma trận và cộng dồn các phần tử có tọa độ (dòng, cột) thỏa yêu cầu.

#include <iostream>
#include <cstdlib> // for srand() and rand()
#include <ctime> // for time()
using namespace std;

// định nghĩa số phần tử mảng
#define ROW 100
#define COL 100

// khai báo prototype
void nhapMang(int mt[][COL], int &m, int &n);
void xuatMang(int mt[][COL], int m, int n);
int tongDong(int mt[][COL], int n, int d);
int tongCot(int mt[][COL], int m, int c);


int main()
{
	int mt[ROW][COL]; // mảng myArray có MAX phần tử
	int nRow, nCol; // số phần tử dòng và cột được sử dụng

	// nhập xuất mảng tự động
	nhapMang(mt, nRow, nCol);
	xuatMang(mt, nRow, nCol);

	// tính tổng dòng d, cột c
	int d;
	cout << "Nhap dong can tinh tong: ";
	cin >> d;
	cout << "Tong dong: " << tongDong(mt, nCol, d) << endl;

	// tính tổng cột c
	int c;
	cout << "Nhap dong can tinh tong: ";
	cin >> c;
	cout << "Tong dong: " << tongCot(mt, nRow, c) << endl;

	return 0;
}

// hàm nhập mảng
void nhapMang(int mt[][COL], int &m, int &n)
{
	// khởi tạo số ngẫu nhiên
	srand(time(NULL));

	cout << "Nhap so dong : ";
	cin >> m;
	cout << "Nhap so cot : ";
	cin >> n;

	// khởi tạo mảng ngẫu nhiên từ [0][0] đến [m-1][n-1].
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			mt[i][j] = rand() % 100;
		}
	}
}

// hàm xuất mảng
void xuatMang(int mt[][COL], int m, int n)
{
	// xuất từng phần tử cho mảng
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cout << mt[i][j] << "\t";
		}
		cout << endl;
	}
}

// tính tổng trên dòng d
int tongDong(int mt[][COL], int n, int d)
{
	int sum(0);
	for (int j = 0; j < n; j++) // Duyệt các cột
		sum += mt[d][j];

	return sum;
}

// tính tổng trên cột c
int tongCot(int mt[][COL], int m, int c)
{
	int sum(0);
	for (int i = 0; i < m; i++) // Duyệt các dòng
		sum += mt[i][c];

	return sum;
}

Ouput 

Nhap so dong : 2
Nhap so cot : 3
83	40	14	
47	22	65	
Nhap dong can tinh tong: 1
Tong dong: 134
Nhap dong can tinh tong: 2
Tong dong: 79

Tìm giá trị lớn nhất của mảng hai chiều

Yêu cầu: Cho trước ma trận mt, kích thước mxn. Tìm giá trị lớn nhất trong ma trận mt (gọi là max)

Ý tưởng:

  • Giả sử giá trị max hiện tại là giá trị phần tử đầu tiên mt[0][0]
  • Lần lượt kiểm tra các phần tử còn lại để cập nhật max.
#include <iostream>
#include <cstdlib> // for srand() and rand()
#include <ctime> // for time()
using namespace std;

// định nghĩa số phần tử mảng
#define ROW 100
#define COL 100

// khai báo prototype
void nhapMang(int mt[][COL], int &m, int &n);
void xuatMang(int mt[][COL], int m, int n);
int timMax(int mt[][COL], int m, int n);

int main()
{
	int mt[ROW][COL]; // mảng myArray có MAX phần tử
	int nRow, nCol; // số phần tử dòng và cột được sử dụng

	// nhập xuất mảng tự động
	nhapMang(mt, nRow, nCol);
	xuatMang(mt, nRow, nCol);

	// tìm max
	int max = timMax(mt, nRow, nCol);
	cout << "Max = " << max << endl;

	return 0;
}

// hàm nhập mảng
void nhapMang(int mt[][COL], int &m, int &n)
{
	// khởi tạo số ngẫu nhiên
	srand(time(NULL));

	cout << "Nhap so dong : ";
	cin >> m;
	cout << "Nhap so cot : ";
	cin >> n;

	// khởi tạo mảng ngẫu nhiên từ [0][0] đến [m-1][n-1].
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			mt[i][j] = rand() % 100;
		}
	}
}

// hàm xuất mảng
void xuatMang(int mt[][COL], int m, int n)
{
	// xuất từng phần tử cho mảng
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cout << mt[i][j] << "\t";
		}
		cout << endl;
	}
}

// tìm giá trị max của mảng 2 chiều
int timMax(int mt[][COL], int m, int n)
{
	int i, j, max;
	max = mt[0][0];
	for (i = 0; i < m; i++)
		for (j = 0; j < n; j++)
			if (mt[i][j] > max)
				max = mt[i][j];
	return max;
}

Ouput:

Nhap so dong : 2
Nhap so cot : 3
25	37	41	
95	53	53	
Max = 95

Thao tác với mảng đa chiều

Mảng đa chiều hoạt động như thế nào?

Mảng đa chiều cũng hoạt động theo cách tương tự như mảng hai chiều . Ví dụ:

float x[2][4][3];

Trong mảng này, x có thể chứa tối đa 24 yếu tố.

Chúng ta có thể tìm ra tổng số phần tử trong mảng chỉ bằng cách nhân kích thước của nó:

2 x 4 x 3 = 24

Kích thước của các mảng đa chiều

Tổng số phần tử có thể được lưu trữ trong một mảng nhiều chiều có thể được tính bằng cách nhân kích thước của tất cả các kích thước.
Ví dụ:
Mảng int x [10] [20] có thể lưu trữ tổng (10 * 20) = 200 phần tử.
Tương tự mảng int x [5] [10] [20] có thể lưu trữ tổng (5 * 10 * 20) = 1000 phần tử.

Khởi tạo mảng nhiều chiều

Giống như một mảng bình thường, chúng ta có thể khởi tạo một mảng nhiều chiều theo nhiều cách.

Mảng hai chiều là hình thức đơn giản nhất của mảng đa chiều. Chúng ta có thể thấy một mảng hai chiều là mảng của mảng một chiều để dễ hiểu hơn.

  • Hình thức cơ bản của khai báo mảng hai chiều có kích thước x, y:
    <Kiểu dữ liệu><Tên biến mảng> [x] [y]; 
    Kiểu dữ liệu : Loại dữ liệu sẽ được lưu trữ. Kiểu dữ liệu hợp lệ trong C++
  • Chúng ta có thể khai báo một mảng số nguyên hai chiều có kích thước ‘x’ có kích thước 10,20 là:
    int x [10] [20];
  • Các phần tử trong mảng hai chiều thường được gọi bằng x [i] [j] trong đó i là số hàng và ‘j’ là số cột.
  • Một mảng hai chiều có thể được xem như một bảng có các cột ‘x’ và ‘y’ trong đó số hàng nằm trong khoảng từ 0 đến (x-1) và số cột nằm trong khoảng từ 0 đến (y-1). Mảng hai chiều ‘x’ với 3 hàng và 3 cột được hiển thị bên dưới

Có 02 cách để khởi tạo một mảng hai chiều:

Phương pháp đầu tiên: 

int test[2][3] = {2, 4, 5, 9, 0, 19};

Phương pháp trên không được ưa thích. Một cách tốt hơn để khởi tạo mảng này với các phần tử mảng tương tự được đưa ra dưới đây.

Phương pháp tốt hơn:

int  test[2][3] = { {2, 4, 5}, {9, 0, 19}};

Mảng này có 2 hàng và 3 cột, đó là lý do tại sao chúng ta có hai hàng phần tử với 3 phần tử mỗi phần.

Khởi tạo mảng ba chiều

int test[2][3][4] = {3, 4, 2, 3, 0, -3, 9, 11, 23, 12, 23, 
                 2, 13, 4, 56, 3, 5, 9, 3, 5, 5, 1, 4, 9};

Đây chưa phải là một cách tốt để khởi tạo một mảng ba chiều. Một cách tốt hơn để khởi tạo mảng này là:

int test[2][3][4] = { 
                     { {3, 4, 2, 3}, {0, -3, 9, 11}, {23, 12, 23, 2} },
                     { {13, 4, 56, 3}, {5, 9, 3, 5}, {3, 1, 4, 9} }
                 };

Truy cập các phần tử trong mảng ba chiều: Truy cập các phần tử trong mảng ba chiều cũng tương tự như các phần tử mảng hai chiều.

Ví dụ 1: Mảng hai chiều

// C++ Program to display all elements
// of an initialised two dimensional array

#include <iostream>
using namespace std;

int main() {
    int test[3][2] = {{2, -5},
                      {4, 0},
                      {9, 1}};

    
// sử dụng vòng lặp lồng nhau
    // truy cập các hàng của mảng
    for (int i = 0; i < 3; ++i) {

        // truy cập các cột của mảng
        for (int j = 0; j < 2; ++j) {
            cout << "test[" << i << "][" << j << "] = " << test[i][j] << endl;
        }
    }

    return 0;
}

Ouput:

test[0][0] = 2
test[0][1] = -5
test[1][0] = 4
test[1][1] = 0
test[2][0] = 9
test[2][1] = 1

Trong ví dụ trên, ta đã khởi tạo một int mảng hai chiều có tên test có 3 “hàng” và 2 “cột”.

Ở đây, ta đã sử dụng for vòng lặp lồng nhau để hiển thị các phần tử mảng.

  • vòng lặp bên ngoài từ i = 0 để i = 2 truy cập vào các hàng của mảng
  • vòng lặp bên trong từ j = 0 để j = 1 truy cập các cột của mảng

Cuối cùng, ta sẽ in các phần tử mảng trong mỗi lần lặp.

Ví dụ 2: Mảng ba chiều

// C++ Program to Store value entered by user in
// three dimensional array and display it.

#include <iostream>
using namespace std;

int main() {
    // Mảng này có thể lưu trữ tối đa 12 phần tử (2x3x2)
    int test[2][3][2] = {
                            {
                                {1, 2},
                                {3, 4},
                                {5, 6}
                            }, 
                            {
                                {7, 8}, 
                                {9, 10}, 
                                {11, 12}
                            }
                        };

  
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            for (int k = 0; k < 2; ++k) {
                cout << "test[" << i << "][" << j << "][" << k << "] = " 
                     << test[i][j][k] << endl;
            }
        }
    }

    return 0;
}

Ouput:

test[0][0][0] = 1
test[0][0][1] = 2
test[0][1][0] = 3
test[0][1][1] = 4
test[0][2][0] = 5
test[0][2][1] = 6
test[1][0][0] = 7
test[1][0][1] = 8
test[1][1][0] = 9
test[1][1][1] = 10
test[1][2][0] = 11
test[1][2][1] = 12

 

Khái niệm cơ bản về các yếu tố in của mảng 3 chiều tương tự như mảng hai chiều. Tuy nhiên, vì ta đang thao tác 3 chiều nên ta phải sử dụng vòng lặp lồng nhau với 3 vòng thay vì chỉ 2 vòng. 

Như chúng ta có thể thấy, độ phức tạp của mảng tăng theo cấp số nhân với sự gia tăng kích thước. Nếu có bất cứ thắc mắc hay ý kiến bổ sung, các bạn hãy để lại comment phía dưới nha!

Nguồn: Sưu tầm.

Facebook Comments
Đánh giá bài viết

Bạn thích bài viết này chứ?
Đăng ký để nhận những bài viết thú vị như thế hàng tuần.

Đừng sợ thất bại, chỉ sợ việc dậm chân tại chỗ

TÌM VIỆC
Bình luận