tri de tableau

Voila j'ai un tableau de DIM 2 (unsigned int Tab[9][9])
je voudrais ecrire un bout de code (STL OU PAS) permettant de disposer
d un pointeur PtTab qui donne acces a TAB mais de maniere trier par
ordre decroissant.je m'explique
exemple:

Tab[0][0-8]={2,1,3,5,9,6,7,8,4} 8
Tab[1][0-8]={7,4,8,5,9,6,1,2,3} 5
Tab[2][0-8]={1,4,8,5,9,6,7,2,3} 9 (le plus petit)
Tab[3][0-8]={6,9,8,5,1,4,7,2,3} 6
Tab[4][0-8]={4,1,8,5,9,6,7,2,3} 7
Tab[5][0-8]={9,8,6,5,7,3,1,2,4} 1 (le plus grand )
Tab[6][0-8]={8,6,4,5,9,1,7,2,3} 4
Tab[7][0-8]={9,7,8,5,4,6,2,1,3} 2
Tab[8][0-8]={8,9,4,1,5,6,7,2,3} 3

je voudrais juste un pointeur qui me donne:
*PtTab me donne 5 (indice du tableau le plus grand)
PtTab++//j' incremente le pointeur
*PtTab me donne 7 (indice du tableau juste en dessous) etc...
*(PtTab+8) me donne 2 le tableau le plus petit

On note M le nombre de lignes de ton yableau, N le nombre de colonnes.
Voici une ébauche de suggestion:
1- créer le tableau PtTab, et le remplir de 0 à (M-1) dans l'ordre
croissant. A ma connaissance, la STL n'aide pas ici, donc tout bêtement:
int ptTab[M];
for(int i = 0 ; i < M ; ++i) ptTab[i] = i;

2- utiliser std::sort pour ordonner le tableau, en utilisant un comparator
spécial:
std::sort(ptTab, ptTab + M, comparator());

le comparator spécial est le suivant:
struct comparator
{
bool operator()(int lhs, int rhs)
{
const int* p = Tab[lhs], * q = Tab[rhs];
while((p - Tab[lhs] < M) && (*p == *q)) p++, q++;
return (*p > *q);
}
};


Bon courage,

SerGioGioGio

merci pour t on aide
je vais essayer d utiliser t on code pour
mon programme

horneta2005@yahoo.fr wrote:

Voila j'ai un tableau de DIM 2 (unsigned int Tab[9][9]) je
voudrais ecrire un bout de code (STL OU PAS) permettant de
disposer d un pointeur PtTab qui donne acces a TAB mais de
maniere trier par ordre decroissant.je m'explique
exemple:

Tab[0][0-8]={2,1,3,5,9,6,7,8,4} 8
Tab[1][0-8]={7,4,8,5,9,6,1,2,3} 5
Tab[2][0-8]={1,4,8,5,9,6,7,2,3} 9 (le plus petit)
Tab[3][0-8]={6,9,8,5,1,4,7,2,3} 6
Tab[4][0-8]={4,1,8,5,9,6,7,2,3} 7
Tab[5][0-8]={9,8,6,5,7,3,1,2,4} 1 (le plus grand )
Tab[6][0-8]={8,6,4,5,9,1,7,2,3} 4
Tab[7][0-8]={9,7,8,5,4,6,2,1,3} 2
Tab[8][0-8]={8,9,4,1,5,6,7,2,3} 3

Si tu mets les données dans un
std::vector< std::vector< int > >
, std::sort marche directement. Sinon, c'est un peu compliqué du
fait que les tableaux de type C ne sont pas de vrais objets : le
type contenu dans le tableau est int[9]. Et un int[9] n'est ni
CopyConstructable, ni Assignable, ce qui veut dire que les
algorithms comme sort ne peut pas l'utiliser comme value_type de
l'iterateur.

(En fait, la norme est un peu vague à cet égard ; je n'ai pas
réussi à trouver des restrictions sur le value_type d'un
itérateur. Mais il me semble évident que pour que sort marche,
il faut que le type soit CopyConstructable et Assignable.)

je voudrais juste un pointeur qui me donne:
*PtTab me donne 5 (indice du tableau le plus grand)
PtTab++//j' incremente le pointeur
*PtTab me donne 7 (indice du tableau juste en dessous) etc...
*(PtTab+8) me donne 2 le tab

Encore plus simple, d'un côté, parce que ce que tu tries est un
tableau d'entiers, ce qui évite le problème d'un value_type qui
est un tableau. En revanche, il va falloir que tu fournisses un
opérateur de comparaison. Quelque chose du genre :

template< typename T, size_t N, size_t M >
class IndexedCmp
{
public:
explicit IndexedCmp( T const table[ N ][ M ] )
: myTable( table )
{
}
bool operator()( size_t lhs, size_t rhs ) const
{
assert( lhs < N && rhs < N ) ;
std::pair< T const*, T const* >
r
= std::mismatch( begin( myTable[ lhs ] ),
end( myTable[ lhs ] ),
begin( myTable[ rhs ] ) ) ;
return r.first != end( myTable[ lhs ] ) && *r.first <
*r.second ;
}
private:
T const (* myTable)[ M ] ;
} ;

template< typename T, size_t N, size_t M >
inline IndexedCmp< T, N, M >
getIndexedCmp(
T const (& table)[ N ][ M ] )
{
return IndexedCmp< T, N, M >( table ) ;
}

La fonction libre permet de profitter de la déduction des
types ; on peut donc écrire simplement :

int const t0[ 9 ][ 9 ] =
{
{2,1,3,5,9,6,7,8,4},
{7,4,8,5,9,6,1,2,3},
{1,4,8,5,9,6,7,2,3},
{6,9,8,5,1,4,7,2,3},
{4,1,8,5,9,6,7,2,3},
{9,8,6,5,7,3,1,2,4},
{8,6,4,5,9,1,7,2,3},
{9,7,8,5,4,6,2,1,3},
{8,9,4,1,5,6,7,2,3},
} ;

std::vector< int > t1( boost::counting_iterator< int >( 0 ),
boost::counting_iterator< int >( 9 ) ) ;
std::sort( t1.begin() , t1.end(), getIndexedCmp( t0 ) ) ;

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34