Segment Tree Build I & II

Segment Tree Build I

The structure of Segment Tree is a binary tree which each node has two attributes

start

and

end

denote an segment / interval.

start and end are both integers, they should be assigned in following rules:

The root's start and end is given by

build

method.

The left child of node A has

start=A.left, end=(A.left + A.right) / 2

.

The right child of node A has

start=(A.left + A.right) / 2 + 1, end=A.right

.

if start equals to end, there will be no children for this node.

Implement a

build

method with two parameters start and end, so that we can create a corresponding segment tree with every node has the correct start andend value, return the root of this segment tree.

Clarification

Segment Tree (a.k.a Interval Tree) is an advanced data structure which can support queries like:

which of these intervals contain a given point

which of these points are in a given interval

Example

Given

start=0, end=3

. The segment tree will be:

[0,  3]
/        \
[0,  1]           [2, 3]
/     \           /     \
[0, 0]  [1, 1]     [2, 2]  [3, 3]

Given

start=1, end=6

. The segment tree will be:

[1,  6]
/        \
[1,  3]           [4,  6]
/     \           /     \
[1, 2]  [3,3]     [4, 5]   [6,6]
/    \           /     \
[1,1]   [2,2]     [4,4]   [5,5]

分析：
简单，递归而已。

/**
* Definition of SegmentTreeNode:
* public class SegmentTreeNode {
*     public int start, end;
*     public SegmentTreeNode left, right;
*     public SegmentTreeNode(int start, int end) {
*         this.start = start, this.end = end;
*         this.left = this.right = null;
*     }
* }
*/
public class Solution {
/**
*@param start, end: Denote an segment / interval
*@return: The root of Segment Tree
*/
public SegmentTreeNode build(int start, int end) {
if (start > end ) return null;

if (start == end) {
return new SegmentTreeNode(start, start);
} else {
SegmentTreeNode root = new SegmentTreeNode(start, end);
root.left = build(start, (start + end) / 2);
root.right = build((start + end) / 2 + 1, end);
return root;
}
}
}

Segment Tree Build II

The structure of Segment Tree is a binary tree which each node has two attributes

start

and

end

denote an segment / interval.

start and end are both integers, they should be assigned in following rules:

The root's start and end is given by

build

method.

The left child of node A has

start=A.left, end=(A.left + A.right) / 2

.

The right child of node A has

start=(A.left + A.right) / 2 + 1, end=A.right

.

if start equals to end, there will be no children for this node.

Implement a

build

method with a given array, so that we can create a corresponding segment tree with every node value represent the corresponding interval max value in the array, return the root of this segment tree.

Have you met this question in a real interview?

Yes

Clarification

Segment Tree (a.k.a Interval Tree) is an advanced data structure which can support queries like:

which of these intervals contain a given point

which of these points are in a given interval

Example

Given

[3,2,1,4]

. The segment tree will be:

[0,  3] (max = 4)
/            \
[0,  1] (max = 3)     [2, 3]  (max = 4)
/        \               /             \
[0, 0](max = 3)  [1, 1](max = 2)[2, 2](max = 1) [3, 3] (max = 4)

分析：
和上题一样，多了一个max而已。

/**
* Definition of SegmentTreeNode:
* public class SegmentTreeNode {
*     public int start, end, max;
*     public SegmentTreeNode left, right;
*     public SegmentTreeNode(int start, int end, int max) {
*         this.start = start;
*         this.end = end;
*         this.max = max
*         this.left = this.right = null;
*     }
* }
*/
public class Solution {

public SegmentTreeNode build(int[] A) {
if (A == null || A.length == 0) return null;

return build(A, 0, A.length - 1);
}

public SegmentTreeNode build(int[] A, int start, int end) {
if (start > end) return null;

if (start == end) {
return new SegmentTreeNode(start, end, A[start]);
} else {
SegmentTreeNode root = new SegmentTreeNode(start, end, 0);
root.left = build(A, start, (start + end) / 2);
root.right = build(A, (start + end) / 2 + 1, end);
root.max = Math.max(root.left.max, root.right.max);
return root;
}
}
}