To clear a 2D array in C++, you can use the nested loops to iterate through each element of the array and set the values to 0 or any other default value.

Here is an example code snippet in C++ to clear a 2D array:

cpp
 
 
Copy code
int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// Clearing the array
for(int i = 0; i < 3; i++) {
    for(int j = 0; j < 3; j++) {
        arr[i][j] = 0; // Set the value to 0
    }
}

In the above example, we have initialized a 2D array of 3x3 and then used two nested loops to set each element to 0. You can replace 0 with any other default value you want to set the array to.

To make a 2D array an argument of a function in C++, you can declare the function with the array parameter using square brackets for both dimensions.

cpp
 
 
Copy code
void myFunction(int myArray[][3]) {
  // function body here
}

In this example, myFunction() takes a 2D integer array as an argument. The size of the second dimension must be specified, while the size of the first dimension can be left empty or specified. In this case, the second dimension has a size of 3.

Here's an example of calling this function with a 2D array argument:

cpp
 
 
Copy code
int main() {
  int array2D[2][3] = {{1,2,3}, {4,5,6}};
  myFunction(array2D);
  return 0;
}

In this example, main() declares a 2D integer array called array2D, which is then passed as an argument to myFunction(). The function can then access or modify the elements of the array as needed.

cpp
 
 
Copy code
#include <iostream> 
using namespace std; 

int main() { 
    int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; 

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

    return 0; 
} 

Explanation:

• First, we define a 2D array arr with 3 rows and 3 columns.
• Then, we use two for loops to iterate over all the elements in the array.
• The outer for loop iterates over the rows (i) and the inner for loop iterates over the columns (j).
• We use the cout statement to print out each element in a matrix style, with a space between each element and a newline character after each row.

To perform a breadth-first search on a 2D array you can use a queue to store the elements to visit. Here is an example code in C++ to perform a BFS on a 2D array.

c++
 
 
Copy code
#include <iostream>
#include <queue>
using namespace std;

void bfs(int **arr, int rows, int cols, int start_row, int start_col) {
    // create a 2D boolean array to keep track of visited elements
    bool **visited = new bool*[rows];
    for (int i = 0; i < rows; i++) {
        visited[i] = new bool[cols];
        for (int j = 0; j < cols; j++) {
            visited[i][j] = false;
        }
    }

    // create a queue to store the elements to visit
    queue<pair<int, int>> q;

    // mark the starting element as visited and add it to the queue
    visited[start_row][start_col] = true;
    q.push(make_pair(start_row, start_col));

    // define the neighbors of an element
    int dr[] = {-1, 1, 0, 0};
    int dc[] = {0, 0, -1, 1};

    // BFS loop
    while (!q.empty()) {
        // get the front element from the queue
        pair<int, int> curr = q.front();
        q.pop();
        int r = curr.first;
        int c = curr.second;
        cout << arr[r][c] << " ";

        // visit the neighbors of the front element
        for (int i = 0; i < 4; i++) {
            int nr = r + dr[i];
            int nc = c + dc[i];
            // check if the neighbor is within the array bounds and not visited
            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && !visited[nr][nc]) {
                visited[nr][nc] = true;
                q.push(make_pair(nr, nc));
            }
        }
    }

    // free the memory used by the boolean array
    for (int i = 0; i < rows; i++) {
        delete[] visited[i];
    }
    delete[] visited;
}

int main() {
    // example 2D array
    int rows = 3;
    int cols = 4;
    int **arr = new int*[rows];
    for (int i = 0; i < rows; i++) {
        arr[i] = new int[cols];
        for (int j = 0; j < cols; j++) {
            arr[i][j] = i * cols + j;
        }
    }

    // perform BFS on the array starting from element (1, 2)
    bfs(arr, rows, cols, 1, 2);

    // free the memory used by the 2D array
    for (int i = 0; i < rows; i++) {
        delete[] arr[i];
    }
    delete[] arr;

    return 0;
}

In this example, the bfs function takes the 2D array arr, the number of rows rows and columns cols of the array, and the starting element start_row and start_col as arguments. It creates a 2D boolean array visited to keep track of visited elements, initializes a queue q with the starting element, and starts a BFS loop. For each element visited, it prints its value and checks its neighbors. If a neighbor is within the array bounds and has not been visited, it is added to the queue and marked as visited. When the queue is empty, the function returns. Finally, the memory allocated for the boolean array and the 2D array is freed.

To perform a Depth First Search (DFS) on a 2D array in C++, you can use recursion.

Here is some sample code to perform a DFS on a 2D array:

c++
 
 
Copy code
const int ROW = 3;
const int COL = 3;

// Helper function to perform a DFS on a 2D array
void dfs(int arr[][COL], bool visited[][COL], int row, int col) {
    // Check if current cell is inside the boundaries of the array
    if (row < 0 || row >= ROW || col < 0 || col >= COL) {
        return;
    }

    // Check if current cell has been visited or its value is 0
    if (visited[row][col] || arr[row][col] == 0) {
        return;
    }

    // Mark current cell as visited
    visited[row][col] = true;
    cout << arr[row][col] << " ";

    // Visit all neighbors
    dfs(arr, visited, row - 1, col); // up
    dfs(arr, visited, row + 1, col); // down
    dfs(arr, visited, row, col - 1); // left
    dfs(arr, visited, row, col + 1); // right
}

int main() {
    int arr[ROW][COL] = {
        {1, 0, 1},
        {0, 1, 0},
        {1, 0, 1}
    };
    bool visited[ROW][COL];

    // Initialize all cells as not visited
    memset(visited, false, sizeof(visited));

    // Perform DFS on all unvisited cells
    for (int i = 0; i < ROW; i++) {
        for (int j = 0; j < COL; j++) {
            if (!visited[i][j] && arr[i][j] == 1) {
                dfs(arr, visited, i, j);
            }
        }
    }
    return 0;
}

This code will run a DFS on a 2D array containing 1s and 0s, where 1s represent cells that should be visited and 0s represent cells that should be ignored.

The code initializes all cells as unvisited and loops through all cells in the array, calling the dfs function on each unvisited cell with a value of 1. During the DFS, the code recursively visits all neighboring cells with a value of 1 and marks them as visited, outputting their values as it goes.