# Binary Tree Level Order Traversal

Given the root of a binary tree, return *the level order traversal of its nodes' values*. (i.e., from left to right, level by level).

```
var levelOrder = function(root) {
// If root is null return an empty array
if(!root) return []
const queue = [root] // initialize the queue with root
const levels = [] // declare output array
while(queue.length !== 0){
const queueLength = queue.length // Get the length prior to dequeueing
const currLevel = [] // Declare this level
// loop through to exhaust all options and only to include nodes at currLevel
for(let i = 0; i < queueLength; i++){
// Get next node
const current = queue.shift()
if(current.left){
queue.push(current.left)
}
if(current.right){
queue.push(current.right)
}
// After we add left and right for current, we add to currLevel
currLevel.push(current.val)
}
// Level has been finished. Push into output array
levels.push(currLevel)
}
return levels
}
```

## Related Problems

You are given the heads of two sorted linked lists list1 and list2.

Merge the two lists into one **sorted** list. The list should be made by splicing together the nodes of the first two lists.

Return *the head of the merged linked list*.

Given the root of a binary tree, flatten the tree into a "linked list":

The "linked list" should use the same TreeNode class where the right child pointer points to the next node in the list and the left child pointer is always null.

The "linked list" should be in the same order as a pre-order traversal of the binary tree.

A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null. Return the head of a deep copy of the list, ie all new nodes and both the node.next and node.random pointers point to new nodes.

Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.

A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node's descendants. The tree tree could also be considered as a subtree of itself.