Sortier-Algorithmus (wo ist der Fehler)

Hi,

Ich schreibe gerade zur Übung ein Programm, das Strings nach dem Alphabet ordnen soll. Dafür habe ich eine Funktion geschrieben, die 2 Strings entgegennimmt und anschließend nach dem Alphabet ordnet. Wenn sich die beiden Strings im ersten Buchstaben unterscheiden funktioniert das ganze auch schon ganz gut. Sobald die Strings aber den ersten Buchstaben gleich haben und somit die Funktion sort rekursiv aufgeruffen wird, wird nur noch ein String getauscht und der andere merkwürdigerweise gelöscht.

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

void sort( char *str1, char *str2);

int main( void)
{
    char test[5][20] = { "blub", "bla", "lala", "foo", "bar"};
    printf( "vorher:\ntest[0]: %s\ntest[1]: %s\n", test[0], test[1]);
    sort( test[0], test[1]);
    printf( "nachher:\ntest[0]: %s\ntest[1]: %s\n", test[0], test[1]);
    return EXIT_SUCCESS;
}

void sort( char *str1, char *str2)
{
    char buffer[20];
    if( str1[0] == str2[0])
        sort( (str1 + 1), (str2 + 1));
    else if( str1[0] > str2[0])
    {
        strncpy( buffer, str2, 20);
        strncpy( str2, str1, 20);
        strncpy( str1, buffer, 20);
    }
}

Als Compiler verwende ich den gcc. Ein Aufruf des Programms sieht folgendermaßen aus:

pat:c>./sort
vorher:
test[0]: blub
test[1]: bla
nachher:
test[0]: bla
test[1]: 
pat:c>

PAD

schon mal was von strcmp und ähnlichem gehört

Nö, bin halt noch Anfänger.
Werde mir das mal anschauen. Wo der Fehler in meinen Programm liegt würde mich aber trotzdem mal interessieren.

pat

--linuxuser--

warum legst du einen 2dimensionalen array an

char test[5][20] = { "blub", "bla", "lala", "foo", "bar"};

und sprichst diesen dann wie einen eindimensionalen an?

char test[5][20] = { "blub", "bla", "lala", "foo", "bar"};
printf( "vorher:\ntest[0]: %s\ntest[1]: %s\n", test[0], test[1]);
sort( test[0], test[1]);
printf( "nachher:\ntest[0]: %s\ntest[1]: %s\n", test[0], test[1]);

//waere es nicht flexibler in ner schleife???
was soll das fuer ein sortieralgorythmus sein???

n neuer forschlag fuer das vertauschen du vertauscht in einem string

strncpy( buffer, str2, 20);
        strncpy( str2, str1, 20);
        strncpy( str1, buffer, 20);

das ist eußerst doof wenn du mich fragst mach das ganze in einem string array was du schon hast und dann kannst das ganze schön im array austauschen
siehe:

pufferString = arr[indexDerErstenStelle];
array[indexDerErstenStelle] = array[indexDerAderderenStelleImArray];
array[indexDerAderderenStelleImArray] = hilf;

Dann ein paar sortieralgorythemen (eingige der einfachsten)
sind in java da ich sie in der schule in java schreiben hab müssen laesst sich aber leicht in c code portieren...
InsertionSort:

int[] inSort(int[] arr){
  int fetzB = 1,fetzS,hilf;
  fetzS = fetzB - 1;
  while (fetzB < arr.length){
    hilf = arr[fetzB];
    while(fetzS >= 0 && arr[fetzS] > hilf){
       arr[fetzS+1] = arr[fetzS];
       fetzS--;          
    }//end while
    arr[fetzS+1] = hilf;
    fetzB++;
    fetzS = fetzB - 1;
  }//end while
    return arr;
}//end inSort

und der bubble sort:

char[] BubbleSort(char[] arr){
       int i = 0,j = 0;
       char hilf = 0;
       boolean changed = false;

       i = arr.length - 2;

       while(i >= 0){
           changed = false;      
           while(j <= i){
                if(arr[j] > arr[j+1]){
                    hilf = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = hilf;
                    changed = true;
                }//end if          
                j++;                  
           }//end if
           i--;   
           j = 0;
       }//enf while
       return arr;
    }

und zu guterletzt der selsort:

int[] sort(int[] arr){
         int i,j, hilf;
         i = 0;
         while(i < arr.length - 1){
             j = i + 1;
             while(j <= arr.length - 1){
                if(arr[i] > arr[j]){
                    hilf = arr[i];
                    arr[i] = arr[j];
                    arr[j] = hilf;                  
                }//end if
                j++;
             }//end while
             i++;
         }//end while
          return arr;
    }//end soert

Erstmal vielen Dank für die Antwort!
Ein zweidimensionales Array wird afaik doch eh angelegt, wenn ich folgendes schreibe: char array[10] = { "test"};
Mit den [20] bestimme ich dann doch nur, dass das Array auf zweiter Dimension, in dem der String gespeichert wird, 19 Zeichen aufnehmen kann. Wenn ich das nicht mache könnte doch ein Pufferüberlauf bei den strncpys entstehen!?
Warum sollte ich die Strings nicht mit strncpy tauschen? Sorry ich blick da noch nicht ganz durch.
Das ganze soll ein Funktion werden die ich dann in einer bubble-sort-Funktion einsetzen möchte.

pat