Umkehren einer Zeichenfolge in c mit Rekursion

Ich habe code geschrieben, um das umkehren einer Zeichenfolge in c... es funktioniert gut, aber ich kann nicht zurück die umgekehrte Zeichenfolge in der main() Funktion.

#include<stdio.h>

main()
{
  char a[17]="abcdefg";
  reverse(a);
  printf("\n");
  system("PAUSE");
}
int reverse(char *a)
{
   if(*a!='\0')
   {   
     reverse(a+1);
   }
   printf("%c",*a);
}

druckt es die umgekehrte Zeichenfolge, aber ich möchte die umgekehrte Zeichenfolge in main(). Wie kann ich dies tun?

Ist das eine Hausaufgabe?
nopes, ich studiere Rekursion
Die int reverse() sollte die Funktion mindestens int zurückgeben.
Sie müssen swap-Zeichen in der Zeichenfolge (ein in-place-reverse), anstatt Sie zu drucken. Eine rekursive Lösung ist ineffizient, aber kann getan werden, relativ leicht.
Statt sich auf die meist nutzlosen Wissens, wie Rekursion, Sie sollten sich auf nützliches wissen, wie C99/C11 und wie zu schreiben Funktionsprototypen in der modernen C. der code enthält einige Fehler, und Sie stehen nicht im Zusammenhang mit Rekursion, sondern um grundlegende C-Programmierung.

InformationsquelleAutor Amol Singh | 2012-10-03

  1. 3

    Sie müssen die Zeichenfolge ändern, also durch den input buffer zu reverse(), anstatt nur zu drucken.

    Tun dies rekursiv scheint ein bisschen widerlich, sollte aber natürlich möglich sein.

    Grundsätzlich, ich denke, der Druck wird für eine Zuweisung, so etwas wie dieses:

    1. Base: Die Umkehrung eines leeren Strings ist der leere string.
    2. Schritt: Die Umkehrung einer Zeichenkette beginnt, die durch vertauschen der ersten und letzten Zeichen, dann recursing über den Rest des Strings.
    ich habe nicht bekommen, Sie
    es scheint ein bisschen kompliziert ...

    InformationsquelleAutor unwind

  2. 5

    Folgenden ist ein Weg, um reverse-string mit Rekursion! 

    #include <stdio.h>
#include <string.h>

void rev_str_recursive(char arr[], size_t iStart, size_t iLast)
{
    if( iStart < iLast )
    {
        //swap
        char temp = arr[iStart];
        arr[iStart] = arr[iLast];
        arr[iLast] = temp;

        rev_str_recursive(arr, ++iStart, --iLast);  
    }
}

void main()
{
    char cArray[] = {"A quick brown fox jumps over a lazy dog"};

    rev_str_recursive(cArray, 0, strlen(cArray)-1);
}
    Wegen der -1 im ursprünglichen Aufruf der Funktion, dies scheitert furchtbar, wenn der string leer ist (also strlen(cArray) 0, sodass der übergebene Wert als iLast ist der maximale Wert size_t). Vereinfachen Sie die Schnittstelle durch den Aufruf als rev_str_recursive(cArray, strlen(cArray)) und Anordnung der rekursive Aufruf als rev_str_recursive(arr+1, iLast-2); nur, wenn iLast > 2. Natürlich, da es tail-rekursiv ist, kann der code optimiert werden, um eine Schleife und ohne Rekursion.
    Danke für das feedback, ich Stimme mit Ihnen, wenn der string leer ist, wird dies scheitern!

    InformationsquelleAutor AFI

  3. 2

    Hier ist ein weiterer Weg, um das umkehren einer Zeichenfolge mit Rekursion:

    void reverseString(char* dest, char *src, int len) {
    if (src == NULL || len == 0)
        return;

    reverseString(dest, src + 1, len - 1);
    strncat_s(dest, len + 1, src, 1);
}

    Können Sie so nennen:

    #include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define STRING "Let's try this one."
#define SIZE 20

void main() {

    char* src = (char*)malloc(SIZE);
    char* dest = (char*)malloc(SIZE);

    strcpy_s(dest, SIZE, "");
    strcpy_s(src, SIZE, STRING);

    reverseString(dest, src, strlen(src));
    /* Do anything with dest. */
    //printf("%s\n", dest);

    free(src);
    free(dest);
}

    InformationsquelleAutor Emre Can Kucukoglu

  4. 0
    #include <iostream>
using namespace std;

reverse( char *str)
{
    if (*str!='\0')
    {
       reverse(str+1);
       cout<<*str;
    }
//cout<<*str   when i am just printing here then why this is printing after one space ??
}

int main()
{   
    string a ;  
    cin>>a;   
    reverse(&a[0]); 
    return 0;
}
    Dies ist nicht eine Antwort so viel, wie Sie kopieren und einfügen von code in. Auch, bitte verwenden Sie code Einzug, wenn die Beantwortung mit code-snippets.

    InformationsquelleAutor Mohammad Chand Alam

  5. 0

    in einer kleinen änderung Emre Kann Kucukoglu Antwort . . .
    wir beseitigen können strncat_s

    void revstr_rec(char *sstr, char *dstr, int len)
{
    int i = 0;
    if((! *sstr) || (! len) )
        return;

    revstr_rec(sstr + 1, dstr, len - 1);
    dstr[len - 1] = *sstr;

    return;
}

int main()
{
    char *sstr = NULL;
    char *dstr = NULL;

    sstr = malloc(16);
    if(! sstr)  {
        printf("no memory . . .\n");
        return 0;
    }
    strcpy(sstr, "hello world !");
    printf("sstr: %s\n", sstr);

    dstr = malloc(16);
    if(! dstr)  {
        printf("no memory . . .\n");
        return 0;
    }

    revstr_rec(sstr, dstr, strlen(sstr));
    printf("dstr(recursive): %s\n", dstr);

    free(sstr);
    free(dstr);

    return 0;
}

    InformationsquelleAutor yogeshk

  6. -1

    Dieser code ist nicht ausführbar 🙁
    Sie definieren, int reverse, aber reverse-Funktion keinen Rückgabe Wert

    verwenden Sie stattdessen (mit void):

    #include<stdio.h>

main()
{
  char a[17]="abcdefg";
  reverse(a);
  printf("\n");
  system("PAUSE");
}
void reverse(char *a)
{
   if(*a!='\0')
   {   
     reverse(a+1);
   }
   printf("%c",*a);
}
    Wie verändert sich der Wert von a?

    InformationsquelleAutor Ali Motamedi

  7. -1

    verwenden sprintf wird es drucken Sie Ihre reversed string in den buffer.

    #include<stdio.h>

char *b;

main()
{
  char a[17]="abcdefg";
  char buffer[17];
  buffer[0]= '\0';
  b = buffer;
  reverse(a);
  printf("%s\n",buffer);
}
int reverse(char *a)
{
   if(*a!='\0')
   {   
     reverse(a+1);
     sprintf(b,"%c",*a);
     b++;
   }

}
    Es ist ein Semikolon fehlt nach char buffer[17]. Auch: Puffer ist nicht ein lvalue, so buffer++; ist nicht möglich.
    code aktualisiert. Habe es getestet und es funktioniert.
    Wir wirklich brauchen Sie nicht eine Globale variable verwenden, so etwas wie dieses...

    InformationsquelleAutor MOHAMED

  8. -1
    void palindromo(char *s)
{
    if(s[0] != '\0'){
        palindromo(s+1);
        printf("%c", s[0]);
    }
}

    Dies ist eine kleine rekursive Funktion, die print den string invertiert.

    InformationsquelleAutor Biuni

  9. -1
    #include<stdio.h>
#include<string.h>
void rev(char *);

int main()
{
    char s[]="Hello";
    printf("\n%s",s);
    rev(s);
    printf("\n%s",s);
    return 0;
}

void rev(char *s)
{
    static int i=0;
    static int j=0;
    if(j==0)                   //since static variable can be intitialized 
    {                          //only with a constant literal,to store 
        j=strlen(s)-1;         //length-1 in 1st function call, we can use 
    }                          //this trick.(condition satisfied only in 1st 
                               //function call)
    if(i<j)
    {
        char temp;
        temp=s[i];
        s[i]=s[j];             //Analogous to for(i=0,j=l-1;i<j;i++,j--)
        s[j]=temp;             //               { //swap code }
        i++;
        j--;
        rev(s);           
    }
}
    Mit static Variablen zu erfassen Zustand ist nicht mit Rekursion korrekt. Sie kann, wie auch schon geschrieben eine Schleife vermieden und eine mögliche race-condition.
    Während dieser code kann die Frage beantworten, die Bereitstellung zusätzlicher Rahmen an, wie und/oder warum es das problem behebt, das würde verbessern die Antwort, die langfristigen Wert.
    Nic3500 Danke für die Anregung.

    InformationsquelleAutor Lelouch Yagami

  10. -3
    #include<stdio.h>
void reverse(char *a);
main()
{
  char a[17]="abcdefg";
  reverse(a);
  printf("\n");
  system("PAUSE");
}
void reverse(char *a)
{
   if(*a!='\0')
   {   
     reverse(a+1);
   }
   printf("%c",*a);
}
    Haben Sie etwas zu tun, sondern kopieren Sie den code aus der Frage?
    Er fügte hinzu, die vorwärts-Deklaration von reverse(char* a) hat er nicht?
    Zwei Gedanken: 1. Die Frage war über die Umkehrung der Zeichenfolge in einer Weise, dass Sie zugegriffen werden kann von der aufrufenden Funktion. 2. Wenn Sie nach einer Antwort, die ist nur code, ein großer weit-Warnung kommt: "vielleicht sollten Sie erklären, was dieser code-block zu tun".
    Ich bin nicht uneins mit allen, (und ich habe/entsprechend editiert) ich habe nur versucht, Sie zu beantworten die Frage, ob sich irgendetwas geändert hatte.

    InformationsquelleAutor Dave Starfield

Schreibe einen Kommentar