Trier les cartes

Tout d'abord, sorte cartes à jouer

1, la structure poussée

typedef struct {
     carboniser a;
    int b;
}poussée;

Dans lequel une des cartes mémoire de couleur A, B, C, D; b carte mémoire numérique 1 à 9.

2, une file d'attente de type tableau

file d' attente <poussée> couleur [ 5 ];
file d' attente <poussée> numéro [ 10 ]; 
file d' attente <poussée> triée;    

Utilisation #include <file> sont les types de tableaux établis file d'attente est une file d'attente poussée dans chaque groupe.

Dans lequel le numéro de carte de mémoire numérique séquentiel, une couleur séquentielle des cartes mémoire de couleurs, le nombre et les tableaux de couleurs est 0 file d'attente ne sont pas (avec ou sans l'ensemble des lignes). triés pour le tri final file d'attente de tri fini (non de type réseau).

En second lieu, l'idée de l'algorithme

Tout d'abord établir neuf file d'attente pour stocker la taille des points, en fonction du nombre de points les cartes dans leur magasin dans la file d'attente, la file d'attente puis appuyez sur 1 à 9 suivi d'une file d'attente d'équipe.
Par exemple, pour les résultats ci-dessus, après séquentiellement dans l'équipe avec les résultats suivants:
Queue 1: C1; cohorte 3: D3, la file d'attente 4: C4, A4
Après quoi, à son tour, est une équipe, le résultat est C1, D3, C4, A4
Ensuite, la mise en place de quatre files d'attente pour le stockage de la couleur. Emmagasinée par la combinaison de la carte A ~ D ~ 1 4 dans la file d'attente, la file d'attente à une file d'attente, puis dequeued 4 séquentiellement.
Par exemple, une séquence immédiatement au-dessus équipe C1, D3, C4, A4, qui est à son tour dans l'équipe avec les résultats suivants:
Queue 1: A4; cohorte 3: C1, C4; cohorte 4: D3
Après quoi, à son tour, est une équipe, le résultat est A4, C1, C4, D3, la commande d'une fin.

Pseudo-code

Une entrée n;
 2 . Boucle n fois;
     2,1 entrée pa, entrée pb;
     2,2 p-pb chiffres dans la première équipe
 . 3 i de 1 à 9 cycles.
     3.1 Cycle de vider les numéros d'équipe i
         3.1 . 1 p = Nombre [I] .front ();
         3.1 . 2 Couleur [PA - ' A ' + 1 ] .Le bouton (P);
         3.1 . 3. Number [I] .pop ();
 4 .i de 1 à 4 cycles
     4.1 Cycle à i couleur de l' équipe vider
         4,1 . 1. P = couleur [i] .front ();
         4.1 . 2sorted.push (p);
        4.1 . 3 couleurs [i] .pop ();
5 .输出trié

En troisième lieu, la complexité et le temps complexité espace

1, complexité temporelle

Si le tri donné triée bien, puis passer par les données d'entrée n fois, les temps 9n les données incluses dans l'équipe numérique, les temps 4n les données de couleur inclus dans l'équipe, puis sortie tri, de sorte que la complexité est en O (n) .

Si le type de trouble est donné, le processus est le même que la séquence positive, la complexité est encore temps O (n).

2, la complexité de l'espace

la complexité de l'espace est O (1).

3, par rapport à la tri à bulles

(1) la complexité du temps: meilleur temps à la complexité de tri à bulles est O (n), la pire complexité est en O (n ^ 2), et la complexité temporelle de l'algorithme est O (n).

(2) la complexité spatiale: sont O (1).

En quatrième lieu, les spectacles de code

 

#include <iostream> 
#include <file>

en utilisant l'  espace de noms std;

typedef struct {
     carboniser a;
    int b;
}poussée;

int main()
{
    file d' attente <poussée> couleur [ 5 ];
    file d' attente <poussée> numéro [ 10 ];
    pousser p;
    int n;
    cin >> n;
    pour ( int i = 0 ; i <n; i ++ ) {
        cin >> pa >> pb;
        nombre [pb] .Le bouton (p);
    }
    pour ( int i = 1 ; i <= 9 ; i ++ ) {
        Cout << " file d' attente " << i << " : " ;
        tandis que (! nombre [i] .empty ()) {
            p = nombre [i] .front ();
            Cout << pa << << PB "  " ;
            couleur [pa - ' A ' + 1 ] .Le bouton (p);
            nombre [i] .pop ();
        }
        Cout << " \ n " ;
    }
    file d' attente <poussée> triée;
    pour ( int i = 1 ; i <= 4 ; i ++ ) {
        cout << " File d' attente " << carbonisation ( ' A ' + i - 1 ) << " : " ;
        tandis que (! couleur [i] .empty ()) {
            p = couleur [i] .front ();
            Cout << pa << << PB "  " ;
            sorted.push (p);
            couleur [i] .pop ();
        }
        Cout << " \ n " ;
    }
    tandis que (! sorted.empty ()) {
        p = sorted.front ();
        Cout << pa << << PB "  " ;
        sorted.pop ();
    }
    retourner  0 ;
}

Si ce cas l'entrée, la sortie est affichée:

 

 

 

 

V. Résumé

En utilisant une des files d'attente de type de tableau réduire considérablement la complexité du problème, bien que le nombre peut être réutilisé pour stocker un tableau de couleurs, mais déroutant et difficile à utiliser un type de tableau est que chaque équipe est une équipe de tableau, et les éléments de structure de l'équipe sont Poke, pas si clair lorsque la compréhension initiale.