Merge pull request #1525 from Samuel-Hinchliffe/main

Create: 203. Remove Linked List Elements, 94-Binary-Tree-Inorder-Traversal, 112-Path-Sum, Trim-a-Binary-Search-Tree., 152-Maximum-Product-Subarray,

Author: Ahmad-A0

javascript/203-Remove-Linked-List-Elements.js

@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ * this.val  = (val===undefined ? 0 : val)
+ * this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} val
+ * @return {ListNode}
+ */
+var removeElements = function (head, val) {
+    
+    let sentinel_node = new ListNode(0, head);
+    let slow_pointer = sentinel_node;
+    let fast_pointer = null;
+
+    while (slow_pointer) {
+        // get next legible node
+        fast_pointer = slow_pointer.next;
+        while (fast_pointer && fast_pointer.val === val) {
+            fast_pointer = fast_pointer.next;
+        }
+
+        // Set next node to the legible node
+        slow_pointer.next = fast_pointer;
+        slow_pointer = slow_pointer.next;
+    }
+
+    return sentinel_node.next;
+};

javascript/669-Trim-a-Binary-Search-Tree.js

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} low
+ * @param {number} high
+ * @return {TreeNode}
+ */
+var trimBST = function (root, low, high) {
+
+	if (!root) {
+		return null;
+	}
+
+	if (root.val < low) {
+		return trimBST(root.right, low, high);
+	}
+
+	if (root.val > high) {
+		return trimBST(root.left, low, high);
+	}
+
+	root.left  = trimBST(root.left, low, high);
+	root.right = trimBST(root.right, low, high);
+
+	return root;
+};

javascript/94-Binary-Tree-Inorder-Traversal.js

@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ * this.val   = (val===undefined ? 0 : val)
+ * this.left  = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+ var inorderTraversal = function (root, list = []) {
+
+    if (!root) return [];
+    
+    inorderTraversal(root.left, list);
+    list.push(root.val)
+    inorderTraversal(root.right, list);
+    
+    return list
+};

ruby/152-Maximum-Product-Subarray.rb

@@ -0,0 +1,17 @@
+# @param {Integer[]} nums
+# @return {Integer}
+def max_product(nums)
+    
+    @largest = -Float::INFINITY
+    @min = 1
+    @max = 1
+    
+    for num in nums do
+        @temp = @max * num
+        @max = [num * @max, num * @min, num].max
+        @min = [num * @min, @temp, num].min
+        @largest = [@max, @largest, num].max
+    end
+    
+    return @largest
+end

typescript/203-Remove-Linked-List-Elements.ts

@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function removeElements(head: ListNode | null, val: number): ListNode | null {
+    
+    let sentinel_node : ListNode = new ListNode(0, head);
+    let slow_pointer  : ListNode | null = sentinel_node;
+    let fast_pointer  : ListNode | null = null;
+
+    while (slow_pointer) {
+                        
+        // get next legible node
+        fast_pointer = slow_pointer.next;
+        while (fast_pointer && fast_pointer.val === val) {
+            fast_pointer = fast_pointer.next;
+        }
+
+        // Set next node to the legible node
+        slow_pointer.next = fast_pointer;
+        slow_pointer      = slow_pointer.next;
+    }
+
+    return sentinel_node.next;
+};

typescript/669-Trim-a-Binary-Search-Tree.ts

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function trimBST(root: TreeNode | null, low: number, high: number): TreeNode | null {
+
+    if (!root) {
+		return null;
+	}
+
+	if (root.val < low) {
+		return trimBST(root.right, low, high);
+	}
+
+	if (root.val > high) {
+		return trimBST(root.left, low, high);
+	}
+
+	root.left  = trimBST(root.left, low, high);
+	root.right = trimBST(root.right, low, high);
+
+	return root;
+};

typescript/94-Binary-Tree-Inorder-Traversal.ts

@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+ function inorderTraversal(root: TreeNode | null, list: Array<number> = [] ): number[] {
+    
+    if (!root) return [];
+    
+    inorderTraversal(root.left, list);
+    list.push(root.val)
+    inorderTraversal(root.right, list);
+    
+    return list
+};