You are given the head of a doubly linked list, which contains nodes that have a next pointer and a previous pointer.
Return an integer array which contains the elements of the linked list in order.
Example 1:
Input:head = [1,2,3,4,3,2,1]
Output:[1,2,3,4,3,2,1]
Example 2:
Input:head = [2,2,2,2,2]
Output:[2,2,2,2,2]
Example 3:
Input:head = [3,2,3,2,3,2]
Output:[3,2,3,2,3,2]
Constraints:
The number of nodes in the given list is in the range [1, 50].
1 <= Node.val <= 50
Solutions
Solution 1: Direct Traversal
We can directly traverse the linked list, adding the values of the nodes to the answer array $\textit{ans}$ one by one.
After the traversal is complete, return the answer array $\textit{ans}$.
The time complexity is $O(n)$, where $n$ is the length of the linked list. Ignoring the space consumption of the answer array, the space complexity is $O(1)$.
1 2 3 4 5 6 7 8 91011121314151617
"""# Definition for a Node.class Node: def __init__(self, val, prev=None, next=None): self.val = val self.prev = prev self.next = next"""classSolution:deftoArray(self,root:"Optional[Node]")->List[int]:ans=[]whileroot:ans.append(root.val)root=root.nextreturnans
1 2 3 4 5 6 7 8 9101112131415161718
/*// Definition for a Node.class Node { public int val; public Node prev; public Node next;};*/classSolution{publicint[]toArray(Nodehead){List<Integer>ans=newArrayList<>();for(;head!=null;head=head.next){ans.add(head.val);}returnans.stream().mapToInt(i->i).toArray();}}
/** * Definition for a Node. * type Node struct { * Val int * Next *Node * Prev *Node * } */functoArray(head*Node)(ans[]int){for;head!=nil;head=head.Next{ans=append(ans,head.Val)}return}