You are given an arbitrarynode from 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,5], node = 5
Output:[1,2,3,4,5]
Example 2:
Input:head = [4,5,6,7,8], node = 8
Output:[4,5,6,7,8]
Constraints:
The number of nodes in the given list is in the range [1, 500].
1 <= Node.val <= 1000
All nodes have unique Node.val.
Solutions
Solution 1: Traverse the Linked List
We can start from the given node and traverse the linked list backward until we reach the head node. Then, we traverse the linked list forward from the head node, adding the values of the nodes we encounter to the answer array.
After the traversal is complete, return the answer array.
The time complexity is $O(n)$, where $n$ is the number of nodes in 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 910111213141516171819
"""# 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,node:"Optional[Node]")->List[int]:whilenode.prev:node=node.prevans=[]whilenode:ans.append(node.val)node=node.nextreturnans
1 2 3 4 5 6 7 8 9101112131415161718192021
/*// Definition for a Node.class Node { public int val; public Node prev; public Node next;};*/classSolution{publicint[]toArray(Nodenode){while(node!=null&&node.prev!=null){node=node.prev;}varans=newArrayList<Integer>();for(;node!=null;node=node.next){ans.add(node.val);}returnans.stream().mapToInt(i->i).toArray();}}
/** * Definition for a Node. * type Node struct { * Val int * Next *Node * Prev *Node * } */functoArray(node*Node)(ans[]int){fornode!=nil&&node.Prev!=nil{node=node.Prev}for;node!=nil;node=node.Next{ans=append(ans,node.Val)}return}