Tìm kiếm một phần tử trong mảng 2d trong c ++

Mảng 2D có thể được định nghĩa là một mảng của các mảng. Mảng 2D được tổ chức dưới dạng ma trận có thể được biểu diễn dưới dạng tập hợp các hàng và cột

Tuy nhiên, mảng 2D được tạo để triển khai cơ sở dữ liệu quan hệ có cấu trúc dữ liệu giống nhau. Nó giúp dễ dàng lưu giữ số lượng lớn dữ liệu cùng một lúc, có thể được chuyển đến bất kỳ chức năng nào khi cần thiết

Cách khai báo Mảng 2D

Cú pháp khai báo mảng hai chiều rất giống với cú pháp khai báo mảng một chiều, như sau

tuy nhiên, Nó tạo ra cấu trúc dữ liệu giống như sau


Tìm kiếm một phần tử trong mảng 2d trong c ++

Hình trên là mảng hai chiều, các phần tử được sắp xếp theo dạng hàng và cột. Phần tử đầu tiên của hàng đầu tiên được biểu thị bằng a[0][0] trong đó số hiển thị trong chỉ mục đầu tiên là số của hàng đó trong khi số hiển thị trong chỉ mục thứ hai là số của cột

Làm cách nào để chúng tôi truy cập dữ liệu trong một mảng 2D

Do các phần tử của mảng 2D có thể được truy cập ngẫu nhiên. Tương tự như mảng một chiều, chúng ta có thể truy cập từng ô riêng lẻ trong mảng 2D bằng cách sử dụng chỉ số của ô. Có hai chỉ số được gắn vào một ô cụ thể, một là số hàng của nó trong khi chỉ số kia là số cột của nó

Tuy nhiên, chúng ta có thể lưu trữ giá trị được lưu trữ trong bất kỳ ô cụ thể nào của mảng 2D vào một số biến x bằng cách sử dụng cú pháp sau

trong đó i và j lần lượt là số hàng và số cột của ô

Chúng ta có thể gán từng ô của mảng 2D thành 0 bằng cách sử dụng đoạn mã sau

Khởi tạo mảng 2D

Chúng ta biết rằng, khi khai báo và khởi tạo đồng thời mảng một chiều trong lập trình C, chúng ta không cần chỉ định kích thước của mảng. Tuy nhiên, điều này sẽ không hoạt động với mảng 2D. Chúng ta sẽ phải xác định ít nhất chiều thứ hai của mảng

Cú pháp khai báo và khởi tạo mảng 2D như sau

Số phần tử có thể có trong mảng 2D sẽ luôn bằng (số hàng * số cột)

Ví dụ. Lưu trữ dữ liệu của Người dùng vào một mảng 2D và in nó

Ví dụ C

Ví dụ Java

Ví dụ về C#

Ánh xạ mảng 2D thành mảng 1D

Khi nói đến ánh xạ mảng 2 chiều, hầu hết chúng ta có thể nghĩ rằng tại sao phải ánh xạ này. Tuy nhiên, mảng 2 D tồn tại theo quan điểm của người dùng. Mảng 2D được tạo để thực hiện cấu trúc dữ liệu giống bảng cơ sở dữ liệu quan hệ, trong bộ nhớ máy tính, kỹ thuật lưu trữ cho mảng 2D tương tự như mảng một chiều

Kích thước của mảng hai chiều bằng phép nhân của số hàng và số cột có trong mảng. Chúng ta cần ánh xạ mảng hai chiều sang mảng một chiều để lưu trữ chúng trong bộ nhớ

Mảng hai chiều 3 X 3 được hiển thị trong hình ảnh sau. Tuy nhiên, mảng này cần được ánh xạ thành mảng một chiều để lưu vào bộ nhớ


Tìm kiếm một phần tử trong mảng 2d trong c ++

Có hai kỹ thuật chính để lưu trữ các phần tử mảng 2D vào bộ nhớ

1. Thứ tự hàng chính

Theo thứ tự chính của hàng, tất cả các hàng của mảng 2D được lưu vào bộ nhớ liên tục. Xem xét mảng được hiển thị trong hình trên, phân bổ bộ nhớ của nó theo thứ tự chính của hàng được hiển thị như sau


Tìm kiếm một phần tử trong mảng 2d trong c ++

đầu tiên, hàng đầu tiên của mảng được lưu hoàn toàn vào bộ nhớ, sau đó hàng thứ 2 của mảng được lưu hoàn toàn vào bộ nhớ và cứ như vậy cho đến hàng cuối cùng


Tìm kiếm một phần tử trong mảng 2d trong c ++

2. Cột thứ tự chính

Theo thứ tự chính của cột, tất cả các cột của mảng 2D được lưu vào bộ nhớ liên tục. Cấp phát bộ nhớ của mảng được hiển thị trong hình trên được đưa ra như sau


Tìm kiếm một phần tử trong mảng 2d trong c ++

đầu tiên, cột đầu tiên của mảng được lưu hoàn toàn vào bộ nhớ, sau đó hàng thứ 2 của mảng được lưu hoàn toàn vào bộ nhớ và cứ như vậy cho đến cột cuối cùng của mảng


Tìm kiếm một phần tử trong mảng 2d trong c ++

Tính địa chỉ của phần tử ngẫu nhiên của mảng 2D

Do có hai kỹ thuật lưu trữ mảng hai chiều vào bộ nhớ khác nhau nên có hai công thức khác nhau để tính địa chỉ của một phần tử ngẫu nhiên của mảng hai chiều.

Theo thứ tự hàng chính

Nếu mảng được khai báo bởi a[m][n] trong đó m là số hàng trong khi n là số cột thì địa chỉ của phần tử a[i][j] của mảng được lưu trữ theo thứ tự chính của hàng được tính như sau

Một mảng các mảng được gọi là mảng 2D. Mảng hai chiều (2D) trong lập trình C còn được gọi là ma trận. Một ma trận có thể được biểu diễn dưới dạng một bảng các hàng và cột

Hãy xem chương trình C sau đây, trước khi chúng ta thảo luận thêm về mảng hai chiều

Ví dụ về mảng hai chiều (2D) đơn giản

Chương trình này trình bày cách lưu trữ các phần tử do người dùng nhập vào trong mảng 2 chiều và cách hiển thị các phần tử của mảng hai chiều. Bây giờ đừng lo lắng về việc khởi tạo mảng hai chiều được hiển thị trong ví dụ này, chúng ta sẽ thảo luận về phần đó sau

#include<stdio.h>
int main(){
   /* 2D array declaration*/
   int disp[2][3];
   /*Counter variables for the loop*/
   int i, j;
   for(i=0; i<2; i++) {
      for(j=0;j<3;j++) {
         printf("Enter value for disp[%d][%d]:", i, j);
         scanf("%d", &disp[i][j]);
      }
   }
   //Displaying array elements
   printf("Two Dimensional array elements:\n");
   for(i=0; i<2; i++) {
      for(j=0;j<3;j++) {
         printf("%d ", disp[i][j]);
         if(j==2){
            printf("\n");
         }
      }
   }
   return 0;
}

đầu ra

Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 

Khởi tạo mảng 2D

Có 2 cách khởi tạo mảng 2 chiều khi khai báo

int disp[2][4] = {
    {10, 11, 12, 13},
    {14, 15, 16, 17}
};

HOẶC

int disp[2][4] = { 10, 11, 12, 13, 14, 15, 16, 17};

Mặc dù cả hai khai báo trên đều hợp lệ, tôi khuyên bạn nên sử dụng phương thức đầu tiên vì nó dễ đọc hơn, vì bạn có thể hình dung các hàng và cột của mảng 2d trong phương thức này

Những điều bạn phải xem xét khi khởi tạo mảng 2D

Chúng ta đã biết, khi khởi tạo một mảng thường (hay có thể nói là mảng một chiều) trong quá trình khai báo, chúng ta không cần chỉ định kích thước của nó. Tuy nhiên, đó không phải là trường hợp của mảng 2D, bạn phải luôn chỉ định thứ nguyên thứ hai ngay cả khi bạn chỉ định các phần tử trong khi khai báo. Hãy hiểu điều này với sự trợ giúp của một vài ví dụ –

/* Valid declaration*/
int abc[2][2] = {1, 2, 3 ,4 }  
/* Valid declaration*/ 
int abc[][2] = {1, 2, 3 ,4 }  
/* Invalid declaration – you must specify second dimension*/
int abc[][] = {1, 2, 3 ,4 }   
/* Invalid because of the same reason  mentioned above*/
int abc[2][] = {1, 2, 3 ,4 }

Cách lưu trữ dữ liệu người dùng nhập vào mảng 2D

Chúng ta có thể tính xem một mảng hai chiều có thể có bao nhiêu phần tử bằng cách sử dụng công thức này. Mảng arr[n1][n2] có thể có n1*n2 phần tử. Mảng mà chúng ta có trong ví dụ bên dưới có kích thước là 5 và 4. Các kích thước này được gọi là chỉ số. Vì vậy, mảng này có giá trị chỉ số thứ nhất là 5 và giá trị chỉ số thứ hai là 4.
Vậy mảng abc[5][4] có thể có 5*4 = 20 phần tử.

Để lưu trữ các phần tử do người dùng nhập vào, chúng tôi đang sử dụng hai vòng lặp for, một trong số đó là vòng lặp lồng nhau. Vòng lặp bên ngoài chạy từ 0 đến (chỉ số thứ nhất -1) và vòng lặp for bên trong chạy từ 0 đến (chỉ số thứ hai -1). Bằng cách này, thứ tự mà người dùng nhập các phần tử sẽ là abc[0][0], abc[0][1], abc[0][2]…v.v.

#include<stdio.h>
int main(){
   /* 2D array declaration*/
   int abc[5][4];
   /*Counter variables for the loop*/
   int i, j;
   for(i=0; i<5; i++) {
      for(j=0;j<4;j++) {
         printf("Enter value for abc[%d][%d]:", i, j);
         scanf("%d", &abc[i][j]);
      }
   }
   return 0;
}

Trong ví dụ trên, tôi có một mảng 2D

Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
2 kiểu số nguyên. Về mặt khái niệm, bạn có thể hình dung mảng trên như thế này
Tìm kiếm một phần tử trong mảng 2d trong c ++

Tuy nhiên, biểu diễn thực tế của mảng này trong bộ nhớ sẽ giống như thế này

Tìm kiếm một phần tử trong mảng 2d trong c ++

Con trỏ và mảng 2D

Như chúng ta đã biết tên mảng một chiều có tác dụng như một con trỏ tới phần tử cơ sở (phần tử đầu tiên) của mảng. Tuy nhiên, trong trường hợp mảng 2D, logic hơi khác một chút. Bạn có thể coi mảng 2D là tập hợp của nhiều mảng một chiều

Vì vậy,

Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
3 sẽ có địa chỉ của phần tử đầu tiên của hàng đầu tiên (nếu chúng ta coi biểu đồ trên là số 1).
tương tự
Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
4 sẽ có địa chỉ của phần tử đầu tiên của hàng thứ hai. Để hiểu rõ hơn, chúng ta hãy viết một chương trình C –

#include <stdio.h>
int main()
{
   int abc[5][4] ={
            {0,1,2,3},
            {4,5,6,7},
            {8,9,10,11},
            {12,13,14,15},
            {16,17,18,19}
            };
    for (int i=0; i<=4; i++)
    {
        /* The correct way of displaying an address would be
         * printf("%p ",abc[i]); but for the demonstration
         * purpose I am displaying the address in int so that
         * you can relate the output with the diagram above that
         * shows how many bytes an int element uses and how they
         * are stored in contiguous memory locations.
         *
         */
    	printf("%d ",abc[i]);
    }
    return 0;
}

đầu ra

Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
0

Biểu diễn địa chỉ thực tế phải ở dạng hex mà chúng tôi sử dụng %p thay vì %d, như đã đề cập trong các nhận xét. Điều này chỉ để chỉ ra rằng các phần tử được lưu trữ trong các vị trí bộ nhớ liền kề. Bạn có thể liên kết đầu ra với sơ đồ trên để thấy rằng sự khác biệt giữa các địa chỉ này thực sự là số byte được tiêu thụ bởi các phần tử của hàng đó

Các địa chỉ được hiển thị trong đầu ra thuộc về phần tử đầu tiên của mỗi hàng

Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
5,
Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
6,
Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
7,
Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
8 và
Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
9

Làm cách nào để tính địa chỉ của một phần tử trong mảng 2D?

Có 2 kỹ thuật tìm địa chỉ của phần tử trong mảng 2D.
1. Thứ tự chính của hàng
2. Thứ tự chính của cột

1. Thứ tự hàng chính

Nếu mảng am được đại diện bởi

int disp[2][4] = {
    {10, 11, 12, 13},
    {14, 15, 16, 17}
};
0 trong đó x đại diện cho các hàng và y đại diện cho các cột thì địa chỉ của một phần tử ngẫu nhiên
int disp[2][4] = {
    {10, 11, 12, 13},
    {14, 15, 16, 17}
};
1 có thể được tính như sau

Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
8

Ở đây Base Address đại diện cho địa chỉ của phần tử

int disp[2][4] = {
    {10, 11, 12, 13},
    {14, 15, 16, 17}
};
2 (phần tử đầu tiên của mảng)

Ví dụ. Cho một mảng,

int disp[2][4] = {
    {10, 11, 12, 13},
    {14, 15, 16, 17}
};
7 với giá trị địa chỉ cơ sở là 100 và kích thước của mỗi phần tử là 4 Byte trong bộ nhớ. Tìm địa chỉ của
int disp[2][4] = {
    {10, 11, 12, 13},
    {14, 15, 16, 17}
};
8 với sự trợ giúp của thứ tự cột lớn?

Làm cách nào để tìm kiếm phần tử trong mảng 2D trong C?

Bước giải pháp .
Chạy một vòng lặp lồng nhau, vòng lặp bên ngoài cho hàng và vòng lặp bên trong cho cột
Kiểm tra mọi phần tử với mục tiêu và nếu phần tử được tìm thấy thì trả về True
Nếu phần tử không được tìm thấy, thì trả về Sai

Làm cách nào để tìm một phần tử trong ma trận trong C?

Phương pháp 1. Tạo một biến tìm kiếm lưu trữ giá trị của phần tử cần tìm kiếm và cũng khai báo một biến kiểu int nói cờ được khởi tạo bằng 0, biến đó trở thành true nếu phần tử có mặt trong ma trận đã cho

Làm cách nào chúng ta có thể tìm kiếm phần tử đã cho trong một mảng?

indexOf() Phương thức indexOf() trả về chỉ mục đầu tiên mà tại đó có thể tìm thấy một phần tử đã cho trong một mảng. Nó trả về -1 nếu phần tử không tồn tại trong mảng.

Làm cách nào để xác định mảng 2D trong C?

Ví dụ về mảng hai chiều trong C .
#include.
int main(){
int i=0,j=0;
int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};
// duyệt qua mảng 2D
for(i=0;i<4;i++){
for(j=0;j<3;j++){
printf("mảng[%d] [%d] = %d \n",i,j,mảng[i][j]);