Sponsored
Sponsored
This approach traverses the matrix in a spiral order by systematically altering the direction when encountering the boundary or an already filled space. Start with the initial direction as 'right'. Change direction to 'down', 'left', 'up' as necessary when a boundary or an already filled cell is encountered.
1
2class ListNode:
3 def __init__(self, val=0, next=None):
4 self.val = val
5 self.next = next
6
7
8def spiralMatrix(m, n, head):
9 # Initializing matrix with -1
10 matrix = [[-1] * n for _ in range(m)]
11 dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)] # Directions: right, down, left, up
12 dir_idx, r, c = 0, 0, 0
13
14 # Traverse the linked list
15 node = head
16 for i in range(m * n):
17 if node:
18 matrix[r][c] = node.val # Fill the current cell with node value
19 node = node.next
20 else:
21 break
22
23 nr, nc = r + dirs[dir_idx][0], c + dirs[dir_idx][1]
24
25 # Check if next position is valid
26 if 0 <= nr < m and 0 <= nc < n and matrix[nr][nc] == -1:
27 r, c = nr, nc
28 else:
29 # Change direction
30 dir_idx = (dir_idx + 1) % 4
31 r, c = r + dirs[dir_idx][0], c + dirs[dir_idx][1]
32
33 return matrix
34
35# Example Usage
36head = ListNode(3, ListNode(0, ListNode(2, ListNode(6, ListNode(8, ListNode(1))))))
37print(spiralMatrix(3, 5, head))
38The provided Python code defines a function spiralMatrix that takes the dimensions m, n and the head of a linked list. It begins by creating a m x n matrix initialized with -1. The spiral movement is driven by the dirs array, which holds possible movement directions. For each direction change, we ensure it keeps within valid boundaries or filled cell conditions. This implementation guarantees that the matrix is filled in a proper spiral order, transitioning directions when necessary.
In this approach, we fill the matrix in a spiral order by completing one 'layer' of the spiral at a time. Start filling from the outer layer to the inner layers progressively until the entire matrix is filled. Each layer comprises four segments: top row, right column, bottom row, and left column.
1#include <stdio.h>
2#include
In C, this approach dynamically allocates a 2D array initialized to -1, representing the m x n matrix. The algorithm uses boundary pointers (top, bottom, left, right) dynamically shifting them inward based on filled cells from the linked list. It rotates through the spiral pattern filling each side of the current layer at a time, ensuring every cell is processed appropriately in relation to the remaining linked list values.