From 83745f8ccda80f015de2aaaba1f245df1d31acee Mon Sep 17 00:00:00 2001 From: Nobody <55767918+Annatxu@users.noreply.github.com> Date: Wed, 21 May 2025 13:26:54 -0700 Subject: [PATCH 1/4] Update README.md add DFS method --- .../README.md | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md b/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md index be80ded542971..bf77cb79d3d5c 100644 --- a/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md +++ b/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md @@ -147,6 +147,41 @@ class Solution { } ``` +``` +DFS: +class Solution { + public List> zigzagLevelOrder(TreeNode root) { + List> result = new ArrayList<>(); + dfs(root, 0, result); + return result; + } + + private void dfs(TreeNode node, int level, List> result) { + if (node == null) return; + + // Create new level list if needed + if (result.size() == level) { + result.add(new LinkedList<>()); + } + + List levelList = result.get(level); + + if (level % 2 == 0) { + // Left to right + levelList.add(node.val); + } else { + // Right to left + levelList.add(0, node.val); + } + + // Go deeper + dfs(node.left, level + 1, result); + dfs(node.right, level + 1, result); + } +} + +``` + #### C++ ```cpp From 300021f031d8e0d96112063b91984869d4283887 Mon Sep 17 00:00:00 2001 From: Nobody <55767918+Annatxu@users.noreply.github.com> Date: Wed, 21 May 2025 13:27:30 -0700 Subject: [PATCH 2/4] Update README.md --- .../0103.Binary Tree Zigzag Level Order Traversal/README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md b/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md index bf77cb79d3d5c..ccf2f147aa146 100644 --- a/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md +++ b/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md @@ -147,8 +147,7 @@ class Solution { } ``` -``` -DFS: +```DFS: class Solution { public List> zigzagLevelOrder(TreeNode root) { List> result = new ArrayList<>(); From 34b4b96c0e3a55e6251a30933542eb08a5b152ee Mon Sep 17 00:00:00 2001 From: Nobody <55767918+Annatxu@users.noreply.github.com> Date: Wed, 21 May 2025 13:28:57 -0700 Subject: [PATCH 3/4] Update README.md --- .../README.md | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md b/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md index ccf2f147aa146..21dc5809a1c52 100644 --- a/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md +++ b/solution/0100-0199/0103.Binary Tree Zigzag Level Order Traversal/README.md @@ -99,7 +99,7 @@ class Solution: #### Java -```java +```java BFS /** * Definition for a binary tree node. * public class TreeNode { @@ -147,7 +147,22 @@ class Solution { } ``` -```DFS: +```java DFS +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ class Solution { public List> zigzagLevelOrder(TreeNode root) { List> result = new ArrayList<>(); From 72118bf477e4687a9f0f7d674dd0cefd5a160819 Mon Sep 17 00:00:00 2001 From: Nobody <55767918+Annatxu@users.noreply.github.com> Date: Sun, 1 Jun 2025 13:41:14 -0700 Subject: [PATCH 4/4] Update README.md --- .../0450.Delete Node in a BST/README.md | 290 ++++-------------- 1 file changed, 59 insertions(+), 231 deletions(-) diff --git a/solution/0400-0499/0450.Delete Node in a BST/README.md b/solution/0400-0499/0450.Delete Node in a BST/README.md index 49f25a6a18fe3..18cce8e5863d6 100644 --- a/solution/0400-0499/0450.Delete Node in a BST/README.md +++ b/solution/0400-0499/0450.Delete Node in a BST/README.md @@ -100,35 +100,65 @@ tags: -#### Python3 - -```python -# Definition for a binary tree node. -# class TreeNode: -# def __init__(self, val=0, left=None, right=None): -# self.val = val -# self.left = left -# self.right = right -class Solution: - def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]: - if root is None: - return None - if root.val > key: - root.left = self.deleteNode(root.left, key) - return root - if root.val < key: - root.right = self.deleteNode(root.right, key) - return root - if root.left is None: - return root.right - if root.right is None: - return root.left - node = root.right - while node.left: - node = node.left - node.left = root.left - root = root.right - return root +#### java iteration + +```java 1 +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public TreeNode deleteNode(TreeNode root, int key) { + if (root == null) return null; + if (root.val == key) return helper(root); + + TreeNode dummy = root; + while (root != null) { + if (root.val > key) { + if (root.left != null && root.left.val == key) { + root.left = helper(root.left); + break; + } else { + root = root.left; + } + } else { + if (root.right != null && root.right.val == key) { + root.right = helper(root.right); + break; + } else { + root = root.right; + } + } + } + return dummy; + } + + private TreeNode helper(TreeNode root) { + if (root.left == null) return root.right; + if (root.right == null) return root.left; + + TreeNode rightChild = root.right; + TreeNode lastRight = findLastRight(root.left); + lastRight.right = rightChild; + return root.left; + } + + private TreeNode findLastRight(TreeNode root) { + if (root.right == null) return root; + return findLastRight(root.right); + } +} ``` #### Java @@ -179,208 +209,6 @@ class Solution { } ``` -#### C++ - -```cpp -/** - * Definition for a binary tree node. - * struct TreeNode { - * int val; - * TreeNode *left; - * TreeNode *right; - * TreeNode() : val(0), left(nullptr), right(nullptr) {} - * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} - * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} - * }; - */ -class Solution { -public: - TreeNode* deleteNode(TreeNode* root, int key) { - if (!root) return root; - if (root->val > key) { - root->left = deleteNode(root->left, key); - return root; - } - if (root->val < key) { - root->right = deleteNode(root->right, key); - return root; - } - if (!root->left) return root->right; - if (!root->right) return root->left; - TreeNode* node = root->right; - while (node->left) node = node->left; - node->left = root->left; - root = root->right; - return root; - } -}; -``` - -#### Go - -```go -/** - * Definition for a binary tree node. - * type TreeNode struct { - * Val int - * Left *TreeNode - * Right *TreeNode - * } - */ -func deleteNode(root *TreeNode, key int) *TreeNode { - if root == nil { - return nil - } - if root.Val > key { - root.Left = deleteNode(root.Left, key) - return root - } - if root.Val < key { - root.Right = deleteNode(root.Right, key) - return root - } - if root.Left == nil { - return root.Right - } - if root.Right == nil { - return root.Left - } - node := root.Right - for node.Left != nil { - node = node.Left - } - node.Left = root.Left - root = root.Right - return root -} -``` - -#### TypeScript - -```ts -/** - * 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 deleteNode(root: TreeNode | null, key: number): TreeNode | null { - if (root == null) { - return root; - } - const { val, left, right } = root; - if (val > key) { - root.left = deleteNode(left, key); - } else if (val < key) { - root.right = deleteNode(right, key); - } else { - if (left == null && right == null) { - root = null; - } else if (left == null || right == null) { - root = left || right; - } else { - if (right.left == null) { - right.left = left; - root = right; - } else { - let minPreNode = right; - while (minPreNode.left.left != null) { - minPreNode = minPreNode.left; - } - const minVal = minPreNode.left.val; - root.val = minVal; - minPreNode.left = deleteNode(minPreNode.left, minVal); - } - } - } - return root; -} -``` - -#### Rust - -```rust -// Definition for a binary tree node. -// #[derive(Debug, PartialEq, Eq)] -// pub struct TreeNode { -// pub val: i32, -// pub left: Option>>, -// pub right: Option>>, -// } -// -// impl TreeNode { -// #[inline] -// pub fn new(val: i32) -> Self { -// TreeNode { -// val, -// left: None, -// right: None -// } -// } -// } -use std::cell::RefCell; -use std::rc::Rc; -impl Solution { - fn dfs(root: &Option>>) -> i32 { - let node = root.as_ref().unwrap().borrow(); - if node.left.is_none() { - return node.val; - } - Self::dfs(&node.left) - } - - pub fn delete_node( - mut root: Option>>, - key: i32, - ) -> Option>> { - if root.is_some() { - let mut node = root.as_mut().unwrap().borrow_mut(); - match node.val.cmp(&key) { - std::cmp::Ordering::Less => { - node.right = Self::delete_node(node.right.take(), key); - } - std::cmp::Ordering::Greater => { - node.left = Self::delete_node(node.left.take(), key); - } - std::cmp::Ordering::Equal => { - match (node.left.is_some(), node.right.is_some()) { - (false, false) => { - return None; - } - (true, false) => { - return node.left.take(); - } - (false, true) => { - return node.right.take(); - } - (true, true) => { - if node.right.as_ref().unwrap().borrow().left.is_none() { - let mut r = node.right.take(); - r.as_mut().unwrap().borrow_mut().left = node.left.take(); - return r; - } else { - let val = Self::dfs(&node.right); - node.val = val; - node.right = Self::delete_node(node.right.take(), val); - } - } - }; - } - } - } - root - } -} -``` -