字符串与数组编程

//检测子串如abcd,bc,输出bc
//一定要注意指针的用法，千万不要乱用
const char* strStr(const char*src, const char* sub)
{
    //判断非空
    if (nullptr == src || nullptr == sub)
        return nullptr;
    while (*src)
    {
        const char*psrc = src, *psub = sub;
        do
        {
            if (!*psub)//如果到了sub的结束位置
                return src;
        } while (*psrc++==*psub++);
        src++;
    }
    return nullptr;
}

将字符串i am from shanghai，变成shanghai from am i

char* revStr(char *str)
{
    if (nullptr == str)
        return nullptr;
    char *start = str, *end = str, *pstr = str;
    while (*pstr++!='\0')
    {
        if (*pstr == ' ' || *pstr == '\0')
        {
            end = pstr - 1;
            while (start<end)//避免了一个字符的交换
            swap(*start++, *end--);
            start = end = pstr + 1;
        }   
    }
    //整体交换一次
    start = str, end = pstr - 2;
    while (start < end)
        swap(*start++, *end--);
    return str; 
}

在字符串中删除指定字符

char* deleteChar(char* str, char c)
{
    if (nullptr == str)
        return nullptr;
    char*start = str;
    char*head= str;
    while (*start)
    {
        if (*start!=c)//当其不是指定元素是赋值
        {
            *head++= *start;
        }
        start++;
    }
    *head = '\0';//注意
    return str;
}

在字符串的指定位置删除指定个数的字符

char* deleteChars(char* str, int pos,int len)
{
    if (nullptr == str)
        return nullptr;
    int tt = strlen(str);
    char* start = str + pos - 1;//开始位置
    char* end = start + len;//结束位置
    if ((len<1) || (start - str)>tt)
        return str;
    //画图去看他的情况
    if ((start + len-str) >tt )
    {
        *start= '\0';
        return str;
    }
    //循环赋值
    while (*end)
        *start++ = *end++;
    *start = '\0';
    return str;
}

字符串的循环右移

char*  loopMove(char* str, int n)
{
    if (nullptr == str)
        return nullptr;
    char* head = str;
    int len = strlen(str);
    int move_n = n%len;//要移动的位数，因为n很大时的做法
    char *p = str + len - move_n-1;//定位到该指针要移到末尾
    char* end = str + len - 1;
    char *temp = new char[n + 1];
    //先将最后到字符串头的元素去除
    for (int i = 0; i < move_n; i++)
        temp[i] = head[len-i-1];
    //循环移位
    for (int i = len-1; i >=n; i--)
        head[i]=head[i-n];
    //添加
    for (int i = 0; i < move_n; i++)
        head[i] = temp[move_n-i-1];
    return str;
}

两个串的最大公共子串

char *commonString(char* str1, char* str2)
{
    if (nullptr == str1 || nullptr == str2)
        return nullptr;
    int len1 = strlen(str1), len2 = strlen(str2);
    char *shortstr, *longstr, *substr;
    if (len1 >= len2)
    {
        longstr = str1;
        shortstr = str2;
    }
    else
    {
        longstr = str2;
        shortstr = str1;
    }
    if (strstr(longstr, shortstr) != nullptr)
        return shortstr;
    substr = new char[len2 + 1];
    //i是指示个数的参数,即将多少个元素复制到substr
    for (int i = len2 - 1; i > 0; i--)
    {
        //从那开始复制
        for (int j = 0; j <=len2 - 1; j++)
        {
            memcpy(substr, &shortstr[j], i);
            substr[i] = '\0';
            if (strstr(longstr, substr) != nullptr)
                return substr;
        }
    }
    return nullptr;
}