[c] le tri, l'échange et les pointeurs

Commenter

Contenu du snippet

J'ai commencé par coder une fonction swap, ensuite je me suis dit que je pourrais m'en servir pour faire un tri bulle mais je me suis rappellé que le tri bulle je ne l'aime pas ^^...
Donc j'ai essayé de coder une fonction sort à ma sauce et comme y'a une chose que j'aime bien en C et qui s'apelle "pointeur" bah j'en ai usé et abusé ^^

Ce code est donc fait en C, très probablement compatible C++ et prend pour exemple un tableau char de 5 éléments... J'utilise le mode console pour afficher les résultats... C'est surtout les algos qui comptent pour moi...

J'ai utilisé le type de données size_t parce que c'est plus court à écrire que unsigned long ^^ et surtout parce que je l'ai vu dans plusieurs biblios (il est là donc autant l'utiliser)...

Les fonctions qui ne sont pas de moi sont :
malloc()
free() (quand on utilise malloc vaut mieux avoir celui là aussi...)
memcpy()

Je les aurai bien aussi codées moi même mais bon l'assembleur en ligne n'est pas le même partout et puis a part memcpy j'aurai pas pu coder grand chose...

J'essairai de les commenter, car seule la fonction main() l'est... Mais ceux qui connaissent le tri par insertion doivent pouvoir facilement s'y retrouver.

Voila... 36 15 My Life c'est terminé...

Source / Exemple : 


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

void swap(void*, void*, size_t);
void sort(void*, size_t, size_t, int (*)(void*, void*));

int char_superieur_ou_egal(void *a, void *b)
{
  return *((char*)a)>=*((char*)b);
}

int char_inferieur_ou_egal(void *a, void *b)
{
  return *((char*)a)>=*((char*)b);
}

void swap(void *buffer1, void *buffer2, size_t size)
{
  void *buffer3;
  
  buffer3 = malloc(size);
  
  memcpy(buffer3, buffer1, size);
  memcpy(buffer1, buffer2, size);
  memcpy(buffer2, buffer3, size);
  
  free(buffer3);
}

void sort(void *buffer, size_t size, size_t count, int (*compare)(void*, void*))
{
  size_t left, right, i;
  void *temp;
  
  temp = (void*) malloc(size);
  
  for(right=0; right<count; right++)
  {
    memcpy(temp, buffer+size*right, size);
    for(left=0; left<right; left++)
      if(compare(buffer+size*right, buffer+size*left)==1) break;
    if(left<right)
    {
      for(i=right; i>left; i--)
        memcpy(buffer+size*i, buffer+size*(i-1), size);
      memcpy(buffer+size*left, temp, size);
    }
  }
  
  free(temp);
  
}

#define TAB_COUNT 5
#define AFFICHER_LE_TABLEAU for (i=0; i<TAB_COUNT; i++) printf("%d\n", tab[i])

main()
{
  //on a besoin d'un tableau et d'une variable pour les boucles
  char tab[TAB_COUNT], i;
  int (*comparaison)(void*, void*);
  
  //on rempli le tableau dont on affiche les valeurs
  for (i=0; i<TAB_COUNT; i++)
    tab[i]=rand()%20;
  AFFICHER_LE_TABLEAU;

  //tri dans l'ordre décroissant
  printf("\n");
  sort(tab, sizeof(char), TAB_COUNT, &char_superieur_ou_egal);
  AFFICHER_LE_TABLEAU;
  
  //tri dans l'ordre croissant
  printf("\n");
  sort(tab, sizeof(char), TAB_COUNT, &char_inferieur_ou_egal);
  AFFICHER_LE_TABLEAU;
  
  //on inverse les deux premiers éléments du tableau
  printf("\n");
  swap(&tab[0], &tab[1], sizeof(char));
  AFFICHER_LE_TABLEAU;

  getch();
}

Conclusion :


Au programme, surtout ce qui touche à la mémoire :
-pointeurs
-pointeurs de fonction
-allocation dynamique
-libération de la mémoire

Le tout de façon générique (fonctionne avec "tous" les types)

Avec ca comme point de départ (surtout le swap...) on peut facilement mettre en oeuvre une biblio en C pour faire des listes chaînées, je pense que je vais me lancer là dedans.

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_Dri)