1

J'ai besoin de trier un tableau à n éléments
est-ce que vous pouvez me donner un algo pour faire ca ?
(itératif ou récursif, si possible en Basic ou en C)
le seul que j'ai trouvé est pas très rapide :
je cherche ds la liste un entier supérieur (ou inf)
qu'en j'en ai un, je le permute avec celui à partir duquel je suis parti :
|5|25|72|13||||||||||||||
____/
confusconfus

2

// tri par shell metzner
void tri( int *array, int elements)
{
int p, k, t, i, j;
p = elements;
p /= 2;
while ( p != 0 )
  {
  k = elements - p;
  for ( t = 0; t < k; t++ )
    {
    i = t;
    while ( i >= 0 )
      {
      j = i + p;
      if (*(array+j) < *(array + i))
        {
        Swap_nb(i,j);
        i = i - p;
        }
      else
        break;
      }
    }
  p /= 2;
  }
}

3

bah ton truc c le bubble sort...
essaye le radix sort... c vachement + rapide tu trie en faisant des piles des nombres en fonction de leur chiffres des centaines (ou milliers) puis des dixaines, des unités et après ton truc est trié...

par ex just pour les centaines:

 125 32 658 23 1 456 85 265

  85
  1
  23
  32   125  265       456       658
|____|____|____|____|____|____|____|____|____|____|
  0    1    2    3    4    5    6    7    8    9


après tu fé pareil pour les dixaines et les unités...
In many respects the Yoshi is like a beautiful woman. A man can come so enamoured that he bestows on her all his time, his energy and his fortune.
- Fred whipple, 1960

*** Ne sous-estimez pas la puissance de la Marmotte ***
© Marmotte Team : LaMarmotte, sBibi, Vark & Sabrina

4

http://tigcc.ticalc.org/doc/stdlib.html#qsort
C'est une fonction ANSI C, donc portable.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

5

hmmm j'ai meme mieux..... c'est que les tris je les ai traité dans mon debu de tuto... honte à toi...
http://www.ti-fr.org/prog/index.php3?do=basic/tuto/chap6
avatar
Il n'a pas de mots
Décrire son mépris
Perdre les rênes
Il a perdu la foi

6

je sais que personne ne le lit, mais quand vous avez une question du genre tri de tableau... c'est tout ecrit dedans... ca m'enerve qu'a moitié mais bon... admettons que ce soit mal ecrit, ou mal fait, je sais pas, dites le moi...!!!
avatar
Il n'a pas de mots
Décrire son mépris
Perdre les rênes
Il a perdu la foi

7

Moi, je me demande pourquoi il y a une fonction qsort dans les librairies C si personne ne l'utilise. roll Cette fonction n'est pas là pour les chiens!
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

8

bah, y a plus rapide que Qsort...
In many respects the Yoshi is like a beautiful woman. A man can come so enamoured that he bestows on her all his time, his energy and his fortune.
- Fred whipple, 1960

*** Ne sous-estimez pas la puissance de la Marmotte ***
© Marmotte Team : LaMarmotte, sBibi, Vark & Sabrina

9

raison suffisante ...roll

10

quand même infiniment plus rapide, c'est appréciable!!
Site : http://www.phareaway.com/
Membre du groupe Phare Away et webmaster du site

11

Pour les listes vraiment en désordre, c pas + rapide le tri genre "Diviser pour régner" récursif ?

[i]Ex : 

int* Fonction Trier(int tableau[], int NbrElements)
{
       
       if(NbrElements == 2)
       {
              if(tableau[0] > tableau[1])
              {
                       int temp = tableau[0]; 
                       tableau[0] = tableau[1]; 
                       tableau[1] = temp;
               }
       return tableau;
       } 

       int Milieu  = NbrElements/2;
       int* tableau_1;
       int* tableau_2;

       for (int i=0; i<Milieu; i++)
       {
              tableau_1[i] = tableau[i];
        }
       for (int i=0; i<Milieu; i++)
       {
              tableau_2[i] = tableau[Milieu+i];
        }

       tableau_1 = Trier(tableau_1, Milieu);
       tableau_2 = Trier(tableau_1, Milieu);
       tableau = fusionner(tableau_1, tableau_2);

       return tableau;
}

[/i] 


[dsl si c 1 peu long...]eek
whether the weather be fine
or whether the weather be not,
whatever the weather,
we'll weather the weather

12

C'est exactement ça le QuickSort, qui est censé être implémenté par qsort.

Remarque: la version de TIGCCLIB est optimisée en taille plutôt qu'en vitesse, et c'est un ShellSort, pas un QuickSort. Selon Zeljko, il n'y avait pas de différence de vitesse remarquable avec la taille de tableaux qu'on rencontre habituellement sur TI-89/92+. Je fais d'ailleurs remarquer que pour de petits tableaux, des techniques comme le ShellSort sont plus rapides que le QuickSort.

Autre remarque: théoriquement, la technique la plus rapide est le HeapSort, mais en pratique, le QuickSort est plus rapide parce que la taille à partir de laquelle HeapSort devient plus rapide est très grande.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

13

c vrai que dans les cas les plus simples, l'itératif est + rapide que le récursif...roll

HeapSort, c la technique des tableaux, où l'on classe par centaines, dizaines, etc...
ou est-ce que l'on utilise une pile ?confus
whether the weather be fine
or whether the weather be not,
whatever the weather,
we'll weather the weather

14

entre les deux, c'est juste un rapport de proportionnalité... diviser pour régner fait du n*ln(n), donc c'est du bon gringringrin
Site : http://www.phareaway.com/
Membre du groupe Phare Away et webmaster du site

15

Miles > tu dois être calé, en algo, (supelec oblige...)

et le bubble sort, c en n² ???confus
whether the weather be fine
or whether the weather be not,
whatever the weather,
we'll weather the weather

16

Le maximum théorique...
Je peux partir d'ici :
J'ai retrouvé mon nom !

Le Forum Ghibli

17

ouais love
Le prof de stat, ce matin : "à Lille, on a fait une fois des tests sur les tris : certains 5h, d'autres 1s"

et je suis dans la bonne moitié, à Supélec - en fait, major jusqu'aux prochains résultats... -
Site : http://www.phareaway.com/
Membre du groupe Phare Away et webmaster du site

18

bravo bravo ? t'as ne id d'où tu vas travailler après, ou ce sera au + offrant ?

Revenons aussi au sujet du topic, ou zougege84 va vouloir se venger sur ma casio 2main...cool
whether the weather be fine
or whether the weather be not,
whatever the weather,
we'll weather the weather

19

>Miles:
>entre les deux, c'est juste un rapport de proportionnalité... diviser pour régner fait du n*ln(n), donc c'est du bon grin grin grin

Non, le QuickSort (qui est l'application du "diviser pour régner" au tri) est entre O(n*ln(n)) et O(n²) selon les cas. HeapSort est toujours en O(n*ln(n)), mais avec un coefficient plus grand devant, donc en pratique, ça ne se voit que pour de gros tableaux. BubbleSort, ShellSort, ... sont tous en O(n²) si je ne me trompe, mais le coefficient devant est bien plus petit que celui du QuickSort, donc pour les petits tableaux, c'est plus rapide. C'est d'ailleurs pour ça que les implémentations optimisées de QuickSort passent à une de ces techniques une fois que le tableau a été coupé en tableaux suffisamment petits.


Et encore une fois: utilisez qsort, ça utilisera automatiquement un algorithme adapté à votre système (QuickSort sur un PC, et autre chose - ShellSort en l'occurrence - sur un système comme les TI-89/92+).
[edit]Edité par Kevin Kofler le 03-04-2002 à 00:34:49[/edit]
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

20

Mais le Quicksort est en n^2 si le tableau est déjà quasiment trié (ou s'il est trié en ordre décroissant), ce qui peut être embêtant dans certains problèmes.
Je peux partir d'ici :
J'ai retrouvé mon nom !

Le Forum Ghibli

21

ah oui, c'est le tri fusion qui est toujours en n*ln(n) alors...

Tu as raison, tri à bulle et C° sont en n^2 et HeapSort en n*ln(n), mais son implémentation est un peu plus ardue... même en CAML...
Site : http://www.phareaway.com/
Membre du groupe Phare Away et webmaster du site

22

Oui, HeapSort est vraiment trop complexe pour ce qu'il rend en pratique (du moins à en croire ce qu'on peut lire).
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

23

chez moi, je dois avoir les fonctions codées, mais j'étais pas en forme quand on l'a expliqué alors... à la trappe grin
Site : http://www.phareaway.com/
Membre du groupe Phare Away et webmaster du site

24

et pour les tris suivant deux facteurs, vous suggérez quoi ?
whether the weather be fine
or whether the weather be not,
whatever the weather,
we'll weather the weather

25

tu tries selon le facteur moins important puis tu retries en priant que le tri précédent ne renverse pas l'ordre des mêmes valeurs.
Site : http://www.phareaway.com/
Membre du groupe Phare Away et webmaster du site

26

ou tu changes la fonction de comparaison, tout simplement. (ordre lexicographique)

x < y <=> ( (x.facteur1 < y.facteur1) ou (x.facteur1 = y.facteur1 et x.facteur2 < y.facteur2 ) )
Je peux partir d'ici :
J'ai retrouvé mon nom !

Le Forum Ghibli

27

>Miles: tu tries selon le facteur moins important puis tu retries en priant que le tri précédent ne renverse pas l'ordre des mêmes valeurs.

Ou en faisant attention à utiliser un algorithme adapté. C'est quand-même plus sûr. grin

>telchar:
>ou tu changes la fonction de comparaison, tout simplement. (ordre lexicographique)
> x < y <=> ( (x.facteur1 < y.facteur1) ou (x.facteur1 = y.facteur1 et x.facteur2 < y.facteur2 ) )

C'est mieux comme idée. Avec qsort, c'est facile à utiliser:

#ifdef __TIGCC_ENV__
typedef short qsort_t;
#else
typedef long qsort_t;
#ifndef CALLBACK
#define CALLBACK
#endif
#endif

typedef struct EXAMPLE_STRUCT {int facteur1, facteur2;} example_struct;

CALLBACK qsort_t cmpfunc(const void *a, const void *b)
{
return ((((example_struct*)a)->facteur1==((example_struct*)b)->facteur1)?(((example_struct*)a)->facteur2-((example_struct*)b)->facteur2):
(((example_struct*)a)->facteur1-((example_struct*)b)->facteur2));
}

[edit]Edité par Kevin Kofler le 03-04-2002 à 01:13:01[/edit]
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

28

voilà l'algo du heapsort : (programme complet)

#include <stdio.h>

#define N 15
int tab[N] = {6, 2, 1, 4, 3, 47, 48, 46, 230, 150, 12, 5, 8, 13, 75};

void descent(int tab[], int n, int indtest)
{
int filsgind, desc, planque, max;

filsgind = indtest*2;
desc = 1;
planque = tab[indtest-1];
while ((desc)&&(indtest <= n/2)) {
max = filsgind; // max est l'indice du plus grand des 2 fils
if (filsgind < n) { // il y a un fils droit
if (tab[filsgind] > tab[filsgind-1])
max = filsgind +1;
}
if (tab[indtest-1] < tab[max-1]) {
tab[indtest-1] = tab[max-1];
tab[max-1] = planque;
indtest = max;
filsgind = max*2;
}
else
desc = 0;
}
}

void tripartas(int tab[], int n)
{
int i, y, temp;

if (n==1)
return;
for (y=n/2; y>=1; y--)
descent(tab, n, y);
for (i=n; i>=3; i--) {
temp = tab[0];
tab[0] = tab[i-1];
tab[i-1] = temp;
descent(tab, i-1, 1);
}
temp = tab[0];
tab[0] = tab[1];
tab[1] = temp;
}

void main(void)
{
int i;

for(i=0;i<N;i++)
printf("%u ", tab[i]);
printf("n")
tripartas(tab, N);
for(i=0;i<N;i++)
printf("%u ", tab[i]);
}

29

Arretez de parler de ce que vous connaissez pas. Le meilleur, le plus efficace, c'est, dans le domaine du classement d'elements non entiers, c'est le tri par fusion.
Qu'on ne me dise pas que :
* C'est complique a faire : c'est ultra simple en assembleur.
* Que le coefficient devant le n*ln(n) est gros : il doit y avoir pas plus de 10 instructions assembleurs.

Je ne connais pas de tri offrant des performances aussi exellentes (a part le tri d'entiers).

30

Pour le tri suivant deux facteurs, on peut pondérer chaque facteur pour calculer une donnée caractérisant chaque élément, et classer les éléments suivant cette donnée ? confus

Sinon, je pense qu'on peut utiliser des arbres binaires, pour les entiers, c très très rapide, non cool
whether the weather be fine
or whether the weather be not,
whatever the weather,
we'll weather the weather