Selezione Ordina complessità del tempo

L'ordinamento di selezione è una sorta di algoritmo di smistamento. Un elenco non desiderato può essere ordinato in ordine crescente o in ordine decrescente. Considera l'elenco non desiderato:

55 65 35 15 85 75 25 45

Se questo elenco viene ordinato in ordine crescente, sarebbe:

15 25 35 45 55 65 75 85

Se l'elenco viene ordinato in ordine decrescente, sarebbe:

85 75 65 55 45 35 25 15

In questo articolo, viene considerato solo l'ordinamento in ordine crescente. Ordine di selezione cercando piccoli elementi e scambiandoli con gli elementi iniziali, a partire dall'elemento più piccolo, mentre gli elementi iniziali sostituiti diventano ascendenti. Un elenco dovrebbe essere ordinato in ordine crescente alla fine di questo processo.

L'articolo mira a determinare la complessità temporale del tipo di selezione. La seguente programmazione viene eseguita nel linguaggio C.

Algoritmo di ordinamento di selezione

I passaggi per l'ordinamento di selezione sono i seguenti:

• Supponiamo che il primo elemento sia l'elemento più piccolo.
• Confronta questo elemento con gli altri elementi per conoscere il vero elemento più piccolo.
• Scambia l'elemento più piccolo trovato con il primo elemento.
• Ripeti i tre passaggi precedenti in ordine, esclusi il primo elemento sostituito.
• Continua a ripetere i tre passaggi precedenti, esclusi gli elementi verso l'estremità sinistra (inferiore) che sono stati sostituiti.
• L'ordinamento termina quando viene raggiunto l'ultimo elemento.

Ci sono due tipi di operazioni principali qui, che sono confronti e scambi. Spostarsi da un elemento all'altro è anche un'operazione, ma ci vuole relativamente poco tempo rispetto all'operazione di confronto o all'operazione di scambio nell'ordinamento di selezione.

SU²) Complessità temporale

Considera il seguente codice:

int risultato = 0;
per (int i = 0; i<8; i++)
per (int j = 0; j<8; j++)
risultato = risultato + 1;


printf ("%i \ n", risultato);

C'è un ciclo esterno e interno. Ogni ciclo si iterato otto volte. L'unica operazione di aggiunta per entrambi i loop è l'operazione principale e funziona 64 volte. 64 = 8 x 8 = 82. L'output è 64.

Si ritiene che questo codice abbia 82 operazioni principali. Se 8 viene sostituito da N, allora la complessità del tempo sarebbe data come:

O (N2)

Questo usa la notazione Big-O. La notazione inizia con O in maiuscolo, seguita da parentesi. All'interno delle parentesi c'è il numero di operazioni principali per il codice.

Considera il seguente codice:

int risultato = 0;
per (int i = 0; i<8; i++)
per (int j = i; j<8; j++)
risultato = risultato + 1;


printf ("%i \ n", risultato);

Il ciclo esterno si itera otto volte. Il ciclo interno itera fino all'ottava volta ma inizia da I, che è il numero di iterazione del ciclo esterno. L'output è 36. L'operazione di un'unica aggiunta funziona 36 volte e non 64 volte. Bene, questo è ancora considerato come complessità del tempo O (N2). Il funzionamento dell'ordinamento di selezione è simile a questo codice. In altre parole, si considera che l'ordinamento di selezione abbia una complessità del tempo O (N2).

Coding in c

L'ordinamento di selezione darà sempre la complessità del tempo O (N2). Non importa come siano organizzati gli elementi dell'array. Questo perché tutti gli elementi vengono scansionati per la prima volta; Quindi il resto degli elementi senza i primi viene scansionato in seguito; Segue la scansione del resto degli elementi senza i primi due. La scansione deve essere completata prima dello scambio.

L'elenco da ordinare è:

P o i u y t r e w q

Il programma C ordina in ordine crescente. In sostanza, il programma inizia con:

#includere
void selectiosort (char a [], int n)
per (int i = 0; iint minindx = i;
per (int j = i+1; jif (a [j] < A[minIndx])
minindx = j;

char temp = a [i]; A [i] = a [minindx]; A [minindx] = temp; // scambiando

È inclusa la libreria responsabile dell'input dalla tastiera e dall'output al monitor. Quindi, c'è la definizione della funzione di ordinamento di selezione. Questa funzione come parametri ha l'array (riferimento) con l'elenco e il numero di elementi nell'array.

Ci sono due per loop; uno è nidificato all'interno dell'altro. L'esterno per loop si itera su tutti gli elementi che iniziano dal primo. Mentre il per loop esterno è a un indice, il per anello interno si iterato sul resto degli elementi, escludendo l'elemento precedente. L'operazione principale è l'operazione di confronto nel circuito nidificato.

Lo scambio viene eseguito per ogni iterazione del ciclo esterno subito dopo il completamento del ciclo interno.

Una funzione principale C idonea per il programma è:

int main (int argc, char ** argv)

int n = 10;
char a [] = 'p', 'o', 'i', 'u', 'y', 't', 'r', 'e', ​​'w', 'q';
selectiosort (a, n);
per (int i = 0; iprintf ("%c", a [i]);
printf ("\ n");
restituzione 0;

L'output è:

E i o p q r t u w y

smistato.

Inizia con la dichiarazione del numero di elementi nell'array. Poi c'è la dichiarazione dell'array. Ci sono dieci elementi nell'array. Questi elementi sono personaggi. Quindi, la dichiarazione dell'array inizia con "char". Successivamente, la funzione di ordinamento di inserimento si chiama. Il primo argomento della chiamata della funzione è il nome dell'array. Il secondo argomento è il numero di elementi nell'array.

Segue un per loop. Questo per loop stampica i personaggi ordinati. Utilizza la funzione printf () di stdio.Biblioteca H. Il primo argomento di questa funzione è una stringa. Questa stringa è una stringa speciale ma ha ancora caratteri che verrebbero stampati. Ha anche parametri per gli argomenti. In questo caso, esiste un solo parametro, %c. C'è anche solo un argomento, un [i]. Dopo che tutti i caratteri sono stati stampati su una riga, la funzione printf () successiva porta l'output alla riga successiva.

Conclusione

Questo articolo ha discusso dei passaggi per l'ordinamento di selezione, che includono assumere il primo elemento è l'elemento più piccolo, confrontando questo elemento con il resto degli elementi e conoscendo il vero elemento più piccolo. Inoltre, un utente deve scambiare l'elemento più piccolo trovato con il primo elemento e ripetere i tre passaggi precedenti in ordine, escludendo il primo elemento sostituito. Gli ultimi passaggi includono il continuazione a ripetere i tre passaggi sopra, esclusi gli elementi verso l'estremità sinistra (inferiore) che sono stati sostituiti; L'ordinamento termina quando viene raggiunto l'ultimo elemento. La complessità temporale per l'ordinamento di selezione è O (N2).