Skip to content
Related Articles
Adjoint and Inverse of a Matrix
• Difficulty Level : Hard
• Last Updated : 11 Jun, 2021

Given a square matrix, find adjoint and inverse of the matrix.
We strongly recommend you to refer below as a prerequisite of this.
Determinant of a Matrix
What is Adjoint?
Adjoint (or Adjugate) of a matrix is the matrix obtained by taking transpose of the cofactor matrix of a given square matrix is called its Adjoint or Adjugate matrix. The Adjoint of any square matrix ‘A’ (say) is represented as Adj(A).
Example:

```Below example and explanation are taken from here.
5  -2  2  7
1   0  0  3
-3  1  5  0
3  -1 -9  4

For instance, the cofactor of the top left corner '5' is
+ |0   0   3|
...|1   5   0| = 3(1 * -9 - (-1) * 5) = -12.
...|-1 -9   4|
(The minor matrix is formed by deleting the row
and column of the given entry.)

As another sample, the cofactor of the top row corner '-2' is
-|1   0  3|
...|-3  5  0| = - [1 (20 - 0) - 0 + 3 (27 - 15)] = -56.
...|3  -9  4|

Proceeding like this, we obtain the matrix
[-12  -56   4   4]
[76   208   4   4]
[-60  -82  -2  20]
[-36  -58  -10 12]

Finally, to get the adjoint, just take the previous
matrix's transpose:
[-12   76 -60  -36]
[-56  208 -82  -58]
[4     4   -2  -10]
[4     4   20   12] ```

Important properties:

• Product of a square matrix A with its adjoint yields a diagonal matrix, where each diagonal entry is equal to determinant of A.
i.e.,

```A.adj(A) = det(A).I

I  => Identity matrix of same order as of A.
det(A) => Determinant value of A ```
• A non zero square matrix ‘A’ of order n is said to be invertible if there exists a unique square matrix ‘B’ of order n such that,
```   A.B = B.A = I
The matrix 'B' is said to be inverse of 'A'.
i.e.,  B = A-1```

How to find Adjoint?
We follow definition given above.

```Let A[N][N] be input matrix.

1) Create a matrix adj[N][N] store the adjoint matrix.
2) For every entry A[i][j] in input matrix where 0 <= i < N
and 0 <= j < N.
a) Find cofactor of A[i][j]
b) Find sign of entry.  Sign is + if (i+j) is even else
sign is odd.
c) Place the cofactor at adj[j][i]```

How to find Inverse?
Inverse of a matrix exists only if the matrix is non-singular i.e., determinant should not be 0.
Using determinant and adjoint, we can easily find the inverse of a square matrix using below formula,

```  If det(A) != 0
A-1 = adj(A)/det(A)
Else
"Inverse doesn't exist"  ```

Inverse is used to find the solution to a system of linear equation.
Below are implementation for finding adjoint and inverse of a matrix.

## C++

 `// C++ program to find adjoint and inverse of a matrix``#include``using` `namespace` `std;``#define N 4` `// Function to get cofactor of A[p][q] in temp[][]. n is current``// dimension of A[][]``void` `getCofactor(``int` `A[N][N], ``int` `temp[N][N], ``int` `p, ``int` `q, ``int` `n)``{``    ``int` `i = 0, j = 0;` `    ``// Looping for each element of the matrix``    ``for` `(``int` `row = 0; row < n; row++)``    ``{``        ``for` `(``int` `col = 0; col < n; col++)``        ``{``            ``//  Copying into temporary matrix only those element``            ``//  which are not in given row and column``            ``if` `(row != p && col != q)``            ``{``                ``temp[i][j++] = A[row][col];` `                ``// Row is filled, so increase row index and``                ``// reset col index``                ``if` `(j == n - 1)``                ``{``                    ``j = 0;``                    ``i++;``                ``}``            ``}``        ``}``    ``}``}` `/* Recursive function for finding determinant of matrix.``   ``n is current dimension of A[][]. */``int` `determinant(``int` `A[N][N], ``int` `n)``{``    ``int` `D = 0; ``// Initialize result` `    ``//  Base case : if matrix contains single element``    ``if` `(n == 1)``        ``return` `A;` `    ``int` `temp[N][N]; ``// To store cofactors` `    ``int` `sign = 1;  ``// To store sign multiplier` `     ``// Iterate for each element of first row``    ``for` `(``int` `f = 0; f < n; f++)``    ``{``        ``// Getting Cofactor of A[f]``        ``getCofactor(A, temp, 0, f, n);``        ``D += sign * A[f] * determinant(temp, n - 1);` `        ``// terms are to be added with alternate sign``        ``sign = -sign;``    ``}` `    ``return` `D;``}` `// Function to get adjoint of A[N][N] in adj[N][N].``void` `adjoint(``int` `A[N][N],``int` `adj[N][N])``{``    ``if` `(N == 1)``    ``{``        ``adj = 1;``        ``return``;``    ``}` `    ``// temp is used to store cofactors of A[][]``    ``int` `sign = 1, temp[N][N];` `    ``for` `(``int` `i=0; i``void` `display(T A[N][N])``{``    ``for` `(``int` `i=0; i

## Java

 `// Java program to find adjoint and inverse of a matrix``class` `GFG``{``    ` `static` `final` `int` `N = ``4``;` `// Function to get cofactor of A[p][q] in temp[][]. n is current``// dimension of A[][]``static` `void` `getCofactor(``int` `A[][], ``int` `temp[][], ``int` `p, ``int` `q, ``int` `n)``{``    ``int` `i = ``0``, j = ``0``;` `    ``// Looping for each element of the matrix``    ``for` `(``int` `row = ``0``; row < n; row++)``    ``{``        ``for` `(``int` `col = ``0``; col < n; col++)``        ``{``            ``// Copying into temporary matrix only those element``            ``// which are not in given row and column``            ``if` `(row != p && col != q)``            ``{``                ``temp[i][j++] = A[row][col];` `                ``// Row is filled, so increase row index and``                ``// reset col index``                ``if` `(j == n - ``1``)``                ``{``                    ``j = ``0``;``                    ``i++;``                ``}``            ``}``        ``}``    ``}``}` `/* Recursive function for finding determinant of matrix.``n is current dimension of A[][]. */``static` `int` `determinant(``int` `A[][], ``int` `n)``{``    ``int` `D = ``0``; ``// Initialize result` `    ``// Base case : if matrix contains single element``    ``if` `(n == ``1``)``        ``return` `A[``0``][``0``];` `    ``int` `[][]temp = ``new` `int``[N][N]; ``// To store cofactors` `    ``int` `sign = ``1``; ``// To store sign multiplier` `    ``// Iterate for each element of first row``    ``for` `(``int` `f = ``0``; f < n; f++)``    ``{``        ``// Getting Cofactor of A[f]``        ``getCofactor(A, temp, ``0``, f, n);``        ``D += sign * A[``0``][f] * determinant(temp, n - ``1``);` `        ``// terms are to be added with alternate sign``        ``sign = -sign;``    ``}` `    ``return` `D;``}` `// Function to get adjoint of A[N][N] in adj[N][N].``static` `void` `adjoint(``int` `A[][],``int` `[][]adj)``{``    ``if` `(N == ``1``)``    ``{``        ``adj[``0``][``0``] = ``1``;``        ``return``;``    ``}` `    ``// temp is used to store cofactors of A[][]``    ``int` `sign = ``1``;``    ``int` `[][]temp = ``new` `int``[N][N];` `    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``        ``for` `(``int` `j = ``0``; j < N; j++)``        ``{``            ``// Get cofactor of A[i][j]``            ``getCofactor(A, temp, i, j, N);` `            ``// sign of adj[j][i] positive if sum of row``            ``// and column indexes is even.``            ``sign = ((i + j) % ``2` `== ``0``)? ``1``: -``1``;` `            ``// Interchanging rows and columns to get the``            ``// transpose of the cofactor matrix``            ``adj[j][i] = (sign)*(determinant(temp, N-``1``));``        ``}``    ``}``}` `// Function to calculate and store inverse, returns false if``// matrix is singular``static` `boolean` `inverse(``int` `A[][], ``float` `[][]inverse)``{``    ``// Find determinant of A[][]``    ``int` `det = determinant(A, N);``    ``if` `(det == ``0``)``    ``{``        ``System.out.print(``"Singular matrix, can't find its inverse"``);``        ``return` `false``;``    ``}` `    ``// Find adjoint``    ``int` `[][]adj = ``new` `int``[N][N];``    ``adjoint(A, adj);` `    ``// Find Inverse using formula "inverse(A) = adj(A)/det(A)"``    ``for` `(``int` `i = ``0``; i < N; i++)``        ``for` `(``int` `j = ``0``; j < N; j++)``            ``inverse[i][j] = adj[i][j]/(``float``)det;` `    ``return` `true``;``}` `// Generic function to display the matrix. We use it to display``// both adjoin and inverse. adjoin is integer matrix and inverse``// is a float.` `static` `void` `display(``int` `A[][])``{``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``        ``for` `(``int` `j = ``0``; j < N; j++)``            ``System.out.print(A[i][j]+ ``" "``);``        ``System.out.println();``    ``}``}``static` `void` `display(``float` `A[][])``{``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``        ``for` `(``int` `j = ``0``; j < N; j++)``            ``System.out.printf(``"%.6f "``,A[i][j]);``        ``System.out.println();``    ``}``}` `// Driver program``public` `static` `void` `main(String[] args)``{``    ``int` `A[][] = { {``5``, -``2``, ``2``, ``7``},``                    ``{``1``, ``0``, ``0``, ``3``},``                    ``{-``3``, ``1``, ``5``, ``0``},``                    ``{``3``, -``1``, -``9``, ``4``}};` `    ``int` `[][]adj = ``new` `int``[N][N]; ``// To store adjoint of A[][]` `    ``float` `[][]inv = ``new` `float``[N][N]; ``// To store inverse of A[][]` `    ``System.out.print(``"Input matrix is :\n"``);``    ``display(A);` `    ``System.out.print(``"\nThe Adjoint is :\n"``);``    ``adjoint(A, adj);``    ``display(adj);` `    ``System.out.print(``"\nThe Inverse is :\n"``);``    ``if` `(inverse(A, inv))``        ``display(inv);` `}``}` `// This code is contributed by Rajput-Ji`

## C#

 `// C# program to find adjoint and inverse of a matrix``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ` `static` `readonly` `int` `N = 4;` `// Function to get cofactor of A[p,q] in [,]temp. n is current``// dimension of [,]A``static` `void` `getCofactor(``int` `[,]A, ``int` `[,]temp, ``int` `p, ``int` `q, ``int` `n)``{``    ``int` `i = 0, j = 0;` `    ``// Looping for each element of the matrix``    ``for` `(``int` `row = 0; row < n; row++)``    ``{``        ``for` `(``int` `col = 0; col < n; col++)``        ``{``            ``// Copying into temporary matrix only those element``            ``// which are not in given row and column``            ``if` `(row != p && col != q)``            ``{``                ``temp[i, j++] = A[row, col];` `                ``// Row is filled, so increase row index and``                ``// reset col index``                ``if` `(j == n - 1)``                ``{``                    ``j = 0;``                    ``i++;``                ``}``            ``}``        ``}``    ``}``}` `/* Recursive function for finding determinant of matrix.``n is current dimension of [,]A. */``static` `int` `determinant(``int` `[,]A, ``int` `n)``{``    ``int` `D = 0; ``// Initialize result` `    ``// Base case : if matrix contains single element``    ``if` `(n == 1)``        ``return` `A[0, 0];` `    ``int` `[,]temp = ``new` `int``[N, N]; ``// To store cofactors` `    ``int` `sign = 1; ``// To store sign multiplier` `    ``// Iterate for each element of first row``    ``for` `(``int` `f = 0; f < n; f++)``    ``{``        ``// Getting Cofactor of A[0,f]``        ``getCofactor(A, temp, 0, f, n);``        ``D += sign * A[0, f] * determinant(temp, n - 1);` `        ``// terms are to be added with alternate sign``        ``sign = -sign;``    ``}``    ``return` `D;``}` `// Function to get adjoint of A[N,N] in adj[N,N].``static` `void` `adjoint(``int` `[,]A, ``int` `[,]adj)``{``    ``if` `(N == 1)``    ``{``        ``adj[0, 0] = 1;``        ``return``;``    ``}` `    ``// temp is used to store cofactors of [,]A``    ``int` `sign = 1;``    ``int` `[,]temp = ``new` `int``[N, N];` `    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``for` `(``int` `j = 0; j < N; j++)``        ``{``            ``// Get cofactor of A[i,j]``            ``getCofactor(A, temp, i, j, N);` `            ``// sign of adj[j,i] positive if sum of row``            ``// and column indexes is even.``            ``sign = ((i + j) % 2 == 0)? 1: -1;` `            ``// Interchanging rows and columns to get the``            ``// transpose of the cofactor matrix``            ``adj[j, i] = (sign) * (determinant(temp, N - 1));``        ``}``    ``}``}` `// Function to calculate and store inverse, returns false if``// matrix is singular``static` `bool` `inverse(``int` `[,]A, ``float` `[,]inverse)``{``    ``// Find determinant of [,]A``    ``int` `det = determinant(A, N);``    ``if` `(det == 0)``    ``{``        ``Console.Write(``"Singular matrix, can't find its inverse"``);``        ``return` `false``;``    ``}` `    ``// Find adjoint``    ``int` `[,]adj = ``new` `int``[N, N];``    ``adjoint(A, adj);` `    ``// Find Inverse using formula "inverse(A) = adj(A)/det(A)"``    ``for` `(``int` `i = 0; i < N; i++)``        ``for` `(``int` `j = 0; j < N; j++)``            ``inverse[i, j] = adj[i, j]/(``float``)det;` `    ``return` `true``;``}` `// Generic function to display the matrix. We use it to display``// both adjoin and inverse. adjoin is integer matrix and inverse``// is a float.``static` `void` `display(``int` `[,]A)``{``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``for` `(``int` `j = 0; j < N; j++)``            ``Console.Write(A[i, j]+ ``" "``);``        ``Console.WriteLine();``    ``}``}``static` `void` `display(``float` `[,]A)``{``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``for` `(``int` `j = 0; j < N; j++)``            ``Console.Write(``"{0:F6} "``, A[i, j]);``        ``Console.WriteLine();``    ``}``}` `// Driver program``public` `static` `void` `Main(String[] args)``{``    ``int` `[,]A = { {5, -2, 2, 7},``                    ``{1, 0, 0, 3},``                    ``{-3, 1, 5, 0},``                    ``{3, -1, -9, 4}};` `    ``int` `[,]adj = ``new` `int``[N, N]; ``// To store adjoint of [,]A` `    ``float` `[,]inv = ``new` `float``[N, N]; ``// To store inverse of [,]A` `    ``Console.Write(``"Input matrix is :\n"``);``    ``display(A);` `    ``Console.Write(``"\nThe Adjoint is :\n"``);``    ``adjoint(A, adj);``    ``display(adj);` `    ``Console.Write(``"\nThe Inverse is :\n"``);``    ``if` `(inverse(A, inv))``        ``display(inv);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

```The Adjoint is :
-12 76 -60 -36
-56 208 -82 -58
4 4 -2 -10
4 4 20 12

The Inverse is :
-0.136364 0.863636 -0.681818 -0.409091
-0.636364 2.36364 -0.931818 -0.659091
0.0454545 0.0454545 -0.0227273 -0.113636
0.0454545 0.0454545 0.227273 0.136364```

Please refer https://www.geeksforgeeks.org/determinant-of-a-matrix/ for details of getCofactor() and determinant().
References:
https://www.geeksforgeeks.org/determinant-of-a-matrix/
https://en.wikipedia.org/wiki/Adjugate_matrix
This article is contributed by Ashutosh Kumar. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up