Asymptotic Notations for Analysis of Algorithms

K'th element in spiral form of matrix

Last Updated : 23 Jul, 2025

Given a matrix of size n * m. You have to find the k^th element which will obtain while traversing the matrix spirally starting from the top-left corner of the matrix.

Examples:

Input: mat[][] = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ], k = 4
Output: 6
Explanation: Spiral traversal of matrix: {1, 2, 3, 6, 9, 8, 7, 4, 5}. Fourth element is 6.
Input: mat[][] = [ [1, 2], [3, 4] ], k = 2
Output: 2
Explanation: Spiral traversal of matrix: {1, 2, 4, 3}. Second element is 2.

[Naive Approach] - Constructing Spiral Matrix - O(n * m) Time and O(1) Space

The idea is to start traversing matrix in spiral form (Print Spiral Matrix) and start a counter count, initialized to 0. Whenever count gets equal to k, return that element
Keep a variable count = 0 to store the count.
Traverse the matrix in spiral from start to end.
Increase the count by 1 for every iteration.
If the count is equal to the given value of k print the element and break.

C++

#include <bits/stdc++.h>
using namespace std;

// finds kth element in spiral traversal
int findK(vector<vector<int>> &mat, int k) {
    int m = mat.size();
    int n = mat[0].size();

    int last = -1;

    int count = 0;

    // Initialize boundaries
    int top = 0, bottom = m - 1, left = 0, right = n - 1;

    // Iterate until all elements are traversed
    while (top <= bottom && left <= right && count < k) {

        // top row from left to right
        for (int i = left; i <= right && count < k; ++i) {
            last = mat[top][i];
            count++;
        }
        top++;

        // right column from top to bottom
        for (int i = top; i <= bottom && count < k; ++i) {
            last = mat[i][right];
            count++;
        }
        right--;

        // bottom row from right to left (if exists)
        if (top <= bottom) {
            for (int i = right; i >= left && count < k; --i) {
                last = mat[i][right];
                count++;
            }
            bottom--;
        }

        // left column from bottom to top (if exists)
        if (left <= right) {
            for (int i = bottom; i >= top && count < k; --i) {
                last = mat[i][right];
                count++;
            }
            left++;
        }
    }

    return last;
}

int main() {

    vector<vector<int>> mat = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    int k = 4;
    cout << findK(mat, k);
    return 0;
}

Java

import java.util.*;

class GfG {

    // finds kth element in spiral traversal
    static int findK(List<List<Integer>> mat, int k) {
        int m = mat.size();
        int n = mat.get(0).size();

        int last = -1;

        int count = 0;

        // Initialize boundaries
        int top = 0, bottom = m - 1, left = 0, right = n - 1;

        // Iterate until all elements are traversed
        while (top <= bottom && left <= right && count < k) {

            // top row from left to right
            for (int i = left; i <= right && count < k; ++i) {
                last = mat.get(top).get(i);
                count++;
            }
            top++;

            // right column from top to bottom
            for (int i = top; i <= bottom && count < k; ++i) {
                last = mat.get(i).get(right);
                count++;
            }
            right--;

            // bottom row from right to left (if exists)
            if (top <= bottom) {
                for (int i = right; i >= left && count < k; --i) {
                    last = mat.get(i).get(right);
                    count++;
                }
                bottom--;
            }

            // left column from bottom to top (if exists)
            if (left <= right) {
                for (int i = bottom; i >= top && count < k; --i) {
                    last = mat.get(i).get(right);
                    count++;
                }
                left++;
            }
        }

        return last;
    }

    public static void main(String[] args) {
        List<List<Integer>> mat = Arrays.asList(
            Arrays.asList(1, 2, 3),
            Arrays.asList(4, 5, 6),
            Arrays.asList(7, 8, 9)
        );
        int k = 4;
        System.out.println(findK(mat, k));
    }
}

Python

# finds kth element in spiral traversal
def findK(mat, k):
    m = len(mat)
    n = len(mat[0])

    last = -1

    count = 0

    # Initialize boundaries
    top, bottom, left, right = 0, m - 1, 0, n - 1

    # Iterate until all elements are traversed
    while top <= bottom and left <= right and count < k:

        # top row from left to right
        for i in range(left, right + 1):
            if count >= k:
                break
            last = mat[top][i]
            count += 1
        top += 1

        # right column from top to bottom
        for i in range(top, bottom + 1):
            if count >= k:
                break
            last = mat[i][right]
            count += 1
        right -= 1

        # bottom row from right to left (if exists)
        if top <= bottom:
            for i in range(right, left - 1, -1):
                if count >= k:
                    break
                last = mat[i][right]
                count += 1
            bottom -= 1

        # left column from bottom to top (if exists)
        if left <= right:
            for i in range(bottom, top - 1, -1):
                if count >= k:
                    break
                last = mat[i][right]
                count += 1
            left += 1

    return last


mat = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
k = 4
print(findK(mat, k))

using System;
using System.Collections.Generic;

class GfG {

    // finds kth element in spiral traversal
    static int findK(List<List<int>> mat, int k) {
        int m = mat.Count;
        int n = mat[0].Count;

        int last = -1;

        int count = 0;

        // Initialize boundaries
        int top = 0, bottom = m - 1, left = 0, right = n - 1;

        // Iterate until all elements are traversed
        while (top <= bottom && left <= right && count < k) {

            // top row from left to right
            for (int i = left; i <= right && count < k; ++i) {
                last = mat[top][i];
                count++;
            }
            top++;

            // right column from top to bottom
            for (int i = top; i <= bottom && count < k; ++i) {
                last = mat[i][right];
                count++;
            }
            right--;

            // bottom row from right to left (if exists)
            if (top <= bottom) {
                for (int i = right; i >= left && count < k; --i) {
                    last = mat[i][right];
                    count++;
                }
                bottom--;
            }

            // left column from bottom to top (if exists)
            if (left <= right) {
                for (int i = bottom; i >= top && count < k; --i) {
                    last = mat[i][right];
                    count++;
                }
                left++;
            }
        }

        return last;
    }

    public static void Main() {
        List<List<int>> mat = new List<List<int>> {
            new List<int> {1, 2, 3},
            new List<int> {4, 5, 6},
            new List<int> {7, 8, 9}
        };
        int k = 4;
        Console.WriteLine(findK(mat, k));
    }
}

JavaScript

// finds kth element in spiral traversal
function findK(mat, k) {
    let m = mat.length;
    let n = mat[0].length;

    let last = -1;

    let count = 0;

    // Initialize boundaries
    let top = 0, bottom = m - 1, left = 0, right = n - 1;

    // Iterate until all elements are traversed
    while (top <= bottom && left <= right && count < k) {

        // top row from left to right
        for (let i = left; i <= right && count < k; ++i) {
            last = mat[top][i];
            count++;
        }
        top++;

        // right column from top to bottom
        for (let i = top; i <= bottom && count < k; ++i) {
            last = mat[i][right];
            count++;
        }
        right--;

        // bottom row from right to left (if exists)
        if (top <= bottom) {
            for (let i = right; i >= left && count < k; --i) {
                last = mat[i][right];
                count++;
            }
            bottom--;
        }

        // left column from bottom to top (if exists)
        if (left <= right) {
            for (let i = bottom; i >= top && count < k; --i) {
                last = mat[i][right];
                count++;
            }
            left++;
        }
    }

    return last;
}

let mat = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
let k = 4;
console.log(findK(mat, k));

Output

[Expected Approach] - O(max(n, m)) Time and O(max(n, m)) Space

The idea is to traverse the array in spiral order, a loop is used to traverse the sides. So if it can be found out that the kth element is in the given side then the kth element can be found out in constant time. This can be done recursively as well as iteratively.

Follow the below given steps:

Traverse the matrix in form of spiral or cycles.
So a cycle can be divided into 4 parts, so if the cycle is of size m X n.
1. Element is in first row, i.e k <= m.
2. Element is in last column, i.e k <= (m+n-1).
3. Element is in last row, i.e. k <= (m+n-1+m-1).
4. Element is in first column, i.e k <= (m+n-1+m-1+n-2)
If any of the above conditions meet then the kth element can be found is constant time.
Else remove the cycle from the array and recursively call the function.

C++

#include <bits/stdc++.h>
using namespace std;

int findKUtil(vector<vector<int>> &mat, int i,
    int j, int n, int m, int k) {

    if (n < 1 || m < 1)
        return -1;

    // If element is in outermost ring
    // Element is in first row
    if (k <= m)
        return mat[i][j + k - 1];

    // Element is in last column
    if (k <= (m + n - 1))
        return mat[i + (k - m)][j + m - 1];

    // Element is in last row
    if (k <= (m + n - 1 + m - 1))
        return mat[i + n - 1][j + m - 1 - (k - (m + n - 1))];

    // Element is in first column
    if (k <= (m + n - 1 + m - 1 + n - 2))
        return mat[i + n - 1 - (k - (m + n - 1 + m - 1))][j];

    return findKUtil(mat, i + 1, j + 1, n - 2, m - 2, k - (2 * n + 2 * m - 4));
}

int findK(vector<vector<int>> &mat, int k) {
    int n = mat.size();
    int m = mat[0].size();
    return findKUtil(mat, 0, 0, n, m, k);
}

int main() {
    vector<vector<int>> mat = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    int k = 4;
    cout << findK(mat, k);
    return 0;
}

Java

import java.util.*;

class GfG {

    static int findKUtil(List<List<Integer>> mat, int i,
        int j, int n, int m, int k) {

        if (n < 1 || m < 1)
            return -1;

        // If element is in outermost ring
        // Element is in first row
        if (k <= m)
            return mat.get(i + 0).get(j + k - 1);

        // Element is in last column
        if (k <= (m + n - 1))
            return mat.get(i + (k - m)).get(j + m - 1);

        // Element is in last row
        if (k <= (m + n - 1 + m - 1))
            return mat.get(i + n - 1).get(j + 
                m - 1 - (k - (m + n - 1)));

        // Element is in first column
        if (k <= (m + n - 1 + m - 1 + n - 2))
            return mat.get(i + n - 1 - 
                (k - (m + n - 1 + m - 1))).get(j + 0);

        return findKUtil(mat, i + 1, j + 1, n - 2, 
            m - 2, k - (2 * n + 2 * m - 4));
    }

    static int findK(List<List<Integer>> mat, int k) {
        int n = mat.size();
        int m = mat.get(0).size();
        return findKUtil(mat, 0, 0, n, m, k);
    }

    public static void main(String[] args) {

        List<List<Integer>> mat = Arrays.asList(
            Arrays.asList(1, 2, 3),
            Arrays.asList(4, 5, 6),
            Arrays.asList(7, 8, 9)
        );
        int k = 4;
        System.out.println(findK(mat, k));
    }
}

Python

def findKUtil(mat, i, j, n, m, k):

    if n < 1 or m < 1:
        return -1

    # If element is in outermost ring
    # Element is in first row
    if k <= m:
        return mat[i + 0][j + k - 1]

    # Element is in last column
    if k <= (m + n - 1):
        return mat[i + (k - m)][j + m - 1]

    # Element is in last row
    if k <= (m + n - 1 + m - 1):
        return mat[i + n - 1][j + 
            m - 1 - (k - (m + n - 1))]

    # Element is in first column
    if k <= (m + n - 1 + m - 1 + n - 2):
        return mat[i + n - 1 - 
            (k - (m + n - 1 + m - 1))][j + 0]

    return findKUtil(mat, i + 1, j + 1, n - 2, 
        m - 2, k - (2 * n + 2 * m - 4))

def findK(mat, k):
    n = len(mat)
    m = len(mat[0])
    return findKUtil(mat, 0, 0, n, m, k)

mat = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
k = 4
print(findK(mat, k))

using System;
using System.Collections.Generic;

class GfG {

    static int findKUtil(List<List<int>> mat, int i,
        int j, int n, int m, int k) {

        if (n < 1 || m < 1)
            return -1;

        // If element is in outermost ring
        // Element is in first row
        if (k <= m)
            return mat[i][j + k - 1];

        // Element is in last column
        if (k <= (m + n - 1))
            return mat[i + (k - m)][j + m - 1];

        // Element is in last row
        if (k <= (m + n - 1 + m - 1))
            return mat[i + n - 1][j + m - 1 - (k - (m + n - 1))];

        // Element is in first column
        if (k <= (m + n - 1 + m - 1 + n - 2))
            return mat[i + n - 1 - (k - (m + n - 1 + m - 1))][j];

        return findKUtil(mat, i + 1, j + 1, n - 2, 
            m - 2, k - (2 * n + 2 * m - 4));
    }

    static int findK(List<List<int>> mat, int k) {
        int n = mat.Count;
        int m = mat[0].Count;
        return findKUtil(mat, 0, 0, n, m, k);
    }

    public static void Main() {
        List<List<int>> mat = new List<List<int>> {
            new List<int> {1, 2, 3},
            new List<int> {4, 5, 6},
            new List<int> {7, 8, 9}
        };
        int k = 4;
        Console.WriteLine(findK(mat, k)); 
    }
}

JavaScript

function findKUtil(mat, i, j, n, m, k) {
    if (n < 1 || m < 1) return -1;

    // If element is in outermost ring
    // Element is in first row
    if (k <= m) return mat[i][j + k - 1];

    // Element is in last column
    if (k <= m + n - 1) return mat[i + (k - m)][j + m - 1];

    // Element is in last row
    if (k <= m + n - 1 + m - 1) 
        return mat[i + n - 1][j + m - 1 - (k - (m + n - 1))];

    // Element is in first column
    if (k <= m + n - 1 + m - 1 + n - 2) 
        return mat[i + n - 1 - (k - (m + n - 1 + m - 1))][j];

    return findKUtil(mat, i + 1, j + 1, n - 2, m - 2, k - (2 * n + 2 * m - 4));
}

function findK(mat, k) {
    let n = mat.length;
    let m = mat[0].length;
    return findKUtil(mat, 0, 0, n, m, k);
}

// Example usage
let mat = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];
let k = 4;
console.log(findK(mat, k));

Output

Asymptotic Notations for Analysis of Algorithms

kartik

Improve

Article Tags :

Practice Tags :

K'th element in spiral form of matrix

[Naive Approach] - Constructing Spiral Matrix - O(n * m) Time and O(1) Space

[Expected Approach] - O(max(n, m)) Time and O(max(n, m)) Space

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?