# DeterminantOfMatrix

### 4. Determinant of a 2D matrix

Problem:

Given a 2D matrix, Determine it’s Determinant.

Solution:

This implementation is done using C#.NET. Rectangular Matrix is declared using int[,] syntax.
``` public static long EvaluateDeterminant(int[,] matrix) { long determinant = 0;```

``` if (matrix == null || matrix.GetUpperBound(0) != matrix.GetUpperBound(1)) { Console.WriteLine("Non-square matrix can't have a determinant"); return determinant; } int row_UB = matrix.GetUpperBound(0); determinant = Determinant(matrix, row_UB + 1); return determinant; } private static long Determinant(int[,] matrix, int size) { long determinant = 0; if (size == 1) // 1x1 MAtrix { determinant = matrix[0, 0]; } else if (size == 2) // 2x2 MAtrix { determinant = matrix[0, 0] * matrix[1, 1] - matrix[0, 1] * matrix[1, 0]; // can hash this multiplication } else { int multiplier = 1; for (int i = 0; i < size; i++) { multiplier = (i % 2 == 0) ? 1 : -1; determinant += multiplier * matrix[0, i] * Determinant(GetMinor(matrix, size, 0, i), size - 1); } } return determinant; } /// <summary> /// Gets the Minor of a Square Matrix /// </summary> /// <param name="matrix"></param> /// <param name="size"></param> /// <param name="rowIndex"></param> /// <param name="colIndex"></param> /// <returns></returns> /// <remarks> /// If function has to be Public, Certain checks on rowIndex, ColIndex should be made and size need not to be passed /// </remarks> private static int[,] GetMinor(int[,] matrix, int size, int rowIndex, int colIndex) { int minorSize = size - 1; int[,] minor = new int[minorSize, minorSize]; for (int i = 0; i < rowIndex; i++) { for (int j = 0; j < colIndex; j++) { minor[i, j] = matrix[i, j]; } } for (int i = rowIndex + 1; i < size; i++) { for (int j = 0; j < colIndex; j++) { minor[i - 1, j] = matrix[i, j]; } } for (int i = 0; i < rowIndex; i++) { for (int j = colIndex + 1; j < size; j++) { minor[i, j - 1] = matrix[i, j]; } } for (int i = rowIndex + 1; i < size; i++) { for (int j = colIndex + 1; j < size; j++) { minor[i - 1, j - 1] = matrix[i, j]; } } ```

```return minor; } ```

# Is Binary Tree a Binary Search Tree?

### 2. Is tree BinarySearchTree?

Problem:

Given a binary tree, determine if it is a Binary Search Tree (BST) or not?

Definition:

What is BST?

BST is a binary tree in which value of root is always greater than the value of every node on it’s left and is less than or equal to the value of every node on it’s right.

Solution:

This implementation is done using C#.NET.
``` class BinaryTree { public BinaryTreeNode Root { get; set; }```

``` public bool IsBinarySearchTree() { Console.WriteLine("Checking if Tree is BST or not:"); if (this.Root != null) { int value = 0; return this.Check(this.Root, ref value); } return true; } private bool Check(BinaryTreeNode currentNode, ref int lastNodeValue) { bool isTreeBST = false, leftTreePresent, rightTreePrsent ; leftTreePresent = currentNode.LeftTree == null ? false : true; rightTreePrsent = currentNode.RightTree == null ? false : true; if (leftTreePresent) { isTreeBST = this.Check(currentNode.LeftTree, ref lastNodeValue); } else { isTreeBST = true; } if (isTreeBST && currentNode.Info > lastNodeValue) { Console.WriteLine("Processing Node With Value:{0}", currentNode.Info); lastNodeValue = currentNode.Info; isTreeBST = true; } else { isTreeBST = false; } if (isTreeBST && rightTreePrsent) { isTreeBST = this.Check(currentNode.RightTree, ref lastNodeValue); } return isTreeBST; } } ```

```class BinaryTreeNode { public BinaryTreeNode LeftTree { get; set; } public BinaryTreeNode RightTree { get; set; } public int Info { get; set; } } ```

Problem with the above code is that if a tree has Duplicate Values, it will fail.

The approach could be then to pass the Range in terms of Minimum and the Maximum Value of a particular node. Since we are traversing down from Root and knowing the min and max value of a root, we can appropriately limit the range and pass on to Left and Right Trees.

``` private bool Check(BinaryTreeNode node, int min, int max) { if (node == null) return true;```

``` ```

```if (node.Info max) return false; else { return this.Check(node.LeftTree, min, node.Info) && this.Check(node.RightTree, node.Info + 1, max); } } ```

# SpiralTraversalOfMatrix

### 1. Spiral Traversal of a 2D matrix

Problem:

Given a 2D matrix, traverse all it’s elements in a spiral form.
Referring the below matrix as an input (Red line shows a spiral traversal),

output should be: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

Solution:

This implementation is done using C#.NET. Rectangular Matrix is declared using int[,] syntax.

```public List<Integer> spiralOrder(int[][] matrix) {
List<Integer> res = new ArrayList();

int rowStart = 0, rowEnd = matrix.length - 1, colStart = 0, colEnd = matrix[0].length - 1;

while (rowStart <= rowEnd && colStart <= colEnd) {
for(int i = colStart; i <= colEnd; i++) {
}
rowStart++;

if (rowStart > rowEnd) {
break;
}
for (int i = rowStart; i <= rowEnd; i++) {
}
colEnd--;

if (colStart > colEnd) {
break;
}
for (int i = colEnd; i >= colStart; i--) {