使用交换和递归在 C 和 C++ 中的字符串反向性能

Posted 2023-02-17

【中文标题】使用交换和递归在 C 和 C++ 中的字符串反向性能

【英文标题】：String reverse performance in C & C++ using swapping and recursion

【发布时间】：2015-07-16 18:42:56

【问题描述】：

我正在练习我的 C 和 C++ 技能，然后我决定使用两种语言中使用的方法来解决字符串反转问题。我写了一个递归解决方案和索引方法。这里有4个反向功能； 2 个使用严格的 C 方法进行计算，另外 2 个使用 C++（STL、String、算法）调用。

这是一个很好的比较来查看每种方法的速度还是我 遗漏了什么？ 另外我想知道每个有多少内存 方法使用，但我还没有想出如何做到这一点。

// C++ reverse string
#include <string> // string
#include <algorithm> // reverse
#include <iostream> // cout

#include <cstring> // std::strcpy
#include <stdio.h> // printf
#include <sys/time.h> // gettimeofday

inline void swap_characters(char* left, char* right) 
    char temp = *left;
    *left = *right;
    *right = temp;


void c_index_reverse(char* input, size_t inputSize) 

    const size_t strSize = inputSize - 1;
    char temp;

    for(int i=0 ; i < inputSize / 2 ; i++) 
        swap_characters(&input[i], &input[strSize - i]);
    


void c_recursive_reverse(char str[], int index, int size)

    swap_characters(&str[index], &str[size - index]);

    if (index == size / 2)
        return;

    c_recursive_reverse(str, index + 1, size);



void c_plusplus_index_reverse(std::string& input) 

    const size_t strSize = input.length();

    for(int i=0 ; i < strSize / 2 ; i++)
        std::swap(input[i], input[strSize - i - 1]);



std::string c_plusplus_recursive_reverse(std::string& input) 

    if(input.length() <= 1) 
        return input;
    

    std::string tmp = std::string(input.begin() + 1, input.end());
    return c_plusplus_recursive_reverse(tmp) + input[0];



double timeit(struct timeval &start, struct timeval &end)
    double delta = ((end.tv_sec - start.tv_sec) * 1000000u + end.tv_usec - start.tv_usec) / 1.e6;
    return delta;


int main() 

    struct timeval start,end;

    // using C++ STL
    std::string temp = "something very weird is another word that includes a longer text to see the delay" \
    "something very weird is another word that includes a longer text to see the delay" \
    "something very weird is another word that includes a longer text to see the delay" \
    "something very weird is another word that includes a longer text to see the delay" \ 
    "something very weird is another word that includes a longer text to see the delay" \
    "something very weird is another word that includes a longer text to see the delay" \
    "something very weird is another word that includes a longer text to see the delay";
    std::cout << temp << std::endl;

    // using c++ recursive reverse function - 4
    gettimeofday(&start, NULL);
    std::reverse(temp.begin(), temp.end());
    gettimeofday(&end, NULL);

    std::cout << temp << std::endl;
    printf("%lf \n",timeit(start, end));


    // use C++ style functions
    // using recersive - 5
    gettimeofday(&start, NULL);
    temp = c_plusplus_recursive_reverse(temp);
    gettimeofday(&end, NULL);
    std::cout << temp  << std::endl;
    printf("%lf \n",timeit(start, end));

    // using index reverse - 3
    gettimeofday(&start, NULL);
    c_plusplus_index_reverse(temp);
    gettimeofday(&end, NULL);
    std::cout << temp << std::endl;
    printf("%lf \n",timeit(start, end));



    // Now do C style
    char *cStr = new char[temp.length() + 1];
    std::strcpy(cStr, temp.c_str());


    // using index - 1
    gettimeofday(&start, NULL);
    c_index_reverse(cStr, temp.length());
    gettimeofday(&end, NULL);
    printf("%s \n", cStr);
    printf("%lf \n",timeit(start, end));


    // using recersive - 2
    gettimeofday(&start, NULL);
    c_recursive_reverse(cStr, 0, temp.length() - 1);
    gettimeofday(&end, NULL);
    printf("%s \n", cStr);
    printf("%lf \n",timeit(start, end));


    return 0;

【问题讨论】：

C 或 C++，选择一个。它们不是一回事。

如果你想计时一些代码，首先不要包括任何类型的输入/输出活动（你不这样做很好），除非这是你想要测量的。与大多数其他代码相比，输入和输出通常非常慢。其次，您应该多次执行该操作，并获得平均（可能是最小/最大）次，执行该操作的次数越多，统计属性就越好。只为单个函数调用计时是没有用的，尤其是在抢占式多任务系统上。

@Armen B. 我确信递归函数最多应该有两个参数，例如 void c_recursive_reverse(char str[], size_t size);

@Barry：我包含了仅使用 C++ 方法的函数，以及仅使用 C 方法的函数。

@JoachimPileborg：好点，我将多次运行该函数并取平均值

【参考方案1】：

拥有一个内联函数swap_characters() 只需三行代码就可以完成一项大工作，当您已经拥有它们时会创建更多指针（尽管编译器可能会进行优化）。使用另一个索引变量，比如 j，它会递减直到满足 i 会更有效。

void c_index_reverse(char* input, size_t inputSize) 

    int j = inputSize - 1;
    char temp;

    for(int i=0; i<j; i++) 
        temp = input[i];
        input[i] = input[j];
        input[j--] = temp;
    

“我还想知道每种方法使用了多少内存”。非递归方法使用最少的内存，因为它只使用指针和索引器。但是递归方法使用更多的内存，因为每个字符串字符（最多为字符串长度的一半）都会调用递归，因此会使用更多的堆栈。由于您的字符串 "something very weird ..." 大约有 600 个字符，因此堆栈使用量很大，并且大部分执行时间都花在调用、操作堆栈帧和返回上，而交换字符的时间很少。

这里的递归是“无处可藏”。

【讨论】：

不 j-- t 与 inputSize - 1 占用相同数量的周期？

每个循环中还有inputSize / 2。

另外，关于我在理论上理解的内存解释很有意义。我想知道是否有办法查看确切的用法，也许是某种数字格式？

非递归解决方案显然更有效的意义何在？最好把时间花在其他地方。

所以在更复杂的函数上使用相同的方法，并获得两种方法之间的比率比较。

【参考方案2】：

C++ 递归函数真的很糟糕：使用迭代器可以提高速度并且代码更简洁：

void c_plusplus_recursive_reverse(std::string::iterator start, 
    std::string::iterator end) 

    if(start >= end) 
        return;
    

    std::iter_swap(start, end);
    c_plusplus_recursive_swap_reverse(++start, --end);