+var eleC = eleB.nextSibling //
+eleC.nextSibling // null
+```
+
+There is also a similar `previousSibling` property, which returns the previous node. Also, there are element-only variant for all these properties like `firstElementChild`, `nextElementSibling`, etc.
+
+
+
+:::note Easier traversal
+
+This allows accessing the DOM tree in [Left-child right-sibling](https://en.wikipedia.org/wiki/Left-child_right-sibling_binary_tree) (LCRS) form, which is more memory efficient for usual traversal.
+
+#### How do you implement **dom traversal**?
+
+The typical approach is to use a queue, push all children to the queue, pop them one-by-one and visit them. This requires **extra memory** because of the queue data structure which holds all the *next items to visit*.
+But with the LCRS form, you always have access to the next item **without using extra space**. If current element has child, visit `.firstChild`. Then visit next node using `.nextSibling`.
+
+```js
+// 1. Typical approach
+var queue = [root]
+while (queue.length > 0) {
+ const item = queue.shift();
+ console.log(item);
+ if (item.hasChildNodes()) {
+ queue = Array.from(item.childNodes).concat(queue)
+ }
+}
+
+// 2. LCRS approach
+function traverse(item) {
+ if (item === null) {
+ return;
+ }
+
+ console.log(item);
+ traverse(item.firstChild)
+ traverse(item.nextSibling)
+}
+traverse(root.firstChild)
+```
+:::
+
+
+
+