New Question added

Author: Prabhat565

Spiral-Matrix/Explanation-of-Solution.md

@@ -0,0 +1,65 @@
+# Spiral Order Traversal of a Matrix
+
+## Introduction
+
+This repository contains a C++ solution to the problem of traversing a matrix in a spiral order. Given a 2D matrix, the objective is to traverse its elements in a spiral pattern, starting from the top-left corner and moving clockwise until all elements are visited. This algorithm is implemented using a straightforward iterative approach.
+
+## Approach
+
+1. **Initialize Variables**:
+
+   - Begin by initializing an empty vector `ans` to store the elements of the matrix in spiral order.
+   - Obtain the dimensions of the input matrix: the number of rows `m` and the number of columns `n`.
+   - Calculate the total number of elements `total_elements` in the matrix as the product of `m` and `n`.
+
+2. **Define Boundaries**:
+
+   - Define four variables to track the boundaries of the traversal: `startingRow`, `startingCol`, `endingRow`, and `endingCol`.
+   - Initially, set `startingRow` and `startingCol` to 0, representing the starting row and column indices of the traversal.
+   - Set `endingRow` to `m-1` and `endingCol` to `n-1`, representing the ending row and column indices of the traversal respectively.
+
+3. **Traverse in Spiral Order**:
+
+   - Utilize a `while` loop to continue traversing until all elements are visited.
+   - Inside the loop, traverse the four sides of the matrix in clockwise order:
+     - Traverse the top row from `startingCol` to `endingCol`, adding each element to `ans`.
+     - Increment `startingRow` to move to the next row.
+     - Traverse the rightmost column from `startingRow` to `endingRow`, adding each element to `ans`.
+     - Decrement `endingCol` to move to the previous column.
+     - Traverse the bottom row from `endingCol` to `startingCol`, adding each element to `ans`.
+     - Decrement `endingRow` to move to the previous row.
+     - Traverse the leftmost column from `endingRow` to `startingRow`, adding each element to `ans`.
+     - Increment `startingCol` to move to the next column.
+   - Increment the `count` variable after adding each element to `ans`.
+
+4. **Return Result**:
+   - Finally, return the vector `ans` containing the spiral order traversal of the matrix.
+
+#
+
+# Time and Space Complexity Analysis
+
+## Time Complexity
+
+- **Traversal**: The algorithm traverses each element of the matrix exactly once in a clockwise spiral order.
+  - The number of elements in the matrix is `m x n`.
+  - Therefore, the time complexity of the traversal is O(m x n).
+
+## Space Complexity
+
+- **Output Space**: The space complexity is primarily determined by the space required to store the output vector `ans`.
+  - The size of the output vector `ans` is equal to the number of elements in the matrix, which is `m x n`.
+  - Therefore, the space complexity for storing the output vector is O(m x n).
+- **Additional Space**: The algorithm uses a constant amount of additional space for variables like `startingRow`, `startingCol`, `endingRow`, `endingCol`, `count`, and loop variables.
+  - Hence, the additional space complexity is O(1).
+
+### Summary
+
+- **Time Complexity**: O(m x n)
+- **Space Complexity**: O(m x n)
+
+The time complexity is determined by the number of elements in the matrix, as the algorithm visits each element once. The space complexity is mainly influenced by the size of the output vector, which stores the elements of the matrix in spiral order. Overall, the algorithm has a linear time complexity relative to the input size and a space complexity proportional to the size of the matrix.
+
+## Conclusion
+
+This approach ensures that all elements of the matrix are traversed exactly once in a spiral order, starting from the top-left corner and moving clockwise until all elements are visited. The implementation is concise and efficient, providing a solution to the spiral order traversal problem.

Spiral-Matrix/Question.md

@@ -0,0 +1,29 @@
+<h1> <a href = "https://leetcode.com/problems/spiral-matrix/description/" target = "_blank" >54. Spiral Matrix</a></h1>
+
+<h3>Given an m x n matrix, return all elements of the matrix in spiral order.</h3>
+
+Example1:
+
+![alt text](image.png)
+
+<strong>Input:</strong> matrix = [[1,2,3],[4,5,6],[7,8,9]]
+<br/>
+<strong>Output:</strong> [1,2,3,6,9,8,7,4,5]
+
+Example2:
+
+![alt text](image-1.png)
+
+<strong>Input: </strong>matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+<br/>
+
+<strong>Output:</strong> [1,2,3,4,8,12,11,10,9,5,6,7]
+
+<strong>Constraints:</strong>
+
+<ul>
+<li>m == matrix.length</li>
+<li>n == matrix[i].length   </li>
+<li>1 <= m, n <= 10</li>
+<li>-100 <= matrix[i][j] <= 100</li>
+</ul>

Spiral-Matrix/image-1.png

@@ -0,0 +1,58 @@
+class Solution
+{
+public:
+    vector<int> spiralOrder(vector<vector<int>> &matrix)
+    {
+
+        vector<int> ans;
+        int m = matrix.size();
+        int n = matrix[0].size();
+        int total_elements = m * n;
+
+        int startingRow = 0;
+        int startingCol = 0;
+        int endingRow = (m - 1);
+        int endingCol = (n - 1);
+
+        int count = 0;
+
+        while (count < total_elements)
+        {
+
+            // print startingRow:
+            for (int i = startingCol; i <= endingCol && count < total_elements; i++)
+            {
+                ans.push_back(matrix[startingRow][i]);
+                count++;
+            }
+
+            startingRow++;
+
+            // print endingCol:
+            for (int i = startingRow; i <= endingRow && count < total_elements; i++)
+            {
+                ans.push_back(matrix[i][endingCol]);
+                count++;
+            }
+            endingCol--;
+
+            // print endingRow:
+            for (int i = endingCol; i >= startingCol && count < total_elements; i--)
+            {
+                ans.push_back(matrix[endingRow][i]);
+                count++;
+            }
+            endingRow--;
+
+            // print startingCol:
+
+            for (int i = endingRow; i >= startingRow && count < total_elements; i--)
+            {
+                ans.push_back(matrix[i][startingCol]);
+                count++;
+            }
+            startingCol++;
+        }
+        return ans;
+    }
+};