题目四：替换空格

char* StrReplace(char* pszStr, int iLen, char ch, const char* pszReStr)
{
    assert(pszStr != NULL && pszReStr != NULL &&iLen >= 0);

    char* pTmp = pszStr;
    int iFindNum = 0;

    // 1.查找字符串中ch个数
    while (*pTmp != ‘\0‘)
    {
        if (*pTmp++ == ch)
        {
            iFindNum++;
        }
    }

    // 2.新字符串长度
    int iOldLen = strlen(pszStr);
    int iReLen = strlen(pszReStr);
    int iNewLen = iOldLen + (iReLen - 1)* iFindNum; // 这里减1 待替换字符串长度 - 原来字符长度
    if (iNewLen > iLen)
    {
        return NULL;
    }

    // 3.从后往前赋值字符串
    // 这里为什么不用 i = iOldLen - 1;  --> 复制最后的‘\0‘;
    for (int i = iOldLen; i >= 0 && iNewLen > i; i--)
    {
        if (pszStr[i] == ch)
        {
            for (int j = iReLen - 1; j >= 0; j--)
            {
                pszStr[iNewLen--] = pszReStr[j];
            }
        }
        else
        {
            pszStr[iNewLen--] = pszStr[i];
        }
    }

#if 0
    while (iOldLen >= 0 && iNewLen > iOldLen)
    {
        if (pszStr[iOldLen] == ch)
        {
            for (int i = iReLen - 1; i >= 0; i--)
            {
                pszStr[iNewLen--] = pszReStr[i];
            }
        }
        else
        {
            pszStr[iNewLen--] = pszStr[iOldLen];
        }

        iOldLen--;
    }

#endif

    return pszStr;

}

void StrReplaceTestFunc()
{
    cout << "\n\n --------------- StrReplaceTestFunc Start -------------->" << endl;

    const int MAX_STR_LEN = 128;
    char szStr[MAX_STR_LEN] = "We Are Happy !";

    StrReplace(szStr, MAX_STR_LEN, ‘ ‘, "%20");

    cout << "Str: " << szStr << endl;

    StrReplace(szStr, MAX_STR_LEN, ‘!‘, "------->");

    cout << "Str: " << szStr << endl;

    cout << "\n\n --------------- StrReplaceTestFunc End -------------->" << endl;

}

//方法一：从前往后比较，需要额外的空间
//时间复杂度O(2n), 空间复杂度O(n)
void MergeTwoArray1(int aiArrayA[], int iNumA, int aiArrayB[], int iNumB)
{
    const int MAX_ARRAY_COUNT = iNumA + iNumB;
    vector<int> vect(MAX_ARRAY_COUNT, 0);

    int i = 0, j = 0, k = 0;
    
    // 1. 比较两个数组，把较小的加入新的数组
    while (i < iNumA &&j < iNumB)
    {
        if (aiArrayA[i] < aiArrayB[j])
        {
            vect[k++] = aiArrayA[i++];
        }
        else
        {
            vect[k++] = aiArrayB[j++];
        }
    }

    // 2.把剩余的元素加到新数组
    while (i < iNumA)
    {
        vect[k++] = aiArrayA[i++];
    }

    while (j < iNumB)
    {
        vect[k++] = aiArrayB[j++];
    }

    // 3.把数据复制到数组A
    k = 0;
    for (auto it : vect)
    {
        aiArrayA[k++] = it;
    }
}

// 方法二：从后往前比较，不需要额外的空间
//时间复杂度O(n), 空间复杂度O(1)
void MergeTwoArray2(int aiArrayA[], int iNumA, int aiArrayB[], int iNumB)
{
    int iNewNum = iNumA + iNumB - 1;
    int i = iNumA - 1;
    int j = iNumB - 1;
    
    // 从数组后往前比较，就不存在重叠的情况了！！！
    while (i >= 0 && j >= 0)
    {
        if (aiArrayA[i] > aiArrayB[j])
        {
            aiArrayA[iNewNum--] = aiArrayA[i--];
        }
        else
        {
            aiArrayA[iNewNum--] = aiArrayB[j--];
        }
    }

    while (i >= 0)
    {
        aiArrayA[iNewNum--] = aiArrayA[i--];
    }

    while (j >= 0)
    {
        aiArrayA[iNewNum--] = aiArrayB[j--];
    }

}

void MergeTwoArrayTestFunc()
{
    cout << "\n\n --------------- MergeTwoArrayTestFunc Start -------------->" << endl;
    const int MAX_ARRAY_COUNT_A = 30;
    const int MAX_ARRAY_COUNT_B = 10;

    int aiArrayA[MAX_ARRAY_COUNT_A] = {0};
    int aiArrayB[MAX_ARRAY_COUNT_B] = {0};

    INITIALIZE_ARRAY(aiArrayA, MAX_ARRAY_COUNT_B);
    INITIALIZE_ARRAY(aiArrayB, MAX_ARRAY_COUNT_B);

    std::sort(aiArrayA, aiArrayA + MAX_ARRAY_COUNT_B);
    std::sort(aiArrayB, aiArrayB + MAX_ARRAY_COUNT_B);

    TRAVERSAL_ARRAY(aiArrayA, MAX_ARRAY_COUNT_B);
    TRAVERSAL_ARRAY(aiArrayB, MAX_ARRAY_COUNT_B);

    //MergeTwoArray1(aiArrayA, MAX_ARRAY_COUNT_B, aiArrayB, MAX_ARRAY_COUNT_B);
    MergeTwoArray2(aiArrayA, MAX_ARRAY_COUNT_B, aiArrayB, MAX_ARRAY_COUNT_B);


    TRAVERSAL_ARRAY(aiArrayA, MAX_ARRAY_COUNT_A);

    cout << "\n\n --------------- MergeTwoArrayTestFunc Start -------------->" << endl;

}