我想将排序的整数数组转换为二叉搜索树。我相信我明白该怎么做。我在下面发布了我的伪代码。我无法想象的是递归实际上是如何工作的。
所以如果我的数组是1,2,3,4,5 ...... 我首先将3作为BST的根。然后我将2的左子节点设为2.然后我将1的左子节点设为1,然后返回2?我不知道递归是如何逐步完成整个过程的......
先谢谢,如果这个问题解释得不好,请道歉。我不想要显式代码,但我真的很感激,如果有人可以帮助我了解递归如何贯穿问题(即,以什么顺序访问哪些节点/调用堆栈如何工作)
的伪代码:
步骤1.创建一个接受整数数组,整数开始和整数结束的函数。 Start = 0,end =整数数组大小 - 1.
步骤2.创建一个等于(start + end)/ 2的整数中间。
步骤3.测试是否开始>结束。
步骤4.如果是,则返回null。
步骤5.否则,将中间索引处的值设置为树的根。
步骤6.将根的左节点设置为等于函数(array,start,middle - 1)。
步骤7.将根的右侧节点设置为等于函数(array,middle + 1,end)。
答案 0 :(得分:1)
在Java中:
public static BST sortedArrayToBST(int[] arr){
BST bst = new BST();
sortedArrayToBST(arr, 0, arr.length-1, bst);
return bst;
}
private static void sortedArrayToBST(int[] arr, int start, int end, BST bst) {
if( start == end){
bst.insert(new Node(arr[start]));
return;
}
else if(start > end) {
return;
}
int middle = (start+end)/2;
bst.insert(new Node(arr[middle]));
sortedArrayToBST(arr, start, middle - 1, bst);
sortedArrayToBST(arr, middle+1, end, bst);
}
<强> TEST:强>
int[] arr = {1,2,3,4,5,6,7,8,9};
BST bst = sortedArrayToBST(arr);
bst.printInOrder();
<强>输出强>
1,2,3,4,5,6,7,8,9,
答案 1 :(得分:0)
Common Lisp版本:
(defun sorted-array->tree (array)
(loop
:with olength := (length array)
:with length := (ceiling olength 2)
:with result := (make-array length)
:for i :from 0 :below length
:for j :from 0 :by 2
:for k :from 1 :by 2 :do
(setf (aref result i)
(if (< k olength)
(list (aref array j) (aref array k))
(list (aref array j))))
:finally
(return (if (= 1 length)
(aref result 0)
(sorted-array->tree result)))))
(sorted-array->tree #(1 2 3 4 5 6 7 8 9))
;; ((((1 2) (3 4)) ((5 6) (7 8))) (((9))))
虽然这实际上取决于你想如何处理不均匀的叶子。
答案 2 :(得分:0)
public class ArrayToBst {
private static int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
public static void main(String[] args) {
Node talakorootpreservegareko = getBst(arr, 0, 6);
inOrder(talakorootpreservegareko);
}
public static Node getBst(int[] arr, int start, int stop) {
if (start > stop) {
return null;
} else {
int mid = (start + stop) / 2;
Node root = new Node(arr[mid]);
System.out.println(root.data);
root.left = getBst(arr, start, mid - 1);
root.right = getBst(arr, mid + 1, stop);
// System.out.print(root.data + " \t");
return root;
}
}
public static void inOrder(Node parent) {
if (parent != null) {
inOrder(parent.left);
System.out.print(" data " + parent.data + "\t");
inOrder(parent.right);
}
}
}
答案 3 :(得分:0)
minimalBST(root, arr, 0, len(arr) - 1)
def minimalBST(root, arr, start, end):
if start > end
return
mid = (start + end) // 2
root = CreateNode(arr[mid])
minimalBST(root.left, arr, start, mid - 1)
minimalBST(root.right, arr, mid + 1, end)
- + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - +
arr = [1,2,3,4,5,6,7]因为len(arr)= 7楼(log(7))= 2 树必须形成最大高度2
4
/ \
2 6
/ \ / \
1 3 5 7
minmalBST(root,arr,0,6) - &gt; root = 4
minimalBST(root.left,arr,0,2) - &gt; root.left = 2
minimalBST(root.left.left,arr,0,0) - &gt; root.left.left = 1
minimalBST(root.left.left.left,arr,0,-1) - &gt;无
minimalBST(root.left.right,arr,2,2) - &gt; root.left.right = 2
minimalBST(root.left.right.left,3,2) - &gt;无
minimalBST(root.right,arr,4,6) - &gt; root.right = 6
minimalBST(root.right.left,arr,4,4) - &gt; root.right.left = 5
minimalBST(root.right.left.left,arr,4,3) - &gt;无
minimalBST(root.right.right,arr,6,6) - &gt; root.left.right = 7
minimalBST(root.right.right.left,3,2) - &gt;无