trees and graphs

Author: Narahari-Sundaragopalan

exercises/leetcode/populateNextRightPointer-II.js

@@ -0,0 +1,65 @@
+/**
+ * Given a binary tree
+
+struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}
+Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
+
+Initially, all next pointers are set to NULL.
+
+ 
+
+Follow up:
+
+You may only use constant extra space.
+Recursive approach is fine, you may assume implicit stack space does not count as extra space for this problem.
+ */
+/**
+ * // Definition for a Node.
+ * function Node(val, left, right, next) {
+ *    this.val = val === undefined ? null : val;
+ *    this.left = left === undefined ? null : left;
+ *    this.right = right === undefined ? null : right;
+ *    this.next = next === undefined ? null : next;
+ * };
+ */
+let prev, leftMost;
+
+const processChild = childNode => {
+	if (childNode !== null) {
+		if (prev !== null) {
+			// If a node exists at this level already, assign the childNode as next of prev
+			prev.next = childNode;
+		} else {
+			// else this is the first node on this level
+			leftMost = childNode;
+		}
+		prev = childNode;
+	}
+}
+const connect = root => {
+	if (root === null) {
+		return root;
+	}
+	leftMost = root;
+
+	while (leftMost !== null) {
+		// No nodes before this at this level
+		prev = null;
+		// Node to keep track of the current level in Tree
+		let curr = leftMost;
+		// Now that we have saved the current node, reassign the leftMost to null
+		leftMost = null;
+
+		while (curr !== null) {
+			processChild(curr.left);
+			processChild(curr.right);
+			curr = curr.next;
+		}
+	}
+	return root;
+}

exercises/leetcode/removeDuplicates.js

@@ -0,0 +1,36 @@
+/**
+ * Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.
+
+Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
+
+Example 1:
+
+Given nums = [1,1,2],
+
+Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
+
+It doesn't matter what you leave beyond the returned length.
+Example 2:
+
+Given nums = [0,0,1,1,1,2,2,3,3,4],
+
+Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.
+
+It doesn't matter what values are set beyond the returned length.
+ */
+
+const removeDuplicates = nums => {
+	if (nums.length === 0) {
+		return 0;
+	}
+
+	let i = 0;
+	for (let j = 1; j < nums.length; j++) {
+		if (nums[i] !== nums[j]) {
+			i++;
+			nums[i] = nums[j];
+		}
+	}
+
+	return i + 1;
+}