diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README.md b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README.md index db7fb7f53c1d7..61748ef081256 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README.md +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README.md @@ -59,19 +59,19 @@ tags: ### 方法一：二分 + 递归 -我们设计一个递归函数 $dfs(l, r)$，表示当前待构造的二叉搜索树的节点值都在数组 `nums` 的下标范围 $[l, r]$ 内。该函数返回构造出的二叉搜索树的根节点。 +我们设计一个递归函数 $\textit{dfs}(l, r)$，表示当前待构造的二叉搜索树的节点值都在数组 $\textit{nums}$ 的下标范围 $[l, r]$ 内。该函数返回构造出的二叉搜索树的根节点。 -函数 $dfs(l, r)$ 的执行流程如下： +函数 $\textit{dfs}(l, r)$ 的执行流程如下： 1. 如果 $l > r$，说明当前数组为空，返回 `null`。 -2. 如果 $l \leq r$，取数组中下标为 $mid = \lfloor \frac{l + r}{2} \rfloor$ 的元素作为当前二叉搜索树的根节点，其中 $\lfloor x \rfloor$ 表示对 $x$ 向下取整。 -3. 递归地构造当前二叉搜索树的左子树，其根节点的值为数组中下标为 $mid - 1$ 的元素，左子树的节点值都在数组的下标范围 $[l, mid - 1]$ 内。 -4. 递归地构造当前二叉搜索树的右子树，其根节点的值为数组中下标为 $mid + 1$ 的元素，右子树的节点值都在数组的下标范围 $[mid + 1, r]$ 内。 +2. 如果 $l \leq r$，取数组中下标为 $\textit{mid} = \lfloor \frac{l + r}{2} \rfloor$ 的元素作为当前二叉搜索树的根节点，其中 $\lfloor x \rfloor$ 表示对 $x$ 向下取整。 +3. 递归地构造当前二叉搜索树的左子树，其根节点的值为数组中下标为 $\textit{mid} - 1$ 的元素，左子树的节点值都在数组的下标范围 $[l, \textit{mid} - 1]$ 内。 +4. 递归地构造当前二叉搜索树的右子树，其根节点的值为数组中下标为 $\textit{mid} + 1$ 的元素，右子树的节点值都在数组的下标范围 $[\textit{mid} + 1, r]$ 内。 5. 返回当前二叉搜索树的根节点。 -答案即为函数 $dfs(0, n - 1)$ 的返回值。 +答案即为函数 $\textit{dfs}(0, n - 1)$ 的返回值。 -时间复杂度 $O(n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 `nums` 的长度。 +时间复杂度 $O(n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 $\textit{nums}$ 的长度。 @@ -86,13 +86,11 @@ tags: # self.right = right class Solution: def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]: - def dfs(l, r): + def dfs(l: int, r: int) -> Optional[TreeNode]: if l > r: return None mid = (l + r) >> 1 - left = dfs(l, mid - 1) - right = dfs(mid + 1, r) - return TreeNode(nums[mid], left, right) + return TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)) return dfs(0, len(nums) - 1) ``` @@ -128,9 +126,7 @@ class Solution { return null; } int mid = (l + r) >> 1; - TreeNode left = dfs(l, mid - 1); - TreeNode right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); } } ``` @@ -152,14 +148,12 @@ class Solution { class Solution { public: TreeNode* sortedArrayToBST(vector& nums) { - function dfs = [&](int l, int r) -> TreeNode* { + auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* { if (l > r) { return nullptr; } int mid = (l + r) >> 1; - auto left = dfs(l, mid - 1); - auto right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); }; return dfs(0, nums.size() - 1); } @@ -184,8 +178,7 @@ func sortedArrayToBST(nums []int) *TreeNode { return nil } mid := (l + r) >> 1 - left, right := dfs(l, mid-1), dfs(mid+1, r) - return &TreeNode{nums[mid], left, right} + return &TreeNode{nums[mid], dfs(l, mid-1), dfs(mid+1, r)} } return dfs(0, len(nums)-1) } @@ -209,16 +202,14 @@ func sortedArrayToBST(nums []int) *TreeNode { */ function sortedArrayToBST(nums: number[]): TreeNode | null { - const n = nums.length; - if (n === 0) { - return null; - } - const mid = n >> 1; - return new TreeNode( - nums[mid], - sortedArrayToBST(nums.slice(0, mid)), - sortedArrayToBST(nums.slice(mid + 1)), - ); + const dfs = (l: number, r: number): TreeNode | null => { + if (l > r) { + return null; + } + const mid = (l + r) >> 1; + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); + }; + return dfs(0, nums.length - 1); } ``` @@ -243,23 +234,24 @@ function sortedArrayToBST(nums: number[]): TreeNode | null { // } // } // } -use std::cell::RefCell; use std::rc::Rc; +use std::cell::RefCell; impl Solution { - fn to_bst(nums: &Vec, start: usize, end: usize) -> Option>> { - if start >= end { - return None; - } - let mid = start + (end - start) / 2; - Some(Rc::new(RefCell::new(TreeNode { - val: nums[mid], - left: Self::to_bst(nums, start, mid), - right: Self::to_bst(nums, mid + 1, end), - }))) - } - pub fn sorted_array_to_bst(nums: Vec) -> Option>> { - Self::to_bst(&nums, 0, nums.len()) + fn dfs(nums: &Vec, l: usize, r: usize) -> Option>> { + if l > r { + return None; + } + let mid = (l + r) / 2; + if mid >= nums.len() { + return None; + } + let mut node = Rc::new(RefCell::new(TreeNode::new(nums[mid]))); + node.borrow_mut().left = dfs(nums, l, mid - 1); + node.borrow_mut().right = dfs(nums, mid + 1, r); + Some(node) + } + dfs(&nums, 0, nums.len() - 1) } } ``` @@ -285,14 +277,46 @@ var sortedArrayToBST = function (nums) { return null; } const mid = (l + r) >> 1; - const left = dfs(l, mid - 1); - const right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); }; return dfs(0, nums.length - 1); }; ``` +#### C# + +```cs +/** + * Definition for a binary tree node. + * public class TreeNode { + * public int val; + * public TreeNode left; + * public TreeNode right; + * public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +public class Solution { + private int[] nums; + + public TreeNode SortedArrayToBST(int[] nums) { + this.nums = nums; + return dfs(0, nums.Length - 1); + } + + private TreeNode dfs(int l, int r) { + if (l > r) { + return null; + } + int mid = (l + r) >> 1; + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); + } +} +``` + diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README_EN.md b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README_EN.md index e21e8ee2ec57a..5841ed4c98502 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README_EN.md +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/README_EN.md @@ -57,19 +57,19 @@ tags: ### Solution 1: Binary Search + Recursion -We design a recursive function $dfs(l, r)$, which indicates that the node values of the current binary search tree to be constructed are all within the index range $[l, r]$ of the array `nums`. This function returns the root node of the constructed binary search tree. +We design a recursive function $\textit{dfs}(l, r)$, which represents that the values of the nodes to be constructed in the current binary search tree are within the index range $[l, r]$ of the array $\textit{nums}$. This function returns the root node of the constructed binary search tree. -The execution process of the function $dfs(l, r)$ is as follows: +The execution process of the function $\textit{dfs}(l, r)$ is as follows: -1. If $l > r$, it means the current array is empty, return `null`. -2. If $l \leq r$, take the element with the index $mid = \lfloor \frac{l + r}{2} \rfloor$ in the array as the root node of the current binary search tree, where $\lfloor x \rfloor$ represents rounding down $x$. -3. Recursively construct the left subtree of the current binary search tree, whose root node value is the element with the index $mid - 1$ in the array, and the node values of the left subtree are all within the index range $[l, mid - 1]$ of the array. -4. Recursively construct the right subtree of the current binary search tree, whose root node value is the element with the index $mid + 1$ in the array, and the node values of the right subtree are all within the index range $[mid + 1, r]$ of the array. +1. If $l > r$, it means the current array is empty, so return `null`. +2. If $l \leq r$, take the element at index $\textit{mid} = \lfloor \frac{l + r}{2} \rfloor$ of the array as the root node of the current binary search tree, where $\lfloor x \rfloor$ denotes the floor function of $x$. +3. Recursively construct the left subtree of the current binary search tree, with the root node's value being the element at index $\textit{mid} - 1$ of the array. The values of the nodes in the left subtree are within the index range $[l, \textit{mid} - 1]$ of the array. +4. Recursively construct the right subtree of the current binary search tree, with the root node's value being the element at index $\textit{mid} + 1$ of the array. The values of the nodes in the right subtree are within the index range $[\textit{mid} + 1, r]$ of the array. 5. Return the root node of the current binary search tree. -The answer is the return value of the function $dfs(0, n - 1)$. +The answer is the return value of the function $\textit{dfs}(0, n - 1)$. -The time complexity is $O(n)$, and the space complexity is $O(\log n)$. Here, $n$ is the length of the array `nums`. +The time complexity is $O(n)$, and the space complexity is $O(\log n)$. Here, $n$ is the length of the array $\textit{nums}$. @@ -84,13 +84,11 @@ The time complexity is $O(n)$, and the space complexity is $O(\log n)$. Here, $n # self.right = right class Solution: def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]: - def dfs(l, r): + def dfs(l: int, r: int) -> Optional[TreeNode]: if l > r: return None mid = (l + r) >> 1 - left = dfs(l, mid - 1) - right = dfs(mid + 1, r) - return TreeNode(nums[mid], left, right) + return TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)) return dfs(0, len(nums) - 1) ``` @@ -126,9 +124,7 @@ class Solution { return null; } int mid = (l + r) >> 1; - TreeNode left = dfs(l, mid - 1); - TreeNode right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); } } ``` @@ -150,14 +146,12 @@ class Solution { class Solution { public: TreeNode* sortedArrayToBST(vector& nums) { - function dfs = [&](int l, int r) -> TreeNode* { + auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* { if (l > r) { return nullptr; } int mid = (l + r) >> 1; - auto left = dfs(l, mid - 1); - auto right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); }; return dfs(0, nums.size() - 1); } @@ -182,8 +176,7 @@ func sortedArrayToBST(nums []int) *TreeNode { return nil } mid := (l + r) >> 1 - left, right := dfs(l, mid-1), dfs(mid+1, r) - return &TreeNode{nums[mid], left, right} + return &TreeNode{nums[mid], dfs(l, mid-1), dfs(mid+1, r)} } return dfs(0, len(nums)-1) } @@ -207,16 +200,14 @@ func sortedArrayToBST(nums []int) *TreeNode { */ function sortedArrayToBST(nums: number[]): TreeNode | null { - const n = nums.length; - if (n === 0) { - return null; - } - const mid = n >> 1; - return new TreeNode( - nums[mid], - sortedArrayToBST(nums.slice(0, mid)), - sortedArrayToBST(nums.slice(mid + 1)), - ); + const dfs = (l: number, r: number): TreeNode | null => { + if (l > r) { + return null; + } + const mid = (l + r) >> 1; + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); + }; + return dfs(0, nums.length - 1); } ``` @@ -241,23 +232,24 @@ function sortedArrayToBST(nums: number[]): TreeNode | null { // } // } // } -use std::cell::RefCell; use std::rc::Rc; +use std::cell::RefCell; impl Solution { - fn to_bst(nums: &Vec, start: usize, end: usize) -> Option>> { - if start >= end { - return None; - } - let mid = start + (end - start) / 2; - Some(Rc::new(RefCell::new(TreeNode { - val: nums[mid], - left: Self::to_bst(nums, start, mid), - right: Self::to_bst(nums, mid + 1, end), - }))) - } - pub fn sorted_array_to_bst(nums: Vec) -> Option>> { - Self::to_bst(&nums, 0, nums.len()) + fn dfs(nums: &Vec, l: usize, r: usize) -> Option>> { + if l > r { + return None; + } + let mid = (l + r) / 2; + if mid >= nums.len() { + return None; + } + let mut node = Rc::new(RefCell::new(TreeNode::new(nums[mid]))); + node.borrow_mut().left = dfs(nums, l, mid - 1); + node.borrow_mut().right = dfs(nums, mid + 1, r); + Some(node) + } + dfs(&nums, 0, nums.len() - 1) } } ``` @@ -283,14 +275,46 @@ var sortedArrayToBST = function (nums) { return null; } const mid = (l + r) >> 1; - const left = dfs(l, mid - 1); - const right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); }; return dfs(0, nums.length - 1); }; ``` +#### C# + +```cs +/** + * Definition for a binary tree node. + * public class TreeNode { + * public int val; + * public TreeNode left; + * public TreeNode right; + * public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +public class Solution { + private int[] nums; + + public TreeNode SortedArrayToBST(int[] nums) { + this.nums = nums; + return dfs(0, nums.Length - 1); + } + + private TreeNode dfs(int l, int r) { + if (l > r) { + return null; + } + int mid = (l + r) >> 1; + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); + } +} +``` + diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cpp b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cpp index 7e31c24233486..533ec37538ec8 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cpp +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cpp @@ -12,15 +12,13 @@ class Solution { public: TreeNode* sortedArrayToBST(vector& nums) { - function dfs = [&](int l, int r) -> TreeNode* { + auto dfs = [&](this auto&& dfs, int l, int r) -> TreeNode* { if (l > r) { return nullptr; } int mid = (l + r) >> 1; - auto left = dfs(l, mid - 1); - auto right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); }; return dfs(0, nums.size() - 1); } -}; \ No newline at end of file +}; diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cs b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cs new file mode 100644 index 0000000000000..74744f8542d62 --- /dev/null +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.cs @@ -0,0 +1,29 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * public int val; + * public TreeNode left; + * public TreeNode right; + * public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +public class Solution { + private int[] nums; + + public TreeNode SortedArrayToBST(int[] nums) { + this.nums = nums; + return dfs(0, nums.Length - 1); + } + + private TreeNode dfs(int l, int r) { + if (l > r) { + return null; + } + int mid = (l + r) >> 1; + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); + } +} diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.go b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.go index 7fcca7e6e4423..b548481249fbf 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.go +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.go @@ -13,8 +13,7 @@ func sortedArrayToBST(nums []int) *TreeNode { return nil } mid := (l + r) >> 1 - left, right := dfs(l, mid-1), dfs(mid+1, r) - return &TreeNode{nums[mid], left, right} + return &TreeNode{nums[mid], dfs(l, mid-1), dfs(mid+1, r)} } return dfs(0, len(nums)-1) -} \ No newline at end of file +} diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.java b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.java index 2198af1f70699..0170906a79324 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.java +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.java @@ -26,8 +26,6 @@ private TreeNode dfs(int l, int r) { return null; } int mid = (l + r) >> 1; - TreeNode left = dfs(l, mid - 1); - TreeNode right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); } -} \ No newline at end of file +} diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.js b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.js index e11b73756e815..15ec76977edb5 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.js +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.js @@ -16,9 +16,7 @@ var sortedArrayToBST = function (nums) { return null; } const mid = (l + r) >> 1; - const left = dfs(l, mid - 1); - const right = dfs(mid + 1, r); - return new TreeNode(nums[mid], left, right); + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); }; return dfs(0, nums.length - 1); }; diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.py b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.py index bbe91182aef82..d829a473dbc59 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.py +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.py @@ -6,12 +6,10 @@ # self.right = right class Solution: def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]: - def dfs(l, r): + def dfs(l: int, r: int) -> Optional[TreeNode]: if l > r: return None mid = (l + r) >> 1 - left = dfs(l, mid - 1) - right = dfs(mid + 1, r) - return TreeNode(nums[mid], left, right) + return TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)) return dfs(0, len(nums) - 1) diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.rs b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.rs index 2c98083931569..34b0a43856680 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.rs +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.rs @@ -19,19 +19,20 @@ use std::cell::RefCell; use std::rc::Rc; impl Solution { - fn to_bst(nums: &Vec, start: usize, end: usize) -> Option>> { - if start >= end { - return None; - } - let mid = start + (end - start) / 2; - Some(Rc::new(RefCell::new(TreeNode { - val: nums[mid], - left: Self::to_bst(nums, start, mid), - right: Self::to_bst(nums, mid + 1, end), - }))) - } - pub fn sorted_array_to_bst(nums: Vec) -> Option>> { - Self::to_bst(&nums, 0, nums.len()) + fn dfs(nums: &Vec, l: usize, r: usize) -> Option>> { + if l > r { + return None; + } + let mid = (l + r) / 2; + if mid >= nums.len() { + return None; + } + let mut node = Rc::new(RefCell::new(TreeNode::new(nums[mid]))); + node.borrow_mut().left = dfs(nums, l, mid - 1); + node.borrow_mut().right = dfs(nums, mid + 1, r); + Some(node) + } + dfs(&nums, 0, nums.len() - 1) } } diff --git a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.ts b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.ts index 0bbb0279052ba..4533065b16cbe 100644 --- a/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.ts +++ b/solution/0100-0199/0108.Convert Sorted Array to Binary Search Tree/Solution.ts @@ -13,14 +13,12 @@ */ function sortedArrayToBST(nums: number[]): TreeNode | null { - const n = nums.length; - if (n === 0) { - return null; - } - const mid = n >> 1; - return new TreeNode( - nums[mid], - sortedArrayToBST(nums.slice(0, mid)), - sortedArrayToBST(nums.slice(mid + 1)), - ); + const dfs = (l: number, r: number): TreeNode | null => { + if (l > r) { + return null; + } + const mid = (l + r) >> 1; + return new TreeNode(nums[mid], dfs(l, mid - 1), dfs(mid + 1, r)); + }; + return dfs(0, nums.length - 1); }