Sortowanie pliku - łączenie proste
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zarejestruj się!

Sortowanie pliku - łączenie proste

AutorWiadomość
Temat założony przez niniejszego użytkownika
Sortowanie pliku - łączenie proste
» 2017-12-07 07:10:05
C/C++
// rozdzielenie fragmentów o długości danej 
// parametrem, naprzemiennie na dwa pomocnicze pliki
void Split( int partLength )
{
    DATA_TYPE buffer;
    // pomocnicza zmienna dla odczytu i zapisu
    int counter;
    // licznik obsłużonych elementów
    do {
        // skopiowanie do pierwszego pliku pomocniczego
        counter = 1;
        while(( counter <= partLength ) &&( !feof( inFile ) )
        {
            read( inFile, & buffer );
            write( auxFileOne, buffer );
            counter = counter + 1;
        }
        // skopiowanie do drugiego pliku pomocniczego
        counter = 1;
        while(( counter <= partLength ) &&( !feof( inFile ) )
        {
            read( inFile, & buffer );
            write( auxFileTwo, buffer );
            counter = counter + 1;
        }
    }
    while( !feof( inFile ) );
    // rozdzielanie aż do końca pliku
}
// Split ()

C/C++
// łączenie fragmentów o długościach danych parametrem
// i pochodzących z dwu plików w posortowany 
// fragment zapisany w pliku wynikowym 
void Combine( int partLength )
{
    DATA_TYPE bufferOne;
    // zapis i odczyt z pierwszego pliku
    DATA_TYPE bufferTwo;
    // zapis i odczyt z drugiego pliku
    int counterOne;
    // licznik obsłużonych elementów pierwszego pliku
    int counterTwo;
    // licznik obsłużonych elementów drugiego pliku
    // naczytanie początkowego elementu z pierwszego pliku pomocniczego
    if( feof( auxFileOne ) == false )
         read( auxFileOne, & bufferOne );
    // naczytanie początkowego elementu z drugiego pliku pomocniczego
    if( feof( auxFileTwo ) == false )
         read( auxFileTwo, & bufferTwo );
    // zasadnicza pętla działająca aż do wyczerpania
    // jednego z plików pomocniczych
    while(( feof( auxFileOne ) == false ) &&( feof( auxFileTwo ) == false ) )
    {
        // inicjalizacja liczników
        counterOne = 1;
        counterTwo = 1;
        // złączenie pojedynczego fragmentu
        do {
            if( bufferOne < bufferTwo )
            {
                Write( inputFile, bufferOne );
                if( feof( auxFileOne ) == false )
                     read( auxFileOne, & bufferOne );
               
                counterOne = counterOne + 1;
            }
            else {
                // bufferOne >= bufferTwo
                write( inputFile, bufferTwo );
                if( feof( auxFileTwo ) == false )
                     read( auxFileTwo, & bufferTwo );
               
                counterTwo = counterTwo + 1;
            }
        }
        while(
        ( counterOne <= partLength ) &&
        ( counterTwo <= partLength ) &&
        ( feof( auxFileOne ) == false ) &&
        ( feof( auxFileTwo ) == false ) );
        // działanie aż do ukończenia jednego z fragmentów
        // lub końca jednego z plików pomocniczych
        // ewentualne dokopiowanie fragmentu 
        // pozostałego na pierwszym pliku pomocniczym
        // gdy drugi fragment skończył się wcześniej
        while(( counterOne <= partLength ) &&( feof( auxFileOne ) == false ) )
        {
            read( auxFileOne, & bufferOne );
            write( inputFile, bufferOne );
            counterOne = counterOne + 1;
        }
        // ewentualne dokopiowanie fragmentu
        // pozostałego na drugim pliku pomocniczym
        // gdy pierwszy fragment skończył się wcześniej
        while(( counterTwo <= partLength ) &&( feof( auxFileTwo ) == false ) )
        {
            read( auxFileTwo, & bufferTwo );
            write( inputFile, bufferTwo );
            counterTwo = counterTwo + 1;
        }
    }
    // ewentualne dokopiowanie reszty pierwszego pliku pomocniczego
    while( feof( auxFileOne ) == false )
    {
        read( auxFileOne, & bufferOne );
        write( inputFile, bufferOne );
    }
    // ewentualne dokopiowanie reszty drugiego pliku pomocniczego
    while( feof( auxFileTwo ) == false )
    {
        read( auxFileTwo, & bufferTwo );
        write( inputFile, bufferTwo );
    }
}


C/C++
int main( void )
{
    int partLength = 1;
    // długość obsługiwanego fragmentu
    bool exitCond = false;
    // wskaźnik warunku końca 
    do {
        // rozdzielanie --------------------
        inputFile = fopen( inputFileName, r );
        auxFileOne = fopen( auxFileNameOne, w );
        auxFileTwo = fopen( auxFileNameTwo, w );
        Split( partLength );
        fclose( auxFileOne );
        fclose( auxFileTwo );
        fclose( inputFile );
        // łączenie ------------------------
        inputFile = fopen( inputFileName, w );
        auxFileOne = fopen( auxFileNameOne, r );
        auxFileTwo = fopen( auxFileNameTwo, r );
        // testowanie warunku końca
        if( !feof( auxFileTwo ) )
        {
            // kontynuacja dla istnienia rozdzielenia
            Combine( partLenght );
            partLength = 2 * partLength;
        }
        else
             exitCond = true;
       
        fclose( auxFileTwo );
        fclose( auxFileOne );
        fclose( inputFile );
       
        while( exitCond == false );
       
    }
}

Gdy przepisałem ten kod na Pascala (Operacje na łańcuchach Pascalowych są wygodniejsze niż na tablicach znakowych z C)
to okazało się że ten kod nie dość że nie kopiuje całego pliku to i nie sortuje poprawnie nawet tego co przekopiował
Nie wiem gdzie jest błąd i jak go poprawić
P-167667
» 2017-12-07 08:08:06
>> okazało się że ten kod nie dość że nie kopiuje całego pliku
używasz warunku np. " while(( counter <= partLength ) &&( !feof( inFile ) ) "
nie zależącego tylko od napotkania końca pliku
? dlatego nie jest to dziwne

>> nie sortuje poprawnie nawet tego co przekopiował
w kodzie nie widać algorytmu sortującego coś, dlatego nie jest to dziwne


2.
zapoznaj się z techniką debugowania kodu, dzięki czemu możesz obejrzeć stany zmiennych, przebieg całego programu i bardzo szybko zobaczyć wady tworzonego algorytmu

P-167671
Temat założony przez niniejszego użytkownika
» 2017-12-07 08:22:14
To chyba jednak nie to bo ta pętla którą wymieniłeś jest wewnątrz pętli
do while

Co do debugowania to wątpię aby to miało jakoś pomóc
ale gdybyście coś o tym napisali np w tych waszych kursach to bym poczytał

P-167673
» 2017-12-07 08:51:02
Co do debugowania to wątpię aby to miało jakoś pomóc ale gdybyście coś o tym napisali np w tych waszych kursach to bym poczytał
Frazy, które należy wpisać w wyszukiwarkę google:

Debugging with Code::Blocks

Debugger jest pierwszą linią poszukiwań błędów logicznych, crashy itd.
Wszystko co dotyczy C::B jest na stronie producenta.

W serwisie YouTube jest cała masa tutoriali o debuggowaniu kodu.
np. chałupnicze sposoby.
P-167678
« 1 »
 Strona 1 z 1