您将如何改进此算法?(c字符串反转）

<algorithm>中的std::reverse适用于字符串和char数组：

string str = "Hello";
char chx[] = "Hello";
reverse(str.begin(), str.end());
reverse(chx, chx + strlen(chx));
cout << str << endl;
cout << chx << endl;

/编辑：这当然会修改原始字符串。但STL出手相救。下面创建一个新的反向字符串。不幸的是（？），如果不创建额外的（隐式）副本：，这不能直接在char阵列上工作

string reverse_string(string const& old) {
    return string(old.rbegin(), old.rend());
}
cout << reverse_string("Hello") << endl;

我曾经有过这个问题。这是我脑海中浮现的第一个答案，但接下来的答案是，"现在在不分配任何内存的情况下进行。"

int length = strlen(string);
for(int i = 0; i < length/2; i++) {
  char c = string[i];
  string[i] = string[length - i];
  string[length - i] = c;
}

编辑：有些人对不使用指针表示不屑。这是一个稍微可读一点，虽然不是完全优化。其他人已经输入了指针解决方案，所以我在此不再重复。

一位评论者质疑说，在没有（基于堆栈的）交换保持单元的情况下，这应该是可行的。这样做的机制是逐位XOR。用替换环路内部

string[i] = string[i] ^ string[length - i];
string[length - i] = string[i] ^ string[length - i];
string[i] = string[i] ^ string[length - i];

但一般来说，现代编译器可以优化出天真交换的局部变量。有关详细信息，请参阅Wikipedia

if( string[0] )
{
    char *end = string + strlen(string)-1;
    while( start < end )
    {
        char temp = *string;
        *string++ = *end;
        *end-- = temp;
    }
}

您的代码直截了当，不足为奇。几件事：

1. 使用size_t而不是int作为循环索引
2. 虽然您的编译器很可能足够聪明，能够弄清楚（length-1）是不变的，但它可能还不够聪明，无法弄清楚（longth-1）-i最好由一个不同的循环变量代替，该变量在每次循环中都会递减
3. 我会使用指针而不是数组语法——对我来说，使用*dst--=*src++会更干净；在循环中

换句话说：

char *dst = reversed_string + length;
*dst-- = '';
while (*src) {
   *dst-- = *src++;
}

嗯？没有人用指针做这件事？

char *reverse(const char *s) {
    size_t n = strlen(s);
    char *dest = new char[n + 1];
    char *d = (dest + n - 1);
    dest[n] = 0;
    while (*s) {
        *d-- = *s++
    }
    return dest;
}

希望多年的Java没有毁了我的C；-）

编辑：用一个额外的变量替换了所有这些strlen调用。这些天strlen返回了什么？（感谢底座）。

我知道这是非常不可移植的，但x86汇编指令bswap允许您仅通过一条指令交换四个字节，这可能是增强代码的好途径。

这是一个如何让它与GCC一起工作的例子。

/* 
 * reverse.c
 *
 * $20081020 23:33 fernando DOT miguelez AT gmail DOT com$
 */
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX_CHARS 10 * 1024 * 1024
/*
 * Borrowed from http://coding.derkeiler.com/Archive/Assembler/comp.lang.asm.x86/2007-03/msg00004.html
 * GNU Compiler syntax
 */
inline uint32_t bswap(uint32_t val)
{
    __asm__("bswap %0" : "=r" (val) : "0" (val));
    return val;
}
char * reverseAsm(const char * str)
{
    int i;
    int length = strlen(str);
    int dwordLength = length/4;
    if(length % 4 != 0)
    {
        printf("Error: Input string length must be multiple of 4: %dn", length);       
        return NULL;
    }
    char * reversed_string = (char *) malloc(length+1);
    for(i = 0; i < dwordLength; i++)
    {
        *(((uint32_t *) reversed_string) + dwordLength - i - 1) = bswap(*(((uint32_t *) str) + i));
    }
    reversed_string[length] = '';
    return reversed_string;
}
char * reverse(const char * str)
{
    int i;
    int length = strlen(str);
    char * reversed_string = (char *) malloc(length+1);
    for(i = 0; i < length; ++i)
    {
        reversed_string[i] = str[(length-1) - i];
    }
        //need to null terminate the string
    reversed_string[length] = '';
    return reversed_string;
}
int main(void)
{
    int i;
    char *reversed_str, *reversed_str2;
    clock_t start, total;
    char *str = (char *) malloc(MAX_CHARS+1);
    str[MAX_CHARS] = '';
    srand(time(0));
    for(i = 0; i < MAX_CHARS; i++)
    {
        str[i] = 'A' + rand() % 26;     
    }
    start = clock();
    reversed_str = reverse(str);
    total = clock() - start;
    if(reversed_str != NULL)
    {
        printf("Total clock ticks to reverse %d chars with pure C method: %dn", MAX_CHARS, total); 
        free(reversed_str);
    }
    start = clock();
    reversed_str2 = reverseAsm(str);
    total = clock() - start;
    if(reversed_str2 != NULL)
    {
        printf("Total clock ticks to reverse %d chars with ASM+C method: %dn", MAX_CHARS, total); 
        free(reversed_str2);
    }
    free(str);
    return 0;
}

在Cygwin:下我的旧电脑上的结果

fer@fernando /cygdrive/c/tmp$ ./reverse.exe
Total clock ticks to reverse 10485760 chars with pure C method: 221
Total clock ticks to reverse 10485760 chars with ASM+C method: 140

@Konrad Rudolph：（对不起，我没有发表评论的"经验"）

我想指出的是，STL提供了一个reverse_copy（）算法，类似于reverse（）。您不需要像以前那样引入临时字符，只需分配一个大小合适的新字符即可。

您不能（不应该）这样做：

string[i] ^= string[length - i] ^= string[i] ^= string[length - i];

发件人：http://en.wikipedia.org/wiki/XOR_swap_algorithm#Code_example

• *"此代码具有未定义的行为，因为它在没有插入序列点的情况下两次修改左值x

实际上，考虑到原始字符串保持不变的约束，我认为问题中给出的原始方法是最好的。所有这些奇特的方法都很好地扭转了人们发布的内容，但一旦考虑到复制给定的字符串，它们的效率都不如简单地向后复制字符串。

我们以前使用过这个问题，结果发现很多人做不到（即使有丰富的C/C++经验！）。我更喜欢就地变体，因为它节省了一些开销，并且只需要迭代strlen（s）/2个字符。

你在面试中的解决方案很好。使用指针而不是数组语法的（正确！）解决方案会得到更高的评价，因为它对C/C++编程中至关重要的指针显示出更高的舒适度。

次要的批评是指出strlen返回的是size_t而不是int，并且应该在rev_str上使用delete[]。

WRT："现在不使用临时持有变量"。。。也许是这样的（现在保持数组索引）：

int length = strlen(string);
for(int i = 0; i < length/2; i++) {
  string[i] ^= string[length - i];
  string[length - i] ^= string[i];
  string[i] ^= string[length - i];
}

这很好用：

#include <algorithm>
#include <iostream>
#include <cstring>
void reverse_string(char *str) {    
    char *end = str + strlen(str) - 1;
    while (str < end) {
        std::iter_swap(str++, end--);
    }
}
int main() {
    char s[] = "this is a test";
    reverse_string(s);
    std::cout << "[" << s << "]" << std::endl;
}

我会像这样解决它（不过我的c有点生疏，请原谅）

char *reverse( const char *source ) {
  int len = strlen( source );
  char *dest = new char[ len + 1 ];
  int i = 0;
  int j = len;
  while( j > 0 ) {
    dest[j--] = src[i++];
  }
  dest[i] = ;
  return dest;
}

它的效率不会更高，但您可以通过将每个字母推到堆栈上，然后将它们弹出到新分配的缓冲区来展示数据结构的知识。

这需要两次传球和一次scratch stack，但我可能更相信自己，第一次就把球打对，而不是像上面那样一次失误。

char* stringReverse(const char* sInput)
{
    std::size_t nLen = strlen(sInput);
    std::stack<char> charStack;
    for(std::size_t i = 0; i < nLen; ++i)
    {
        charStack.push(sInput[i]);
    }
    char * result = new char[nLen + 1];
    std::size_t counter = 0;
    while (!charStack.empty())
    {
        result[counter++] = charStack.top();
        charStack.pop();
    }
    result[counter] = '';
    return result;
}

作为面试官，当我问这个问题时，我希望找到一个干净、易懂的解决方案，并可能会问如何使最初的解决方案更有效率。我对"智能"解决方案不感兴趣。

我在想这样的事情；候选人是否在循环中犯了一个错误，他们是否预先分配了足够的内存，是否检查了错误的输入，是否充分使用有效类型。

不幸的是，正如已经指出的，太多人甚至不能做到这一点。

字符串反转到位，没有临时变量。

static inline void
byteswap (char *a, char *b)
{
  *a = *a^*b;
  *b = *a^*b;
  *a = *a^*b;
}
void
reverse (char *string)
{
  char *end = string + strlen(string) - 1;
  while (string < end) {
    byteswap(string++, end--);
  }
}

一种不需要临时变量的方法

int length = strlen(string);
for(int i = 0; i < length/2; i++) {
  string[i] ^= string[length - i] ^= string[i] ^= string[length - i];
}

如果我在面试，我会对解决方案的质量更加挑剔，因为它的稳健性，而不仅仅是性能。

如果传递了一个空指针，那么迄今为止提交的所有答案都将失败，其中大多数答案会立即调用可能的空指针上的strlen()，这可能会中断您的进程。

许多答案都痴迷于性能，以至于错过了问题的一个关键问题：反转const char *，即您需要制作一个反转的副本，而不是原地反转。如果需要副本，您会发现很难将迭代次数减半！

这是一个采访问题，所以我们想了解算法的细节，但在现实世界中，这只是强调了尽可能使用标准库的价值。

。

char * reverse(const char * str)
{
  if (!str)
    return NULL;
  int length = strlen(str);
  char * reversed_string = new char[length+1];
  for(int i = 0; i < length/2; ++i)
  {
    reversed_string[i] = str[(length-1) - i];
    reversed_string[(length-1) - i] = str[i];
  }
  //need to null terminate the string
  reversed_string[length] = '';
  return reversed_string;
}

一半的时间，但相同的复杂性（注意可能会因为一个错误而关闭）

上面的循环有打字错误。循环变量i的检查应为<=代替<，对于奇数个元素，othrewise将失败。对于（int i=0；i<=长度/2；++i）