Bạn có thể đại diện cho một cây nhị phân trong Python như một danh sách một chiều theo cùng một cách chính xác.
Điều này tương ứng với công thức của bạn. Đối với một nút nhất định tại Index
Xem thảo luận
Cải thiện bài viết
Lưu bài viết
Đọc Bàn luậnXem thảo luận
Cải thiện bài viết
Lưu bài viết
Đọc
Bàn luận
Cho một mảng đại diện cho một cây theo cách mà các chỉ mục mảng là các giá trị trong các nút cây và giá trị mảng cung cấp cho nút cha của chỉ mục cụ thể đó (hoặc nút). Giá trị của chỉ mục nút gốc sẽ luôn là -1 vì không có cha mẹ cho root. Xây dựng biểu diễn liên kết tiêu chuẩn của cây nhị phân đã cho từ biểu diễn đã cho này. Hãy tham khảo để hiểu cách xây dựng cây nhị phân từ biểu diễn mảng cha mẹ đã cho.
- Các cách để đại diện cho: & nbsp;
- Cây có thể được biểu diễn theo hai cách như được liệt kê dưới đây:
Biểu diễn nút động (biểu diễn liên kết).
Illustration:
A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) Procedure:
Biểu diễn mảng (biểu diễn tuần tự).father, left_son and right_son are the values of indices
of the array.
Bây giờ, chúng ta sẽ nói về đại diện tuần tự của cây. & NBSP; Để biểu diễn một cây bằng một mảng, việc đánh số các nút có thể bắt đầu từ 0, (N-1) hoặc 1 N N, hãy xem xét hình minh họa dưới đây như sau: (0—n-1)
if (say)father=p;
then left_son=(2*p)+1;
and right_son=(2*p)+2;
Lưu ý: Cha, trái_SON và RIGHT_SON là các giá trị của các chỉ số của mảng. 1—n
if (say)father=p;
then left_son=(2*p);
and right_son=(2*p)+1;
Implementation:
C++
15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
0& nbsp; trường hợp 1: (0, n-1) & nbsp;
Trường hợp 2: 1 - N
15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
1 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
2 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
3 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
5class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
7class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
8class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
2 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
7 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
9class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
3class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
4 Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
6 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 4 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 5class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
8class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5if (say)father=p;
then left_son=(2*p)+1;
and right_son=(2*p)+2;
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
7 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
9Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
3class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
6 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Can't set child at 3 , no parent found
Can't set child at 4 , no parent found
A-C---F---
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 4 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 5class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
8 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
8 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 # Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 # Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Can't set child at 3 , no parent found
Can't set child at 4 , no parent found
A-C---F---
8 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
7 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
9Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
3class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
07class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
8class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
4 Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
19a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
20class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
19class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
25class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
8class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
7 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
9Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
3class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
7a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
37a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
38class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
8a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
41a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
42class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
4 Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
5class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
8a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
49a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
50class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0if (say)father=p;
then left_son=(2*p)+1;
and right_son=(2*p)+2;
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
53a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
50class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0if (say)father=p;
then left_son=(2*p)+1;
and right_son=(2*p)+2;
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
57a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
58class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
60 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
7 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
9Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
3class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4
class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
4 Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
8 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 # Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 # Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 # Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
5class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
3class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 if (say)father=p;
then left_son=(2*p)+1;
and right_son=(2*p)+2;
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
4 # Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 # Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
81a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
82 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
83a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
85a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
86a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
38a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
89__1901919191919138a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
95a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
96a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
91a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
1a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
38a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
89 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
02a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
91a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
1a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
38a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
95 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
08a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
91a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
2a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
38a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
13class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
71 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
18class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
222a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
8class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
27a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
82 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
29 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
30 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
31class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
35a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
37class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
41 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
43class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
48a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
2 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
50a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
1a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
55 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
56 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
57 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
59 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
60 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
61 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
62 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
60 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
64a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
71a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
79 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
43class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
48a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
2 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
50__12a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
55 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
56 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
57 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
59 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
60 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
61 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
62 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
60 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
64a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
71a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
79 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
43class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
48a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
2 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
50__12class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
17 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
60class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
35a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
10 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
11 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
24____1010____326 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
30class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
28 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
60class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
39a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
25a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
38a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6C#
15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
31 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
56class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
48class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
81a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
82 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
83a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
85a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
86a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
38a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
89a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
90a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
46a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
95a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
96a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
50a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
89 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
02a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
50a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
71 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
72a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
13class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
71 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
18class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
222a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
8class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
27a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
82 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
29 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
30 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
31class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
35a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
37class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
06class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
41 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
43class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
55 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
56 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
57 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
26Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
27Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
28a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
71a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
79 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
43class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
48a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
2 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
50__12a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
55 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
56 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
57 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
26Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
27Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
28a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
71a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
79 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
43class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
79a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
48a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
2 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
50__12class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
17 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
60Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
88 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
60Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
26a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
25a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
38a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
6Python3
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
10 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
11 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
24____1010____326 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
30class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
28 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
31 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
56class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
18a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
11class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
7class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
1 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
48a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
71 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
72class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
56a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
95 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
08a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
58class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
93class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
16class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
27a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
82 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
98class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
74 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
76 Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
02a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
95 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
08a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
58class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
6 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
93class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
16class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
75 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
27a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
82 class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
98# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
07 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 02class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
10 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 05 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 06 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 07a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
11 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
30 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 10a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
1 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 13# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
01 # Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
03# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
16 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
18 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 19# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
01 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 21a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
80Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
0# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
16 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
58# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
18a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
11a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
25 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 29# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
01 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 21class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
5# Naming slices (slice(start, end, step))
>>> a = [0, 1, 2, 3, 4, 5]
>>> LASTTHREE = slice(-3, None)
>>> LASTTHREE
slice(-3, None, None)
>>> a[LASTTHREE]
[3, 4, 5]
18 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 34 15
6
14
2
13
5
11
0
10
4
9
1
8
3
7
7a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
37class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4if (say)father=p;
then left_son=(2*p)+1;
and right_son=(2*p)+2;
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
45a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
91a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
0class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4Original array:
[1, 2, 3, 4, 5, 6, 7]
Array to a height balanced BST:
4
2
1
3
6
5
7
None
8a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
49a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
91a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
1class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4if (say)father=p;
then left_son=(2*p)+1;
and right_son=(2*p)+2;
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
53a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
91a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
1class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4if (say)father=p;
then left_son=(2*p)+1;
and right_son=(2*p)+2;
6a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
57a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
91a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15]
def childNodes(i):
return (2*i)+1, (2*i)+2
def traversed(a, i=0, d = 0):
if i >= len(a):
return
l, r = childNodes(i)
traversed(a, r, d = d+1)
print(" "*d + str(a[i]))
traversed(a, l, d = d+1)
traversed(a)
2class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def array_to_bst(array_nums):
if not array_nums:
return None
mid_num = len(array_nums)//2
node = TreeNode(array_nums[mid_num])
node.left = array_to_bst(array_nums[:mid_num])
node.right = array_to_bst(array_nums[mid_num+1:])
return node
def preOrder(node):
if not node:
return
print(node.val)
preOrder(node.left)
preOrder(node.right)
array_nums = [1,2,3,4,5,6,7]
print("Original array:")
print(array_nums)
result = array_to_bst(array_nums)
print("\nArray to a height balanced BST:")
print(preOrder(result))
4 A(0)
/ \
B(1) C(2)
/ \ \
D(3) E(4) F(6)
OR,
A(1)
/ \
B(2) C(3)
/ \ \
D(4) E(5) F(7) 58Đầu ra
Can't set child at 3 , no parent found
Can't set child at 4 , no parent found
A-C---F---
Độ phức tạp về thời gian: O (log n) Vì sử dụng heap để tạo ra độ phức tạp của không gian nhị phân: O (n) cho mảng since using heap to create a binary tree
Space complexity: O(n) for array
Trong trường hợp của một cây nhị phân, bạn sẽ phải thực hiện một đường ngang hàng. Và khi bạn tiếp tục đi qua, bạn sẽ phải lưu trữ các giá trị trong mảng theo thứ tự chúng xuất hiện trong thời gian truyền tải. Điều này sẽ giúp bạn khôi phục các thuộc tính của cây nhị phân và cũng sẽ duy trì thứ tự của các yếu tố.perform a level order traversal. And as you keep traversing, you'll have to store the values in the array in the order they appear during the traversal. This will help you in restoring the properties of a binary tree and will also maintain the order of elements.
Cho một mảng đại diện cho một cây theo cách mà các chỉ mục mảng là các giá trị trong các nút cây và giá trị mảng cung cấp cho nút cha của chỉ mục cụ thể đó (hoặc nút).Giá trị của chỉ mục nút gốc sẽ luôn là -1 vì không có cha mẹ cho root.
