Question

这个函数是C中反转字符串的最快，最优化的方法吗？这在O（n / 2）时间内运行。优化是它只迭代字符串的一半。

char* str_reverse(char *str, int len)
{
    char word[len];
    int i;
    for (i = 0; i <= len / 2; ++i) {
        word[i] = str[len - i - 1];
        word[len - i - 1] = str[i];
    }
    word[len] = '\0';
    return word;
}

Answer 1

也许是这样的？

char *str_reverse_in_place(char *str, int len)
{
    char *p1 = str;
    char *p2 = str + len - 1;

    while (p1 < p2) {
        char tmp = *p1;
        *p1++ = *p2;
        *p2-- = tmp;
    }

    return str;
}

Answer 2

您会发现算法采用较少的指令，例如到位反向

char* str_reverse_in_place(char *str, int len)
{
    int i;
    for (i = len/2-1 ; i >= 0 ; --i) {
        char c = str[i];
        str[i] = str[len-i-1];
        str[len-i-1] = c;
    }
    return str;
}

优化该级别的速度，查看内联关键字，同时使用-O3编译（对于gcc）（通常更好的是添加寄存器 ...自己动手。）

如果您需要在其他位置使用反转字符串，请在函数中提供它（分配给strlen(str)+1 - 实际上len+1这里 - 字符）

char* str_reverse(char *str, char *reverse, int len)
{
    int i;
    for (i = len-1 ; i >= 0 ; --i) {
        reverse[i] = str[len-i-1];
    }
    reverse[len] = 0;
    return reverse;
}

或 malloc 它（它必须由调用者释放）。

char* str_reverse_malloc(char *str, int len)
{
    char *reverse = malloc(len+1);
    if ( ! reverse) return NULL;
    int i;
    for (i = len-1 ; i >= 0 ; --i) {
        reverse[i] = str[len-i-1];
    }
    reverse[len] = 0;
    return reverse;
}

Answer 3

＆＃34;大多数＆＃34;优化方式必须解决CPU和内存架构以及正在逆转的问题（长字符串或短字符串以及分布是什么）。

没有办法放宽O（N）的要求，但是可以使用诸如循环展开，循环阻塞和并行性等技术来优化非常大的字符串的缓存未命中。还可以增加字大小并就地交换字，双字或更大的实体（同时处理可能的对齐问题）。

//这很可能比逐字节复制更快，但它不是O（N / 8）...

if (len & 7 == 0)
{
    uint32_t *dst = src+len-4;
    uint32_t *src = (uint32_t *)ptr;
    while (src<dst)
    {
      a = *src; b = *dst;
      *src++ = byte_swap(b);
      *dst-- = byte_swap(a);
    }
}

Answer 4

int main() {
   char str[100], temp;
   int i, j = 0;

   printf("\nEnter the string :");
   gets(str);

   i = 0;
   j = strlen(str) - 1;

   while (i < j) {
      temp = str[i];
      str[i] = str[j];
      str[j] = temp;
      i++;
      j--;
   }

   printf("\nReverse string is :%s", str);
   return (0);
}

Answer 5

这是一个不需要传递长度的变体，它将在每个传递循环的字符串中的给定偏移处交换开始和结束字符：

/** strrevstr - reverse string, swaps src & dest each iteration.
 *  Takes valid string and reverses, original is not preserved.
 *  If str is valid, returns pointer to str, NULL otherwise.
 */
char *strrevstr (char *str)
{
    if (!str) {
        printf ("strrevstr() error: invalid string\n");
        return NULL;
    }

    char *begin = str;
    char *end = str + strlen (str) - 1;
    char tmp;

    while (end > begin)
    {
        tmp = *end;
        *end-- = *begin;
        *begin++ = tmp;
    }

    return str;
}

Answer 6

这里是一个有趣的游戏。但我认为它的速度与此处发布的其他方法一样快。
有趣的部分是按位异或！在纸上做，就可以了！

void inplace_swap(char *x, char *y) {
    *y = *x ^ *y;
    *x = *x ^ *y;
    *y = *x ^ *y;
}

void reverse_string(char *str, int len) {
    int first, last;
    for (first = 0, last = len - 1; first < last; first++, last--) {
        inplace_swap(&str[first], &str[last]);
    }
}

Answer 7

这是在c

中打印反向字符串的最快方法

＆＃13;

#include <stdio.h>
#include <string.h>

int main()
{
    char str[30],str1[30];
    printf("Enter string :");
    scanf("%s",str);
    int i = strlen(str);
    for (int j = 0; j <=5;j++)
    {
    		str1[j]=str[i-j];
    		printf("%c",str1[j]);	
    }
    printf("\n");
}

＆＃13;

在C中反转字符串的最快方法

7 个答案: