Facebook面试题 check for subText in input text's subarray.

97人阅读 评论(0)

This question is a follow up for question for Suffix array sorting.
Based on the output of last question, we are given an input array int[] substext. We want to check for the existance of this subText in the text array. We already have the output sorted_suffix_array.
The output of this question is a boolean value isExist indicating the existance of the subText in the text.

The program need to run in time less than O(N^2)

• Analysis:

For this question, since we are going to find something that is already sorted, it is possible that binary search is suitable. Since the sorted_suffix_array is based on lexical order,
it is possible to use binary search for each position, i.e. First binary search for the first position in subtext, then second, then third.

The time complexity for this code is O(mlogn) where O(logn) is for the binary search in length n array and O(m) is for checking the length m subarray with subText in each binary search iteration.
The space complexity is O(1) without considering the sortedSuffix array since we are only using constant number of variables and passing pointers each time.

The implementation in Java is showed as following:

public class Solution {
public boolean isExistSubText(int[] text, int[] subText) {
//corner cases
if(text == null || text.length == 0) return false;
if(subText == null || subText.length == 0) return true;

int[] sortedSuffix = suffixSort(text);

return binarySearch(text, subText, sortedSuffix, 0, text.length - 1);

}

private boolean binarySearch(int[] text, int[] subText, int[] sortedSuffix, int start, int end) {
int m = subText.length;
while(end >= start) {
int mid = start + (end - start) / 2;
int cmp = compare(text, sortedSuffix[mid], m, subText);
if(cmp == 0) {
return true;
}
else if(cmp < 0) {
start = mid + 1;
}
else {
end = mid - 1;
}
}

return false;
}

private int compare(int[] text, int start, int length, int[] subText) {
if (start + length >= text.length) {
return text[start] > subText[0] ? 1 : -1;
}

int p1 = start, p2 = 0;

while (p1 < start + length && p2 < length) {
if (text[p1] != subText[p2]) {
return text[p1] - subText[p2];
}
else {
p1++;
p2++;
}
}

return 0;
}
}

Note suffixSort() function is in Suffix array sorting.
I copied is as following in order for quick reference.

public class Solution {
class Suffix {
int index;
int[] array;

public Suffix(int index, int[] array) {
this.index = index;
this.array = array;
}
}

public int[] suffixSort(int[] text) {
if (text == null || text.length == 0) return new int[]{};

List<Suffix> suffixList = new ArrayList<>();
for(int i = 0; i < text.length; i++) {
}

int l = text.length;
Collections.sort(suffixList, new Comparator<Suffix>() {
@Override
public int compare(Suffix s1, Suffix s2) {
int i = 0;
for(; i < Math.min(l - s1.index, l - s2.index); i++) {
if(s1.array[i] < s2.array[i]) {
return -1;
}
else if(s1.array[i] > s2.array[i]) {
return 1;
}
}
return i == l - s1.index ? -1 : 1;
}
});

int[] ret = new int[l];
int j = 0;

for(Suffix s : suffixList) {
ret[j++] = s.index;
}

return ret;
}
}
0
0

* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
个人资料
• 访问：24257次
• 积分：838
• 等级：
• 排名：千里之外
• 原创：59篇
• 转载：1篇
• 译文：4篇
• 评论：1条
文章分类
我的GitHub
阅读排行