begin process at 2012 05 27 16:40:22
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Divers

 > GESTION DES LISTE CHAINÉES

GESTION DES LISTE CHAINÉES


 Information sur la source

Note :
1 / 10 - par 1 personne
1,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Divers Niveau :Débutant Date de création :12/07/2003 Date de mise à jour :29/09/2003 00:48:06 Vu :4 922

Auteur : Nicolus

Ecrire un message privé
Commentaire sur cette source (6)
Ajouter un commentaire et/ou une note

 Description

Petit source fournissant plusieurs fonctions permettant de gérer les listes chainées simples.
Ca peut toujours etre utile.

Source

  • // Auteur : nicof31@everyday.com
  • // But : - Montrer comment fonctionnent les listes simplement chainees
  • // - Offrir un set de fonctions reutilisables ou facilement adaptables pour d'autres programmes
  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <malloc.h> // a enlever selon le compilateur utilise (necessaire sous VC++)
  • ///////////////////////////////////
  • // Definition d'un maillon de liste
  • ///////////////////////////////////
  • typedef struct tag_link
  • {
  • int data;
  • struct tag_link *next;
  • } LINK;
  • //////////////////////
  • // Initialise la liste
  • //////////////////////
  • void Init(LINK *list)
  • {
  • list->next = NULL;
  • }
  • ////////////////////////////////////
  • // Ajoute un maillon en fin de liste
  • ////////////////////////////////////
  • void Add(LINK *list, int data)
  • {
  • LINK *next_link;
  • next_link = list;
  • while(next_link->next)
  • {
  • next_link = next_link->next;
  • }
  • next_link->next = malloc(sizeof(LINK));
  • (next_link->next)->data = data;
  • (next_link->next)->next = NULL;
  • }
  • //////////////////////////////////
  • // Insere un maillon dans la liste
  • //////////////////////////////////
  • int Insert(LINK *list, int pos, int data)
  • {
  • LINK *next_link, *sav_link;
  • int i;
  • next_link = list;
  • i = 0;
  • while(next_link->next && i < pos-1)
  • {
  • next_link = next_link->next;
  • i++;
  • }
  • if(i == pos-1)
  • {
  • sav_link = next_link->next;
  • next_link->next = malloc(sizeof(LINK));
  • (next_link->next)->data = data;
  • (next_link->next)->next = sav_link;
  • return 1;
  • }
  • else
  • {
  • return 0;
  • }
  • }
  • /////////////////////////////////
  • // Detruit un maillon de la liste
  • /////////////////////////////////
  • int Delete(LINK *list, int pos)
  • {
  • LINK *next_link, *sav_link;
  • int i;
  • next_link = list;
  • i = 0;
  • while(next_link->next && i < pos-1)
  • {
  • next_link = next_link->next;
  • i++;
  • }
  • if(i == pos-1)
  • {
  • sav_link = (next_link->next)->next;
  • free(next_link->next);
  • next_link->next = sav_link;
  • return 1;
  • }
  • else
  • {
  • return 0;
  • }
  • }
  • /////////////////////////////////////////
  • // Libere la memoire allouee par la liste
  • /////////////////////////////////////////
  • void Free(LINK *list)
  • {
  • LINK *next_link, *next2_link;
  • next2_link = list->next;
  • while(next2_link)
  • {
  • next_link = next2_link;
  • next2_link = next_link->next;
  • free(next_link);
  • }
  • list->next = NULL;
  • }
  • //////////////////////////////////////////////////
  • // Affiche le nb de maillons que contient la liste
  • //////////////////////////////////////////////////
  • int Count(LINK *list)
  • {
  • LINK *next_link;
  • int i;
  • next_link = list;
  • i = 0;
  • while(next_link->next)
  • {
  • next_link = next_link->next;
  • i++;
  • }
  • return i;
  • }
  • ///////////////////////////////////
  • // Affiche les elements de la liste
  • ///////////////////////////////////
  • void Print(LINK *list)
  • {
  • LINK *next_link;
  • int i;
  • next_link = list;
  • i = 0;
  • while(next_link->next)
  • {
  • next_link = next_link->next;
  • printf("Maillon %d : %d\n", ++i, next_link->data);
  • }
  • printf("\n");
  • }
  • //////////////////////
  • // Fonction principale
  • //////////////////////
  • int main(void)
  • {
  • LINK list;
  • int i;
  • // Initialisation de la liste
  • Init(&list);
  • // On remplit la liste (ajouts d'elements en fin de liste)
  • for(i = 0; i < 5; i++)
  • {
  • Add(&list, 2*i);
  • }
  • Print(&list);
  • // Insertion d'un element en milieu de liste
  • Insert(&list, 4, -20);
  • Print(&list);
  • // Suppression d'un element en milieu de liste
  • Delete(&list, 2);
  • Print(&list);
  • // Compte et affiche le nombre d'elements que contient la liste
  • printf("La liste comporte %d elements\n", Count(&list));
  • // Libere la memoire allouee pour les elements de la liste
  • Free(&list);
  • return 1;
  • }
// Auteur : nicof31@everyday.com
// But    : - Montrer comment fonctionnent les listes simplement chainees
//         - Offrir un set de fonctions reutilisables ou facilement adaptables pour d'autres programmes



#include <stdio.h>
#include <stdlib.h>
#include <malloc.h> // a enlever selon le compilateur utilise (necessaire sous VC++)


///////////////////////////////////
// Definition d'un maillon de liste
///////////////////////////////////
typedef struct tag_link
{
  int              data;
  struct tag_link  *next;
} LINK;


//////////////////////
// Initialise la liste
//////////////////////
void Init(LINK *list)
{
  list->next = NULL;
}


////////////////////////////////////
// Ajoute un maillon en fin de liste
////////////////////////////////////
void Add(LINK *list, int data)
{
  LINK  *next_link;


  next_link = list;
  while(next_link->next)
  {
    next_link = next_link->next;
  }

  next_link->next = malloc(sizeof(LINK));

  (next_link->next)->data = data;
  (next_link->next)->next = NULL;
}


//////////////////////////////////
// Insere un maillon dans la liste
//////////////////////////////////
int Insert(LINK *list, int pos, int data)
{
  LINK  *next_link, *sav_link;
  int   i;


  next_link = list;
  i = 0;
  while(next_link->next && i < pos-1)
  {
    next_link = next_link->next;
    i++;
  }

  if(i == pos-1)
  {
    sav_link = next_link->next;
    next_link->next = malloc(sizeof(LINK));
    (next_link->next)->data = data;
    (next_link->next)->next = sav_link;

    return 1;
  }
  else
  {
    return 0;
  }
}


/////////////////////////////////
// Detruit un maillon de la liste
/////////////////////////////////
int Delete(LINK *list, int pos)
{
  LINK  *next_link, *sav_link;
  int   i;
  
  
  next_link = list;
  i = 0;
  while(next_link->next && i < pos-1)
  {
    next_link = next_link->next;
    i++;
  }

  if(i == pos-1)
  {
    sav_link = (next_link->next)->next;
    free(next_link->next);
    next_link->next = sav_link;

    return 1;
  }
  else
  {
    return 0;
  }
}


/////////////////////////////////////////
// Libere la memoire allouee par la liste
/////////////////////////////////////////
void Free(LINK *list)
{
  LINK  *next_link, *next2_link;

  
  next2_link = list->next;

  while(next2_link)
  {
    next_link = next2_link;
    next2_link = next_link->next;
    free(next_link);
  }

  list->next = NULL;
}


//////////////////////////////////////////////////
// Affiche le nb de maillons que contient la liste
//////////////////////////////////////////////////
int Count(LINK *list)
{
  LINK  *next_link;
  int   i;


  next_link = list;
  i = 0;
  while(next_link->next)
  {
    next_link = next_link->next;
    i++;
  }

  return i;
}


///////////////////////////////////
// Affiche les elements de la liste
///////////////////////////////////
void Print(LINK *list)
{
  LINK  *next_link;
  int   i;


  next_link = list;
  i = 0;
  while(next_link->next)
  {
    next_link = next_link->next;
    printf("Maillon %d : %d\n", ++i, next_link->data);
  }

  printf("\n");
}


//////////////////////
// Fonction principale
//////////////////////
int main(void)
{
  LINK  list;
  int   i;


  // Initialisation de la liste
  Init(&list);

  // On remplit la liste (ajouts d'elements en fin de liste)
  for(i = 0; i < 5; i++)
  {
    Add(&list, 2*i);
  }
  Print(&list);

  // Insertion d'un element en milieu de liste
  Insert(&list, 4, -20);
  Print(&list);

  // Suppression d'un element en milieu de liste
  Delete(&list, 2);
  Print(&list);

  // Compte et affiche le nombre d'elements que contient la liste
  printf("La liste comporte %d elements\n", Count(&list));

  // Libere la memoire allouee pour les elements de la liste
  Free(&list);

  return 1;
}



 Sources du même auteur

Source avec Zip Source avec une capture MECAPHI (SIMULATEUR DE TRAJECTOIRES)
Source avec Zip Source avec une capture MOTEUR 3D SOFTWARE SOUS WINDOWS (+EXE)
Source avec Zip Source avec une capture JEU D'ECHECS WINDOWS AVEC IA (+EXE)
Source avec Zip Source avec une capture ENLEVER LES MSG D'AVERTISSEMENT DES PROG VC++ INTRODUCTORY E...
Source avec Zip Source avec une capture EASYPROTECT (CRYPTAGE DE FICHIERS)

 Sources de la même categorie

Source avec Zip KISIEL CD INFO DRIVE par kisiel0147852
Source avec une capture SUPPRESSION DES REDONDANCES DE FICHIERS par cyberntique
Source avec Zip ÉDITEUR DE RECTANGLES EN CONSOLE par seoseo
CONVERSION DE FICHIER EN FICHIER BMP par seoseo
Source avec Zip DETECTEUR EJP par idpro

Commentaires et avis

Commentaire de Kirua le 13/07/2003 22:33:06

on peut l'utiliser seulement avec des int, c dommage. faudrait essayer de la globaliser pour n'importe quel type de donnée (data), ce serait top ;-)

Commentaire de Nicolus le 15/07/2003 18:46:16

une petite idee qui me passe par la tete (faudrait essayer) :
tu definis LINK comme ceci:
typedef struct {
    struct tag_mesdonnees data;
    struct tag_link *next;
} LINK;

ca doit regler le pb dont tu me parles.

Commentaire de Kirua le 15/07/2003 19:32:01

ah vi mais la structure tag_mesdonnées je la crée pour l'occasion alors? parce que je sais qu'il y a moyen de généraliser directement, je pense en mettant void* comme type de données, on pourrait mettre ce qu'on veut dedans. je ne sais pas trop, j'ai vu ça qq part. ce que tu me proposes n'est pas très pratique, ou bien j'ai pas compris, parce qu'il suffirait de changer la déclaration de int data vers TypeVoulu data directement. enfin j'ai peut etre pas compris :-)

Commentaire de NiFF le 18/07/2003 02:22:47

oui avec void* on pointe vers ce qu'on veut comme données, c'est la meilleure solution.
C'est Maths et Algorithmes la catégorie.

Commentaire de Kirua le 18/07/2003 03:43:03

ok merci pr la confirmation NiFF.
qu'est-ce qui va ds math et algo? les listes chaînées?

Commentaire de NiFF le 18/07/2003 16:45:19

Listes chainées, arbres, graphes, tout ça va dans algo et toutes les calculettes/traceur de fonctions/outils mathématiques pareil

 Ajouter un commentaire




Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,484 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales