Problema selection sort

[michele1239]

(sarò cieco?!?!?)

No, semplicemente non hai riletto il tuo codice, altrimenti avresti notato quell'assegnamento invertito.

l'ho riletto,ma ripeto non trovo l'errore...

[Albesa81]

Ohibò...
Che cosa fa

Codice:

min=mat[j][j];

?
E invece che cosa fa

Codice:

mat[j][j]=min;

?

[michele1239]

il primo assegna al minimo il valore in posizione j,j.
il secondo assegna al valore in posizione j,j il valore del minimo.

[michele1239]

grazie mille per la pazienza credo di aver capito!!
potresti darmi qualche consiglio su come evitare certi errori?

[Albesa81]

grazie mille per la pazienza credo di aver capito!!

Ah, meno male

potresti darmi qualche consiglio su come evitare certi errori?

Gli errori capitano a tutti, però quando le cose non ti tornano rileggi criticamente ciò che hai scritto invece di cercare le differenze con soluzioni esterne

[insideworld]

per quando fai l'assegnazione puoi ricordarti come si scrive in pseudocodice
a=b;
a <-- b ;
il valore di b va in a

comunque l'errore c'è (quasi) sempre.
considera che quando si scrive codice per lavoro, metà del tempo è dedicato allo sviluppo e l'altra metà al debug (quando va bene)
di solito se un programmatore scrive un codice che compila al primo tentativo allora inizia a preoccuparsi seriamente XD

[vict85]

Al di là del codice, ho qualche commento generale:

1. Il tuo codice non fa alcuna allocazione dinamica. Inoltre, nel caso invece in cui il main la faccia, ti troveresti o con uno spreco di memoria, oppure con un bug piuttosto difficile da notare. In generale, trovo che il metodo usato dal tuo professore non sia sempre la scelta migliore. Un esempio di approccio differente:

   Codice:

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

#define MAXDIM 1024

// funzione che ordina la diagonale principale
void
ordinaDiagonale( int mat[], int dim )
{
    for ( int i = 0; i < dim * dim; i += dim + 1 ) {
        int pos = i;
        int min = mat[i];
        for ( int j = i + dim + 1; j < dim * dim; j += dim + 1 ) {
            if ( mat[j] < min ) {
                min = mat[j];
                pos = j;
            }
        }
        { /* SWAP( mat[i], mat[pos] ) */
            int temp = mat[i];
            mat[i] = mat[pos];
            mat[pos] = temp;
        }
    }
}

int
main( void )
{
    printf( "Inserisci la dimensione:\t" );
    int dim;
    scanf( "%d", &dim );
    if ( dim <= 0 || dim > 32 ) {
        puts( "ERRORE: dimensione non corretta" );
        return EXIT_FAILURE;
    }
    int mat[MAXDIM] = {0};
    for ( int i = 0; i != dim; ++i ) {
        for ( int j = 0; j != dim; ++j ) {
            printf( "Inserisci il valore a[%d][%d]:\t", i, j );
            scanf( "%d", &mat[i * dim + j] );
        }
    }
    ordinaDiagonale( mat, dim );
    for ( int i = 0; i != dim; ++i ) {
        for ( int j = 0; j != dim; ++j ) {
            printf( "%d\t", mat[i * dim + j] );
        }
        puts( "" );
    }

    puts("\nE funziona anche con array multidimensionali statici");
    int a[3][3] = { {0, 1, 3}, { 3, -2, 4 }, { 1, 1, 1 } };
    for ( int i = 0; i != 3; ++i ) {
        for ( int j = 0; j != 3; ++j ) {
            printf( "%d\t", a[i][j] );
        }
        puts( "" );
    }
    puts("Diventa:");
    ordinaDiagonale( &a[0][0], 3 );
    for ( int i = 0; i != 3; ++i ) {
        for ( int j = 0; j != 3; ++j ) {
            printf( "%d\t", a[i][j] );
        }
        puts( "" );
    }
}


   La stessa funzione ordinaDiagonale può essere usata anche per array statici di dimensione conosciuta a tempo di compilazione e per array di dimensione fissa. Ovviamente una funzione che accettasse sia il numero di righe che di colonne sarebbe più generica.
2. Il C non ha mai richiesto che le variabili fossero definite ad inizio funzione, quello che richiedeva nello standard del 1989 era che venissero definite ad inizio del blocco in cui "vivevano". Questa richiesta non è più necessaria dallo standard del 1999 in poi. Per esempio, questo codice, equivalente al tuo, viene tranquillamente compilato da gcc con l'opzione -ansi

   Codice:

   #define MAXNUM 15

/* funzione che ordina la diagonale principale */
void
ordinaDiagonale( int mat[][MAXNUM], int dim )
{
    if ( dim >= 0 ) {
        int i;
        for ( i = 0; i < dim; i++ ) {
            int pos = i;
            { /* ricerca elemento */
                int min = mat[i][i];
                int j;
                for ( j = i + 1; j < dim; j++ ) {
                    if ( mat[j][j] < min ) {
                        min = mat[j][j];
                        pos = j;
                    }
                }
            }
            { /* SWAP( mat[i][i], mat[pos][pos]) */
                int temp = mat[i][i];
                mat[i][i] = mat[pos][pos];
                mat[pos][pos] = temp;
            }
        }
    }
}

   Ovviamente ho voluto esagerare nell'inserimento dei blocchi, la soluzione migliore è una via di mezzo (sia per leggibilità che come aiuto al compilatore).

[apatriarca]

di solito se un programmatore scrive un codice che compila al primo tentativo allora inizia a preoccuparsi seriamente XD

E se sono solo piccoli errori di scrittura/disattenzione festeggia..