Skip to content

Commit 2275130

Browse files
aakhtar3aakhtar3
committed
refactor: js - tree
1 parent 9897759 commit 2275130

16 files changed

+879
-324
lines changed

Diff for: ‎javascript/100-Same-Tree.js

+64-11
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,71 @@
11
/**
2-
* Definition for a binary tree node.
3-
* function TreeNode(val, left, right) {
4-
* this.val = (val===undefined ? 0 : val)
5-
* this.left = (left===undefined ? null : left)
6-
* this.right = (right===undefined ? null : right)
7-
* }
2+
* https://leetcode.com/problems/same-tree/
3+
* TIme O(N) | Space O(H)
4+
* @param {TreeNode} p
5+
* @param {TreeNode} q
6+
* @return {boolean}
87
*/
8+
var isSameTree = function(p, q) {
9+
const isBaseCase = !(p || q);
10+
if (isBaseCase) return true;
11+
12+
const isBalanced = (p && q);
13+
if (!isBalanced) return false;
14+
15+
const isSame = p.val === q.val;
16+
if (!isSame) return false;
17+
18+
return dfs(p, q);
19+
};
20+
21+
const dfs = (p, q) => {
22+
const left = isSameTree(p.left, q.left);
23+
const right = isSameTree(p.right, q.right);
24+
25+
return left && right;
26+
}
27+
928
/**
29+
* https://leetcode.com/problems/same-tree/
30+
* TIme O(N) | Space O(W)
1031
* @param {TreeNode} p
1132
* @param {TreeNode} q
1233
* @return {boolean}
1334
*/
14-
var isSameTree = function (p, q) {
15-
if (!p && !q) return true;
16-
if (!p || !q || p.val !== q.val) return false;
17-
return isSameTree(p.right, q.right) && isSameTree(p.left, q.left);
18-
};
35+
var isSameTree = function(p, q) {
36+
if (isSameNode(p, q)) return true;
37+
38+
return bfs([[ p, q ]]);
39+
}
40+
41+
const bfs = (queue) => {
42+
while (queue.length) {
43+
for (let i = (queue.length - 1); 0 <= i; i--) {
44+
const [ p, q ] = queue.shift();
45+
46+
if (!isSame(p, q)) return false;
47+
48+
if (p.left) queue.push([ p.left, q.left ]);
49+
if (p.right) queue.push([ p.right, q.right ]);
50+
}
51+
}
52+
53+
return true;
54+
}
55+
56+
const isSameNode = (p, q) => {
57+
const isBaseCase = !(p || q);
58+
if (isBaseCase) return true;
59+
60+
const isBalanced = (p && q);
61+
if (!isBalanced) return false;
62+
63+
const isSame = p.val === q.val;
64+
if (!isSame) return false;
65+
66+
return true;
67+
}
68+
69+
const isSame = (p, q) => isSameNode(p, q)
70+
&& isSameNode(p.left, q.left)
71+
&& isSameNode(p.right, q.right);

Diff for: ‎javascript/102-Binary-Tree-Level-Order-Traversal.js

+46-22
Original file line numberDiff line numberDiff line change
@@ -1,32 +1,56 @@
11
/**
2-
* Definition for a binary tree node.
3-
* function TreeNode(val, left, right) {
4-
* this.val = (val===undefined ? 0 : val)
5-
* this.left = (left===undefined ? null : left)
6-
* this.right = (right===undefined ? null : right)
7-
* }
8-
*/
9-
/**
2+
* https://leetcode.com/problems/binary-tree-level-order-traversal/
3+
* Time O(N) | Space O(W)
104
* @param {TreeNode} root
115
* @return {number[][]}
126
*/
13-
var levelOrder = function (root) {
14-
if (!root) return [];
7+
var levelOrder = function(root) {
8+
const isBaseCase = root === null;
9+
if (isBaseCase) return [];
1510

16-
const result = [];
17-
const queue = [root];
11+
return bfs([ root ]);
12+
};
1813

14+
const bfs = (queue, levels = []) => {
1915
while (queue.length) {
20-
const numNodes = queue.length;
21-
const temp = [];
22-
for (let i = 0; i < numNodes; i++) {
23-
const subtree = queue.shift();
24-
temp.push(subtree.val);
25-
if (subtree.left !== null) queue.push(subtree.left);
26-
if (subtree.right !== null) queue.push(subtree.right);
16+
const level = [];
17+
18+
for (let i = (queue.length - 1); 0 <= i; i--) {
19+
const node = queue.shift();
20+
21+
if (node.left) queue.push(node.left);
22+
if (node.right) queue.push(node.right);
23+
24+
level.push(node.val);
2725
}
28-
result.push(temp);
26+
27+
levels.push(level.slice());
2928
}
3029

31-
return result;
32-
};
30+
return levels;
31+
}
32+
33+
/**
34+
* https://leetcode.com/problems/binary-tree-level-order-traversal/
35+
* Time O(N) | Space O(H)
36+
* @param {TreeNode} root
37+
* @return {number[]}
38+
*/
39+
var levelOrder = function(root, level = 0, levels = []) {
40+
const isBaseCase = root === null;
41+
if (isBaseCase) return levels;
42+
43+
const isLastNode = level === levels.length;
44+
if (isLastNode) levels.push([]);
45+
46+
levels[level].push(root.val);
47+
48+
return dfs(root, level, levels);
49+
}
50+
51+
const dfs = (root, level, levels) => {
52+
if (root.left) levelOrder(root.left, (level + 1), levels);
53+
if (root.right) levelOrder(root.right, (level + 1), levels);
54+
55+
return levels;
56+
}

Diff for: ‎javascript/104-Maximum-Depth-of-Binary-Tree.js

+44-17
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,50 @@
11
/**
2-
* Definition for a binary tree node.
3-
* function TreeNode(val, left, right) {
4-
* this.val = (val===undefined ? 0 : val)
5-
* this.left = (left===undefined ? null : left)
6-
* this.right = (right===undefined ? null : right)
7-
* }
2+
* https://leetcode.com/problems/maximum-depth-of-binary-tree/
3+
* TIme O(N) | Space O(N)
4+
* @param {TreeNode} root
5+
* @return {number}
86
*/
7+
var maxDepth = function(root) {
8+
const isBaseCase = root === null;
9+
if (isBaseCase) return 0;
10+
11+
return dfs(root);
12+
};
13+
14+
const dfs = (root) => {
15+
const left = maxDepth(root.left);
16+
const right = maxDepth(root.right);
17+
18+
const height = Math.max(left, right);
19+
20+
return height + 1;
21+
}
22+
923
/**
24+
* https://leetcode.com/problems/maximum-depth-of-binary-tree/
25+
* TIme O(N) | Space O(N)
1026
* @param {TreeNode} root
1127
* @return {number}
1228
*/
13-
var maxDepth = (root) => {
14-
let maxDepth = 0;
15-
let DFS = (node, depth) => {
16-
if (!node) return maxDepth;
17-
if (depth > maxDepth) maxDepth = depth;
18-
DFS(node.right, depth + 1);
19-
DFS(node.left, depth + 1);
20-
};
21-
DFS(root, 1);
22-
return maxDepth;
23-
};
29+
var maxDepth = function(root) {
30+
const isBaseCase = root === null;
31+
if (isBaseCase) return 0;
32+
33+
return bfs([[ root, 0 ]]);
34+
}
35+
36+
const bfs = (queue, height = 0) => {
37+
while (queue.length) {
38+
for (let i = (queue.length - 1); 0 <= i; i--) {
39+
const [ root, depth ] = queue.shift();
40+
41+
height = Math.max(height, (depth + 1));
42+
43+
if (root.left) queue.push([ root.left, (depth + 1) ]);
44+
if (root.right) queue.push([ root.right, (depth + 1) ]);
45+
}
46+
}
47+
48+
return height;
49+
}
50+

Diff for: ‎javascript/105-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal.js

+62-10
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,62 @@
1-
function buildTree(preorder, inorder) {
2-
if (!preorder.length || !inorder.length) return null;
3-
4-
let root = new TreeNode(preorder[0]);
5-
let mid = inorder.indexOf(preorder[0]);
6-
7-
root.left = buildTree(preorder.slice(1, mid + 1), inorder.slice(0, mid));
8-
root.right = buildTree(preorder.slice(mid + 1), inorder.slice(mid + 1));
9-
return root;
10-
}
1+
/**
2+
* https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
3+
* Time O(N^2) | Space(H)
4+
* @param {number[]} preorder
5+
* @param {number[]} inorder
6+
* @return {TreeNode}
7+
*/
8+
var buildTree = function(preorder, inorder) {
9+
const isBaseCase = !preorder.length || !inorder.length;
10+
if (isBaseCase) return null;
11+
12+
return dfs(preorder, inorder);
13+
}
14+
15+
var dfs = (preorder, inorder) => {
16+
const { leftInorder, mid, rightInorder } = getPointers(preorder, inorder);
17+
const root = new TreeNode(inorder[mid]);
18+
19+
root.left = buildTree(preorder, leftInorder);
20+
root.right = buildTree(preorder, rightInorder);
21+
22+
return root;
23+
}
24+
25+
const getPointers = (preorder, inorder) => {
26+
const next = preorder.shift();
27+
const mid = inorder.indexOf(next);
28+
const leftInorder = inorder.slice(0, mid);
29+
const rightInorder = inorder.slice(mid + 1);
30+
31+
return { leftInorder, mid, rightInorder };
32+
}
33+
34+
/**
35+
* https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
36+
* Time O(N) | Space(H)
37+
* @param {number[]} preorder
38+
* @param {number[]} inorder
39+
* @return {TreeNode}
40+
*/
41+
var buildTree = function(preorder, inorder, max = -Infinity, indices = { preorder: 0, inorder: 0 }) {
42+
const isBaseCase = preorder.length <= indices.inorder;
43+
if (isBaseCase) return null;
44+
45+
const isAtEnd = inorder[indices.inorder] === max;
46+
if (isAtEnd) {
47+
indices.inorder++;
48+
return null;
49+
}
50+
51+
return dfs(preorder, inorder, max, indices);
52+
}
53+
54+
var dfs = (preorder, inorder, max, indices) => {
55+
const val = preorder[indices.preorder++]
56+
const root = new TreeNode(val);
57+
58+
root.left = buildTree(preorder, inorder, root.val, indices);
59+
root.right = buildTree(preorder, inorder, max, indices);
60+
61+
return root;
62+
}

0 commit comments

Comments
 (0)