All adjacent of a given element in a 2D Array or Matrix

Last Updated : 24 Mar, 2025

Given a 2d integer array arr, your task is to return all the adjacent elements of a particular integer whose position is given as (x, y).
Note: Adjacent elements are all the elements that share a common side or point i.e., they have a vertical, horizontal or diagonal distance of 1.

Examples:

Input: arr[][] = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ], x = 1, y = 1
Output: 1 2 3 4 6 7 8 9
Explanation: Elements adjacent to arr[1][1] (i.e., 5) are:
arr[0][0], arr[0][1], arr[0][2], arr[1][0], arr[1][2], arr[2][0], arr[2][1], and arr[2][2].
Input: arr[][] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }, x = 0, y = 2
Output: {2, 5, 6}

By Checking All Adjacent Cells Separately - O(1) Time and O(1) Space

The idea is to create 8 if conditions to check for all 8 neighbors of given cell (x, y), and include the valid cells in the answer.

C++

#include <bits/stdc++.h> using namespace std;  // Function to check whether // position is valid or not int isValidPos(int i, int j, int n, int m) {     if (i < 0 || j < 0 || i >= n || j >= m)         return 0;     return 1; }  // Function that returns all adjacent elements vector<int> getAdjacent(vector<vector<int>> &arr,      int i, int j) {      // Size of given 2d array     int n = arr.size();     int m = arr[0].size();      // Initialising a vector array     // where adjacent element will be stored     vector<int> ans;      // Checking for all the possible adjacent positions     if (isValidPos(i - 1, j - 1, n, m))         ans.push_back(arr[i - 1][j - 1]);     if (isValidPos(i - 1, j, n, m))         ans.push_back(arr[i - 1][j]);     if (isValidPos(i - 1, j + 1, n, m))         ans.push_back(arr[i - 1][j + 1]);     if (isValidPos(i, j - 1, n, m))         ans.push_back(arr[i][j - 1]);     if (isValidPos(i, j + 1, n, m))         ans.push_back(arr[i][j + 1]);     if (isValidPos(i + 1, j - 1, n, m))         ans.push_back(arr[i + 1][j - 1]);     if (isValidPos(i + 1, j, n, m))         ans.push_back(arr[i + 1][j]);     if (isValidPos(i + 1, j + 1, n, m))         ans.push_back(arr[i + 1][j + 1]);      // Returning the vector     return ans; }  int main() {     vector<vector<int>> arr =      {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};     int x = 1, y = 1;     vector<int> ans = getAdjacent(arr, x, y);     for (int i = 0; i < ans.size(); i++) {         cout << ans[i] << " ";     }     return 0; }

Java

import java.util.*;  class GfG {      // Function to check whether     // position is valid or not     static int isValidPos(int i, int j, int n, int m) {         if (i < 0 || j < 0 || i >= n || j >= m)             return 0;         return 1;     }      // Function that returns all adjacent elements     static List<Integer> getAdjacent(int[][] arr, int i, int j) {          // Size of given 2d array         int n = arr.length;         int m = arr[0].length;          // Initialising a list where adjacent elements will be stored         List<Integer> ans = new ArrayList<>();          // Checking for all the possible adjacent positions         if (isValidPos(i - 1, j - 1, n, m) == 1)             ans.add(arr[i - 1][j - 1]);         if (isValidPos(i - 1, j, n, m) == 1)             ans.add(arr[i - 1][j]);         if (isValidPos(i - 1, j + 1, n, m) == 1)             ans.add(arr[i - 1][j + 1]);         if (isValidPos(i, j - 1, n, m) == 1)             ans.add(arr[i][j - 1]);         if (isValidPos(i, j + 1, n, m) == 1)             ans.add(arr[i][j + 1]);         if (isValidPos(i + 1, j - 1, n, m) == 1)             ans.add(arr[i + 1][j - 1]);         if (isValidPos(i + 1, j, n, m) == 1)             ans.add(arr[i + 1][j]);         if (isValidPos(i + 1, j + 1, n, m) == 1)             ans.add(arr[i + 1][j + 1]);          // Returning the list         return ans;     }      public static void main(String[] args) {         int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};         int x = 1, y = 1;         List<Integer> ans = getAdjacent(arr, x, y);         for (int num : ans) {             System.out.print(num + " ");         }     } }

Python

# Function to check whether # position is valid or not def isValidPos(i, j, n, m):     if i < 0 or j < 0 or i >= n or j >= m:         return 0     return 1  # Function that returns all adjacent elements def getAdjacent(arr, i, j):      # Size of given 2d array     n = len(arr)     m = len(arr[0])      # Initialising a list where adjacent elements will be stored     ans = []      # Checking for all the possible adjacent positions     if isValidPos(i - 1, j - 1, n, m):         ans.append(arr[i - 1][j - 1])     if isValidPos(i - 1, j, n, m):         ans.append(arr[i - 1][j])     if isValidPos(i - 1, j + 1, n, m):         ans.append(arr[i - 1][j + 1])     if isValidPos(i, j - 1, n, m):         ans.append(arr[i][j - 1])     if isValidPos(i, j + 1, n, m):         ans.append(arr[i][j + 1])     if isValidPos(i + 1, j - 1, n, m):         ans.append(arr[i + 1][j - 1])     if isValidPos(i + 1, j, n, m):         ans.append(arr[i + 1][j])     if isValidPos(i + 1, j + 1, n, m):         ans.append(arr[i + 1][j + 1])      # Returning the list     return ans  arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] x, y = 1, 1 ans = getAdjacent(arr, x, y) print(" ".join(map(str, ans)))

using System; using System.Collections.Generic;  class GfG {      // Function to check whether     // position is valid or not     static int IsValidPos(int i, int j, int n, int m) {         if (i < 0 || j < 0 || i >= n || j >= m)             return 0;         return 1;     }      // Function that returns all adjacent elements     static List<int> GetAdjacent(int[,] arr, int i, int j) {          // Size of given 2d array         int n = arr.GetLength(0);         int m = arr.GetLength(1);          // Initialising a list where adjacent elements will be stored         List<int> ans = new List<int>();          // Checking for all the possible adjacent positions         if (IsValidPos(i - 1, j - 1, n, m) == 1)             ans.Add(arr[i - 1, j - 1]);         if (IsValidPos(i - 1, j, n, m) == 1)             ans.Add(arr[i - 1, j]);         if (IsValidPos(i - 1, j + 1, n, m) == 1)             ans.Add(arr[i - 1, j + 1]);         if (IsValidPos(i, j - 1, n, m) == 1)             ans.Add(arr[i, j - 1]);         if (IsValidPos(i, j + 1, n, m) == 1)             ans.Add(arr[i, j + 1]);         if (IsValidPos(i + 1, j - 1, n, m) == 1)             ans.Add(arr[i + 1, j - 1]);         if (IsValidPos(i + 1, j, n, m) == 1)             ans.Add(arr[i + 1, j]);         if (IsValidPos(i + 1, j + 1, n, m) == 1)             ans.Add(arr[i + 1, j + 1]);          // Returning the list         return ans;     }      public static void Main() {         int[,] arr = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };         int x = 1, y = 1;         List<int> ans = GetAdjacent(arr, x, y);         Console.WriteLine(string.Join(" ", ans));     } }

JavaScript

// Function to check whether // position is valid or not function isValidPos(i, j, n, m) {     if (i < 0 || j < 0 || i >= n || j >= m)         return 0;     return 1; }  // Function that returns all adjacent elements function getAdjacent(arr, i, j) {      // Size of given 2d array     let n = arr.length;     let m = arr[0].length;      // Initialising an array where adjacent elements will be stored     let ans = [];      // Checking for all the possible adjacent positions     if (isValidPos(i - 1, j - 1, n, m))         ans.push(arr[i - 1][j - 1]);     if (isValidPos(i - 1, j, n, m))         ans.push(arr[i - 1][j]);     if (isValidPos(i - 1, j + 1, n, m))         ans.push(arr[i - 1][j + 1]);     if (isValidPos(i, j - 1, n, m))         ans.push(arr[i][j - 1]);     if (isValidPos(i, j + 1, n, m))         ans.push(arr[i][j + 1]);     if (isValidPos(i + 1, j - 1, n, m))         ans.push(arr[i + 1][j - 1]);     if (isValidPos(i + 1, j, n, m))         ans.push(arr[i + 1][j]);     if (isValidPos(i + 1, j + 1, n, m))         ans.push(arr[i + 1][j + 1]);      // Returning the array     return ans; }  let arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; let x = 1, y = 1; let ans = getAdjacent(arr, x, y); console.log(ans.join(" "));

Output

1 2 3 4 6 7 8 9

Using For Loop - O(1) Time and O(1) Space

The idea is to define a directions array to store all eight directions, and run a loop to check all eight directions using single condition.

C++

#include <bits/stdc++.h> using namespace std;  // Function to check whether // position is valid or not int isValidPos(int i, int j, int n, int m) {     if (i < 0 || j < 0 || i >= n || j >= m)         return 0;     return 1; }  // Function that returns all adjacent elements vector<int> getAdjacent(vector<vector<int>> &arr,      int i, int j) {      // Size of given 2d array     int n = arr.size();     int m = arr[0].size();      vector<int> ans;      // directions     vector<vector<int>> dirs = {         {-1, -1}, {-1, 0}, {-1, 1},         {0, -1}, {0, 1},         {1, -1}, {1, 0}, {1, 1}     };      for (auto dir : dirs) {         int x = i + dir[0];         int y = j + dir[1];         if (isValidPos(x, y, n, m))             ans.push_back(arr[x][y]);     }      return ans; }  int main() {     vector<vector<int>> arr =      {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};     int x = 1, y = 1;     vector<int> ans = getAdjacent(arr, x, y);     for (int i = 0; i < ans.size(); i++) {         cout << ans[i] << " ";     }     return 0; }

Java

import java.util.*;  class GfG {      // Function to check whether     // position is valid or not     static int isValidPos(int i, int j, int n, int m) {         if (i < 0 || j < 0 || i >= n || j >= m)             return 0;         return 1;     }      // Function that returns all adjacent elements     static List<Integer> getAdjacent(int[][] arr, int i, int j) {          // Size of given 2d array         int n = arr.length;         int m = arr[0].length;          List<Integer> ans = new ArrayList<>();          // directions         int[][] dirs = {             {-1, -1}, {-1, 0}, {-1, 1},             {0, -1}, {0, 1},             {1, -1}, {1, 0}, {1, 1}         };          for (int[] dir : dirs) {             int x = i + dir[0];             int y = j + dir[1];             if (isValidPos(x, y, n, m) == 1)                 ans.add(arr[x][y]);         }          return ans;     }      public static void main(String[] args) {         int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};         int x = 1, y = 1;         List<Integer> ans = getAdjacent(arr, x, y);         for (int num : ans) {             System.out.print(num + " ");         }     } }

Python

# Function to check whether # position is valid or not def isValidPos(i, j, n, m):     if i < 0 or j < 0 or i >= n or j >= m:         return 0     return 1  # Function that returns all adjacent elements def getAdjacent(arr, i, j):      # Size of given 2d array     n = len(arr)     m = len(arr[0])      ans = []      # directions     dirs = [         (-1, -1), (-1, 0), (-1, 1),         (0, -1), (0, 1),         (1, -1), (1, 0), (1, 1)     ]      for dx, dy in dirs:         x, y = i + dx, j + dy         if isValidPos(x, y, n, m):             ans.append(arr[x][y])      return ans  arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] x, y = 1, 1 ans = getAdjacent(arr, x, y) print(" ".join(map(str, ans)))

using System; using System.Collections.Generic;  class GfG {      // Function to check whether     // position is valid or not     static int IsValidPos(int i, int j, int n, int m) {         if (i < 0 || j < 0 || i >= n || j >= m)             return 0;         return 1;     }      // Function that returns all adjacent elements     static List<int> GetAdjacent(int[,] arr, int i, int j) {          // Size of given 2d array         int n = arr.GetLength(0);         int m = arr.GetLength(1);          List<int> ans = new List<int>();          // directions         int[,] dirs = {             {-1, -1}, {-1, 0}, {-1, 1},             {0, -1}, {0, 1},             {1, -1}, {1, 0}, {1, 1}         };          for (int k = 0; k < dirs.GetLength(0); k++) {             int x = i + dirs[k, 0];             int y = j + dirs[k, 1];             if (IsValidPos(x, y, n, m) == 1)                 ans.Add(arr[x, y]);         }          return ans;     }      public static void Main() {         int[,] arr = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };         int x = 1, y = 1;         List<int> ans = GetAdjacent(arr, x, y);         Console.WriteLine(string.Join(" ", ans));     } }

JavaScript

// Function to check whether // position is valid or not function isValidPos(i, j, n, m) {     if (i < 0 || j < 0 || i >= n || j >= m)         return 0;     return 1; }  // Function that returns all adjacent elements function getAdjacent(arr, i, j) {      // Size of given 2d array     let n = arr.length;     let m = arr[0].length;      let ans = [];      // directions     let dirs = [         [-1, -1], [-1, 0], [-1, 1],         [0, -1], [0, 1],         [1, -1], [1, 0], [1, 1]     ];      for (let dir of dirs) {         let x = i + dir[0];         let y = j + dir[1];         if (isValidPos(x, y, n, m))             ans.push(arr[x][y]);     }      return ans; }  let arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; let x = 1, y = 1; let ans = getAdjacent(arr, x, y); console.log(ans.join(" "));

Output

1 2 3 4 6 7 8 9

XOR of major diagonal elements of a 3D Matrix

yashguptaaa333

Improve

Article Tags :

Practice Tags :

All adjacent of a given element in a 2D Array or Matrix

By Checking All Adjacent Cells Separately - O(1) Time and O(1) Space

Using For Loop - O(1) Time and O(1) Space

Similar Reads