add tree examples

Barklim · Barklim · commit 521ec6289c54 · 2025-03-15T14:23:20.000+03:00
diff --git a/example/5.Stack/2390.js b/example/5.Stack/2390.js
@@ -3,13 +3,7 @@
  * @return {string}
  */
 var removeStars = function(s) {
-  const stack = [];
 
-  for (const char of s) {
-      char === '*' ? stack.pop(): stack.push(char)
-  }
-
-  return stack.join('');
 };
 
 const example1 = removeStars('leet**cod*e'); // 'lecoe'
diff --git a/example/6.Tree/0098.js b/example/6.Tree/0098.js
@@ -0,0 +1,23 @@
+/**
+ * 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 {boolean}
+ */
+var isValidBST = function(root) {
+    
+};
+
+const example1 = isValidBST(); // root = [2,1,3] // true
+const example2 = isValidBST(); // root = [5,1,4,null,null,3,6] // false
+const example3 = isValidBST(); // root = [1,2,3] // false
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
diff --git a/example/6.Tree/0100.js b/example/6.Tree/0100.js
@@ -0,0 +1,24 @@
+/**
+ * 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} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function(p, q) {
+    
+};
+
+const example1 = isSameTree(); // p = [1,2,3], q = [1,2,3] // true
+const example2 = isSameTree(); // p = [1,2], q = [1,null,2] // false
+const example3 = isSameTree(); // p = [1,2,1], q = [1,1,2] // false
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
diff --git a/example/6.Tree/0101.js b/example/6.Tree/0101.js
@@ -0,0 +1,25 @@
+/**
+ * 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 {boolean}
+ */
+var isSymmetric = function(root) {
+    
+};
+
+const example1 = isSymmetric(); // [1,2,2,3,4,4,3] // true
+const example2 = isSymmetric(); // [1,2,2,null,3,null,3] // false
+const example3 = isSymmetric(); // [1,2,3,null,null,4] // 3
+const example4 = isSymmetric(); // [] // 0
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
+console.log(example4);
diff --git a/example/6.Tree/0102.js b/example/6.Tree/0102.js
@@ -0,0 +1,25 @@
+/**
+ * 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 levelOrder = function(root) {
+    
+};
+
+const example1 = levelOrder(); // root = [3,9,20,null,null,15,7] // [[3],[9,20],[15,7]] 
+const example2 = levelOrder(); // root = [1] // [[1]]
+const example3 = levelOrder(); // root = [] // []
+const example4 = levelOrder(); // root = [1,2,3,4,5,6,7] // [[1],[2,3],[4,5,6,7]]
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
+console.log(example4);
diff --git a/example/6.Tree/0103.js b/example/6.Tree/0103.js
@@ -0,0 +1,23 @@
+/**
+ * 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 zigzagLevelOrder = function(root) {
+    
+};
+
+const example1 = zigzagLevelOrder(); // root = [3,9,20,null,null,15,7] // [[3],[20,9],[15,7]]
+const example2 = zigzagLevelOrder(); // root = [[1] // [[1]]
+const example3 = zigzagLevelOrder(); // root = [] // []
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
diff --git a/example/6.Tree/0104.js b/example/6.Tree/0104.js
@@ -0,0 +1,25 @@
+/**
+ * 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 maxDepth = function(root) {
+    
+};
+
+const example1 = maxDepth(); // [3,9,20,null,null,15,7] // 3
+const example2 = maxDepth(); // [1,null,2] // 2
+const example3 = maxDepth(); // [1,2,3,null,null,4] // 3
+const example4 = maxDepth(); // [] // 0
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
+console.log(example4);
diff --git a/example/6.Tree/0110.js b/example/6.Tree/0110.js
@@ -0,0 +1,27 @@
+/**
+ * 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 {boolean}
+ */
+var isBalanced = function(root) {
+    
+};
+
+const example1 = isBalanced(); // root = [3,9,20,null,null,15,7] // true
+const example2 = isBalanced(); // root = [1,2,2,3,3,null,null,4,4] // false
+const example3 = isBalanced(); // root = [] // true
+const example4 = isBalanced(); // root = [1,2,3,null,null,4] // true
+const example5 = isBalanced(); // root = [1,2,3,null,null,4,null,5] // false
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
+console.log(example4);
+console.log(example5);
diff --git a/example/6.Tree/0112.js b/example/6.Tree/0112.js
@@ -0,0 +1,24 @@
+/**
+ * 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} targetSum
+ * @return {boolean}
+ */
+var hasPathSum = function(root, targetSum) {
+    
+};
+
+const example1 = hasPathSum(); // root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22 // true
+const example2 = hasPathSum(); // root = [1,2,3], targetSum = 5 // false
+const example3 = hasPathSum(); // root = [], targetSum = 0 // false
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
diff --git a/example/6.Tree/0117.js b/example/6.Tree/0117.js
@@ -0,0 +1,23 @@
+/**
+ * // 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;
+ * };
+ */
+
+/**
+ * @param {_Node} root
+ * @return {_Node}
+ */
+var connect = function(root) {
+    
+};
+
+const example1 = connect(); // root = [1,2,3,4,5,null,7] // [1,#,2,3,#,4,5,7,#]
+const example2 = connect(); // root = [] // []
+
+console.log(example1);
+console.log(example2);
diff --git a/example/6.Tree/0199.js b/example/6.Tree/0199.js
@@ -0,0 +1,29 @@
+/**
+ * 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 rightSideView = function(root) {
+    
+};
+
+const example1 = rightSideView(); // [1,2,3,null,5,null,4] // [1,3,4]
+const example2 = rightSideView(); // root = [1,2,3,4,null,null,null,5] // [1,3,4,5]
+const example3 = rightSideView(); // root = [1,null,3] //  [1,3]
+const example4 = rightSideView(); // root = [] //  []
+const example5 = rightSideView(); // root = [1,2,3] // [1,3]
+const example6 = rightSideView(); // root = [1,2,3,4,5,6,7] // [1,3,7]
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
+console.log(example4);
+console.log(example5);
+console.log(example6);
diff --git a/example/6.Tree/0226.js b/example/6.Tree/0226.js
@@ -0,0 +1,27 @@
+/**
+ * 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 {TreeNode}
+ */
+var invertTree = function(root) {
+    
+};
+
+const example1 = invertTree(); // [4,2,7,1,3,6,9] //[ 4,7,2,9,6,3,1]
+const example2 = invertTree(); // [2,1,3] // [2,3,1]
+const example3 = invertTree(); // [] // []
+const example4 = invertTree(); // [1,2,3,4,5,6,7] // [1,3,2,7,6,5,4]
+const example5 = invertTree(); // [3,2,1] // [3,1,2]
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
+console.log(example4);
+console.log(example5);
diff --git a/example/6.Tree/0236.js b/example/6.Tree/0236.js
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function(root, p, q) {
+    
+};
+
+const example1 = lowestCommonAncestor(); // root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 // 3
+const example2 = lowestCommonAncestor(); // root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 // 5
+const example3 = lowestCommonAncestor(); // root = [1,2], p = 1, q = 2 // 1
+const example4 = lowestCommonAncestor(); // root = [5,3,8,1,4,7,9,null,2], p = 3, q = 8 // 5
+const example5 = lowestCommonAncestor(); // root = [5,3,8,1,4,7,9,null,2], p = 3, q = 4 // 3
+
+console.log(example1);
+console.log(example2);
+console.log(example3);
+console.log(example4);
+console.log(example5);
diff --git a/example/6.Tree/0515.js b/example/6.Tree/0515.js
@@ -0,0 +1,21 @@
+/**
+ * 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 largestValues = function(root) {
+    
+};
+
+const example1 = largestValues(); // root = [1,3,2,5,3,null,9]  // [1,3,9]
+const example2 = largestValues(); // root = [1,2,3] // [1,3]
+
+console.log(example1);
+console.log(example2);
diff --git a/example/6.Tree/0543.js b/example/6.Tree/0543.js
@@ -0,0 +1,21 @@
+/**
+ * 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 diameterOfBinaryTree = function(root) {
+    
+};
+
+const example1 = diameterOfBinaryTree(); // root = [1,2,3,4,5] // 3
+const example2 = diameterOfBinaryTree(); // root = [1,2] // 1
+
+console.log(example1);
+console.log(example2);
diff --git a/example/6.Tree/0700.js b/example/6.Tree/0700.js
diff --git a/example/6.Tree/0701.js b/example/6.Tree/0701.js
diff --git a/example/6.Tree/1302.js b/example/6.Tree/1302.js
diff --git a/example/6.Tree/1325.js b/example/6.Tree/1325.js
diff --git a/example/README.md b/example/README.md
