OPTIMIZING THE JAVA VIRTUAL MACHINE INSTRUCTION SET BY ...

208
sequences at any level in the tree will be at most n and the number of lists for any
one node within the tree will be constrained by |Σ| + |L|. As a result, performing the
multiway merge for each level in the tree is O(n log(|Σ| + |L|)).
The multiway merge is the most expensive operation that must be performed.
Each of the loops based on the number of children of the node is known to be O(n)
because the number of leaves in the entire tree is O(n). Similarly, CountUniqueOccurrences,
shown in Figure 9.6, executes in linear time because the number of elements
in the list being checked will never be larger than the number of leaves in the tree.
As a result, it is concluded that the complexity of the algorithm is O(n log(|Σ| + |L|))
for each level in the tree.
In the worst case, the number of levels in a suffix tree is equal to n resulting in
an overall complexity of O(n 2 log(|Σ| + |L|)). However, this worst case only occurs
in pathological cases. Studies have been conducted that show, contrary to the worst
case height, the expected height of a suffix tree is O(log n) [40, 15, 67]. Because
the height of the tree in the expected case is O(log n) and the complexity of the
NonOverlappingOccurrences algorithm is O(n log(|Σ| + |L|)) per level in the tree, it
is concluded that the overall complexity of the algorithm is O(n log n log(|Σ| + |L|)).
The NonOverlappingScore algorithm is O(n) in space. By its construction, a suffix
tree is O(n), containing at most 2n nodes. After leaf node splitting is performed, the
total number of nodes has grown to 3n at most. The other data structure required
for this algorithm is the list of starting positions for each occurrence of the string
represented by a node. While it is necessary to maintain the list for the current node,
these lists can be discarded once the node has been processed. As a result, each
starting position only ever exists in at most two lists: one of the lists pointed to by
the ChildPositions array for the current node and within the Retval array for the
current node. Consequently, the number of elements that may be stored at any time
is bounded by 2n, making the space requirement for their storage O(n).
After this algorithm executes the number of non-overlapping substrings has been
determined and the resulting score has been computed. Again, the score may be
stored in the node and used subsequently or single variables may be used to store the
best string and score encountered so far. Figure 9.7 shows the tree after scoring has
been performed using the NonOverlappingOccurrences algorithm. It shows that the
best substring is ab with a score of 10 – a different result than the string abab which
was achieved when overlapping strings were permitted.