阿里二面

实现细节

这一次相对于一面来讲，涉及到项目中的技术实现细节更加深入，对于实现的数据分析和逻辑漏斗追问的更加详细，由于时间比较紧张准备不足，这次面试中的技术点交流并不流畅，有些实现细节描述不清，估计会止步于此.

算法

这次提到最长回文字串的查找，这是一道非常常规的算法题，然而由于过于紧张只记得Manacher算法，但是对于具体的查找实现没能描述清楚，超级尴尬.
其实面试官并不要求你会最牛逼的算法，只要有思路即可。比如这样一种实现：

// 判断s中索引[i, j]是不是回文序列
bool isPalindrome(char *s, int i, int j) {
int start = i;
int end = j;
	while (!(i > j)) {
		if (s[i] != s[j]) {
			return false;
		}
        i++;
        j--;
	}
	return true;
}

char * longestPalindrome(char * s){
int length = strlen(s);
int start = 0;
int end = 0;
for (int i = 0; i < length; i++) {
	for (int j = i; j < length; j++) {
		if (j - i > end - start && isPalindrome(s, i, j)) {
			start = i;
			end = j;
		}
	}
}
char *result = malloc(sizeof(char) * (end - start + 2));
memset(result, 0, sizeof(char) * (end - start + 2));
memcpy(result, s + start, end - start + 1);
return result;
}

这个算法虽然不怎么高效，但是在LeetCode中是可以通过的。

其他算法

• 动态规划
  这里假设已经知道区间$[i+1,j-1]$是一个回文串，那么区间$[i,j]$是不是回文串串只需要知道$s[i]==s[j]$是否成立即可.
  这里的初始条件是$i==j$时，区间$[i,j]$肯定是回文字串；$j=i+1$时，只要$s[i]==s[j],$则区间$[i,j]$肯定也是回文字串。

char * longestPalindrome(char * s) {
int length = strlen(s);
bool **dp = malloc(sizeof(bool *) * length);
for (int index = 0; index < length; index++) {
	bool *ele = malloc(sizeof(bool) * length);
	memset(ele, 0, sizeof(bool) * length);
	dp[index] = ele;
}

// 记录最长回文串起始位置
int startIndex = 0;
int endIndex = 0;
// 字串长度
for (int len = 0; len < length; len++ ) {
	for (int start = 0; start + len < length; start++) {
			int end = start + len;
			if(len == 0) {
				dp[start][end] = true;
			} else if (len == 1) {
				dp[start][end] = s[start] == s[end];
			} else {
			    dp[start][end] = (dp[start + 1][end - 1]) && (s[start] == s[end]);
			}
            if (dp[start][end] && end - start > endIndex - startIndex ) {
	            endIndex = end;
	            startIndex = start;
            }
	    }
    }
    free(dp);
    dp = NULL;
    char *result = malloc(sizeof(char) * (endIndex - startIndex + 2));
    memset(result, 0, sizeof(char) * (endIndex - startIndex + 2));
    memcpy(result, s + startIndex, sizeof(char) * (endIndex - startIndex + 1));
    return result;
}

• Manacher算法
  这是一个很经典但是也很让人头疼的算法，此处略。