#面试系列 字符串处理算法

面试系列 字符串处理算法

最大子序列和

动态规划法

思路：顺序遍历，判断sum是否大于等于0

时间复杂度：O(n)

空间复杂度：O(1)

#include <iostream>
#include <limits.h>

using namespace std;

int getMaxSum(int *arr, int size) {
int maxSum = INT_MIN; //负的无穷大
int sum = 0;
int curstart = 0;
int start = 0;
int end = 0;

for (int i=0; i<size; i++) {
if (sum<0) {
sum = arr[i];
curstart = i; //记录起始位置
} else {
sum += arr[i];
}

if (sum > maxSum) {
maxSum = sum;
start = curstart; //保存起始位置
end = i; //保存结束为止
}
}
return maxSum;
}

int main(int argc, char *argv[]) {

int arr[] = {0, -2, 3, 5, -1, 2};
int maxSum = getMaxSum(arr, 6);
printf("max sum is : %d", maxSum);
return 0;
}

分治法

思路：左右分治比中间，递归返回取大小

时间复杂度：O(n)

空间复杂度：O(1)

#include <iostream>

using namespace std;

int getMax(int a, int b, int c) {
int max = a;
if (b > max){
max = b;
}
if (c > max){
max = c;
}
return max;
}

int getMaxSum(int *arr, int left, int right) {
if (left == right){
if (arr[left]>0)
return arr[left];
else
return 0;
}
int mid = (left + right)/2;
int maxLeftSum = getMaxSum(arr, left, mid);
int maxRightSum = getMaxSum(arr, mid+1, right);

int maxLeftBorderSum = 0, leftBorderSum = 0;
for (int i= mid; i>=left; i--){
leftBorderSum += arr[i];
if(leftBorderSum > maxLeftBorderSum)
maxLeftBorderSum = leftBorderSum;
}
int maxRightBorderSum = 0, rightBorderSum = 0;
for (int j = mid+1; j<=right; j++){
rightBorderSum += arr[j];
if(rightBorderSum>maxRightBorderSum)
maxRightBorderSum = rightBorderSum;
}
return getMax(maxLeftSum, maxRightSum, maxLeftBorderSum + maxRightBorderSum);

}

int main(int argc, char *argv[]) {
int arr[] = {0, -2, 3, 5, -1, 2};
int maxSum = getMaxSum(arr, 0, 5);
printf("max sum is : %d", maxSum);
return 0;
}

最长递增子序列 (LIS)

动态规划法

思路：i,j循环，存储每个位置的最长递增子序列的长度

时间复杂度：O(n^2)

空间复杂度：O(n)

#include <iostream>

using namespace std;

int len[101];
int maxLen;

int LIS(int *arr, int size) {
for (int i=0; i<size; ++i) {
len[i] = 1;
for (int j=0; j<i; ++j) {
if (arr[i]>arr[j] && len[i] < len[j]+1){
len[i] = len[j]+1;
if(len[i]>maxLen){
maxLen = len[i];
}
}
}
}
return maxLen;
}

void outputLIS(int *arr, int index){
bool isLIS = 0;
if (index<0||maxLen==0)
return;
if (len[index]==maxLen){
--maxLen;
isLIS = 1;
}
outputLIS(arr, --index);

if (isLIS)
printf("%d ", arr[index+1]);
}

int main(int argc, char *argv[]) {
int arr[] = {1,-1,2,-3,4,-5,6,-7};
printf("%d\n",LIS(arr,sizeof(arr)/sizeof(int)));
outputLIS(arr,sizeof(arr)/sizeof(int) - 1);
printf("\n");
}

动归+二分查找

思路：i循环，存储递增元素至 新的数组

时间复杂度：O(n)

空间复杂度：O(n)

#include <iostream>

using namespace std;

int maxArr[30];
int len;

int BinSearch(int *maxArr, int size, int x) {
int left = 0, right = size -1;
while(left<=right){
int mid = (left+right)/2;
if (maxArr[mid] <= x){
left = mid +1;
} else {
// right < left maxArr[]覆盖
right = mid -1;
}
}
return left;
}

int LIS(int *arr, int size) {
maxArr[0] = arr[0];
len = 1;
for (int i=1; i<size; ++i){
if (arr[i] > maxArr[len-1]){
maxArr[len] = arr[i];
len++;
} else {
int pos = BinSearch(maxArr, len, arr[i]);
maxArr[pos] = arr[i];
}
}
return len;
}

int main(int argc, char *argv[]) {
int arr[] = {1,-1,2,-3,4,-5,6,-7};
printf("%d\n",LIS(arr,sizeof(arr)/sizeof(int)));
return 0;
}

最长公共子串 (LCS)

矩阵法

思路：矩阵的对角线，右下依次加一

时间复杂度：O(n^2)

空间复杂度：O(n)

举个例子

bab

和

caba

, 二维矩阵如下：





我们需要的是某一行和上一行，所以可以用一位数组来代替矩阵。

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
//str1为横向，str2这纵向
const string LCS(const string& str1,const string& str2){
int xlen=str1.size();       //横向长度
vector<int> tmp(xlen);      //保存矩阵的上一行
vector<int> arr(xlen);      //当前行
int ylen=str2.size();       //纵向长度
int maxele=0;               //矩阵元素中的最大值
int pos=0;                  //矩阵元素最大值出现在第几列
for(int i=0;i<ylen;i++){
string s=str2.substr(i,1);
arr.assign(xlen,0);     //数组清0
for(int j=0;j<xlen;j++){
if(str1.compare(j,1,s)==0){
//compare(a,b) //<0:  a < b
//=0:  a == b  //>0:  a > b
if(j==0)
arr[j]=1;
else
arr[j]=tmp[j-1]+1;
if(arr[j]>maxele){
maxele=arr[j];
pos=j;
}
}
}
tmp.assign(arr.begin(),arr.end());
}
string res=str1.substr(pos-maxele+1,maxele);
//substr(a,b):从下标a开始，长度为b
return res;
}
int main(){
string str1("21232523311324");
string str2("312123223445");
string lcs=LCS(str1,str2);
cout<<lcs<<endl;
return 0;
}

最长公共子序列

递归法

思路: i,j标记，a[i]==b[j]分情况，向后递归

对于a[0…n],b[0..m],

如果a[i]==b[j], 1+ LCS(i+1,j+1);

如果a[i]!=b[j], max(LCS(i,j+1),LCS(i+1,j));



时间复杂度：O(n^2)

空间复杂度：O(n)

#include<stdio.h>
#include<string.h>
char a[100],b[100];
int lena,lenb;
int LCS(int,int);///两个参数分别表示数组a的下标和数组b的下标
int main()
{
strcpy(a,"ABCBDAB");
strcpy(b,"BDCABA");
lena=strlen(a);
lenb=strlen(b);
printf("%d\n",LCS(0,0));
return 0;
}
int LCS(int i,int j)
{
if(i>=lena || j>=lenb)
return 0;
if(a[i]==b[j])
return 1+LCS(i+1,j+1);
else
return LCS(i+1,j)>LCS(i,j+1)? LCS(i+1,j):LCS(i,j+1);
}

动态规划法

思路：矩阵标记，向右、向下、向右下传值

时间复杂度：O(n^2)

空间复杂度：O(n^2)



使用二维数组flag标记下标i和j的走向，数字‘1’表示：斜向下；数字‘2’表示：向右；数字‘3’表示：向下。



通过行进的路径，可以得到最长公共子序列。

#include<stdio.h>
#include<string.h>
char a[500],b[500];
char num[501][501]; ///记录中间结果的数组
char flag[501][501];    ///标记数组，用于标识下标的走向，构造出公共子序列
void LCS(); ///动态规划求解
void getLCS();    ///采用倒推方式求最长公共子序列
int main()
{
int i;
strcpy(a,"ABCBDAB");
strcpy(b,"BDCABA");
LCS();
printf("%d\n",num[strlen(a)][strlen(b)]);
getLCS();
return 0;
}
void LCS()
{
int i,j;
for(i=1;i<=strlen(a);i++)
{
for(j=1;j<=strlen(b);j++)
{
if(a[i-1]==b[j-1])   ///注意这里的下标是i-1与j-1
{
num[i][j]=num[i-1][j-1]+1;
flag[i][j]=1;  ///斜向下标记
}
else
{
if(num[i][j-1]>num[i-1][j])
{
num[i][j]=num[i][j-1];
flag[i][j]=2;  ///向右标记
}
else
{
num[i][j]=num[i-1][j];
flag[i][j]=3;  ///向下标记
}
}
}
}
}
void getLCS()
{
char res[500];
int i=strlen(a);
int j=strlen(b);
int k=0;    ///用于保存结果的数组标志位
while(i>0 && j>0)
{
if(flag[i][j]==1)   ///如果是斜向下标记
{
res[k]=a[i-1];
k++;
i--;
j--;
}
else if(flag[i][j]==2)  ///如果是斜向右标记
j--;
else if(flag[i][j]==3)  ///如果是斜向下标记
i--;
}
for(i=k-1;i>=0;i--){
printf("%c",res[i]);
}

}

最长不重复子串

Hash法

思路：i循环，j=i+1向后循环，通过hash[256]判重

时间复杂度：O(n^2)

空间复杂度：O(l)

#include <iostream>

using namespace std;

int maxlen;
int maxindex;
char visit[256];

void output(char * arr){
for(int i= maxindex; i< maxlen+maxindex; i++){
printf("%c", arr[i]);
}
}

void LNRS_hash(char * arr, int size)
{
for(int i = 0; i < size; ++i)
{
memset(visit,0,sizeof(visit)); //清空hash表，重要
visit[arr[i]] = 1;
for(int j = i+1; j < size; ++j)
{
if(visit[arr[j]] == 0)
{
visit[arr[j]] = 1;
}
else
{
if(j-i > maxlen)
{
maxlen = j - i;
maxindex = i;
}
break;
}
}
}
output(arr);
}

int main(int argc, char *argv[]) {
char arr[11] = "abcabcdcba"; //最后一个为'/0'
LNRS_hash(arr, 10);
return 0;
}

动态规划法

思路：i循环，j=i-1向前循环,判重

时间复杂度：O(n^2)

空间复杂度：O(n)

int dp[100];
void LNRS_dp(char * arr, int size)
{
int i, j;
maxlen = maxindex = 0;
dp[0] = 1;
for(i = 1; i < size; ++i)
{
for(j = i-1; j >= 0; --j)
{
if(arr[j] == arr[i])
{
dp[i] = i - j;
break;
}
}
if(j == -1)
{
dp[i] = dp[i-1] + 1;
}
if(dp[i] > maxlen)
{
maxlen = dp[i];
maxindex = i + 1 - maxlen;
}
}
output(arr);
}

动归+hash+空间优化

思路：一边遍历，hash记下标

时间复杂度：O(n)

空间复杂度：O(1)

void LNRS_dp_hash(char * arr, int size)
{
memset(visit, -1, sizeof visit);
maxlen = maxindex = 0;
visit[arr[0]] = 0;
int curlen = 1;
for(int i = 1; i < size; ++i)
{
if(visit[arr[i]] == -1)
{
++curlen;
visit[arr[i]] = i; /* 记录字符下标 */
}
else
{
curlen = i - visit[arr[i]];
visit[arr[i]] = i; /* 更新字符下标 */
}
if(curlen > maxlen)
{
maxlen = curlen;
maxindex = i + 1 - maxlen;
}
}
output(arr);
}

最长回文子串

思路：i遍历str,以i为中心，左右两端寻找

时间复杂度：O(n^2)

空间复杂度：O(1)

string findLPS(const string &str)
{
int center = 0, max_len = 0;
for(int i = 1; i < str.length()-1; ++i)
{
int j = 1;
//以str[i]为中心，依次向两边扩展，寻找最长回文Pi
while(i+j < str.length() && i-j >= 0 && str[i+j] == str[i-j])
++j;
--j;
if(j > 1 && j > max_len)
{
center = i;
max_len = j;
}
}
return str.substr(center-max_len, (max_len * 2) + 1);
}

写在后面的话：

本片博客主要参考 寒小阳的博客 找工作知识储备(2) 对作者表示。

另外，我会参考更多的资料，整理补充本篇博客。