implementation stack with array and pointers

source_codes/piles/pile_array_int.c

+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <limits.h>
+#include"pile_array_int.h"
+
+bool pile_est_valide(pile stack) {
+   return (stack.capacite > 0 && stack.sommet >= -1 && stack.data != NULL);
+}
+
+bool pile_est_vide(pile stack) {
+   assert(pile_est_valide(stack));
+   return (-1 == stack.sommet);
+}
+
+bool pile_est_pleine(pile stack) {
+   assert(pile_est_valide(stack));
+   return (stack.capacite-1 == stack.sommet);
+}
+
+int pile_count(pile stack) {
+   assert(pile_est_valide(stack));
+   return stack.sommet+1;
+}
+
+int pile_sommet(pile stack) {
+   assert(!pile_est_vide(stack));
+   return stack.data[stack.sommet]; 
+}
+
+pile pile_creer(int max) {
+   assert(max > 0);
+   pile stack;
+   stack.capacite = max;
+   stack.sommet = -1;
+   stack.data = malloc(max*sizeof(int));
+   return stack;
+}
+
+void pile_resize(pile* stack,int max) {
+   assert(pile_est_valide(*stack));
+   if (max > stack->capacite) {
+      stack->capacite = max;
+      stack->data = realloc(stack->data,max*sizeof(int));
+   }
+}
+
+void pile_detruire(pile* stack) {
+   stack->capacite = -1;
+   stack->sommet = INT_MIN;
+   free(stack->data);
+   stack->data = NULL;
+}
+
+void pile_empiler(pile* stack,int val) {
+   if (pile_est_pleine(*stack)) {
+      pile_resize(stack,stack->capacite+INCR);
+   }
+   stack->sommet++;
+   stack->data[stack->sommet] = val;
+}
+
+int pile_depiler(pile* stack) {
+   int val = pile_sommet(*stack);
+   stack->sommet--;
+   return val; 
+}
+

source_codes/piles/pile_array_int.h

+#ifndef PILE_ARRAY_INT_H
+#define PILE_ARRAY_INT_H
+
+#include <stdbool.h>
+const int INCR = 100;
+
+typedef struct _pile {
+   int* data;
+   int sommet;
+   int capacite;
+} pile;
+
+//Créer une nouvelle pile vide
+pile pile_creer(int max);
+//Libérer le tableau, mettre la capacité à < -1
+void pile_detruire(pile* stack);
+//Empiler un élement au sommet de pile
+void pile_empiler(pile* stack,int val);
+//Dépiler un élément du sommet de la pile
+int pile_depiler(pile* stack);
+//Tester si la pile est vide
+bool pile_est_vide(pile stack);
+//Tester si la pile est pleine
+bool pile_est_pleine(pile stack);
+//Consulter l'élément au sommet de la pile
+int pile_sommet(pile stack);
+//Compter du nombre d'éléments de la pile:
+int pile_count(pile stack);
+
+#endif
+
+
+
+
+

source_codes/piles/pile_ptr_int.c

+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "pile_ptr_int.h"
+
+
+//Creer une nouvelle pile vide
+pile pile_creer() {
+   return NULL;
+}
+
+//Tester si la pile est vide
+bool pile_est_vide(pile stack) {
+	return (NULL == stack);
+}
+
+//Inserer un élement en début de pile
+void pile_empiler(pile* stack,int data) {
+   element* elmt = malloc(sizeof(element));
+   elmt->data = data;
+   elmt->next = *stack;
+   *stack = elmt;
+}
+
+//Consulter l'élément au sommet de la pile
+int pile_sommet(pile stack) {
+   assert(!pile_est_vide(stack));
+   return stack->data;
+}
+
+//Supprimer un élément de la pile
+int pile_depiler(pile* stack) {
+   int data = pile_sommet(*stack);
+   element* elmt = *stack;
+   *stack = (*stack)->next; 
+   free(elmt);    
+   return data; 
+}
+
+//Désallouer complètement la pile
+void pile_detruire(pile* stack) {
+   while (!pile_est_vide(*stack)) {      
+      int data = pile_depiler(stack);
+   }   
+}
+
+//Compter le nombre d'éléments de la pile:
+int pile_count(pile stack) {
+   int cnt = 0;
+   while (NULL != stack) {      
+      stack = stack->next;
+      cnt++;
+   }
+   return cnt;
+}
+
+/////////////////////////////////////////////////////////
+/*
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include "stack.h"
+
+void print(void* a) {
+   int* b = (int*)a;
+   printf("%d ",*b);
+}
+int cmp(void* a,void* b) {
+   int* aa = (int*)a;
+   int* bb = (int*)b;
+   if (*aa == *bb) return 0;
+   else if (*aa < *bb) return -1;
+   else return 1;
+}
+   
+int main() {
+
+   Stack_Elmt* pile = stack_create();
+   int a = 3;
+   pile = stack_push(pile,&a);
+   int b = 6;
+   pile = stack_push(pile,&b);
+   int c = 7;
+   pile = stack_push(pile,&c);
+   stack_process(pile,print); printf("\n");
+   int d = 6;
+   Stack_Elmt* elmt = stack_pop(pile,&d,cmp);
+   int* tutu = (int*)(elmt->data);
+   printf("%d\n",*tutu);
+   stack_process(pile,print); printf("\n");
+   return 0;   
+}*/
+
+
+

source_codes/piles/pile_ptr_int.h

+/* pour éviter que le précompilateur inclue plusieurs fois le fichier .h */
+#ifndef PILE_PTR_INT_H  
+#define PILE_PTR_INT_H
+#include <stdbool.h>
+
+/* Utilité du typedef : Element a; <=> struct Element a; */
+typedef struct _element {
+   int data;
+   struct _element* next;
+} element;
+typedef element* pile;
+
+//Créer d'une nouvelle pile vide
+pile pile_creer();
+//Désallouer complètement la pile
+void pile_detruire(pile* stack);
+//Empiler un élement en début de pile
+void pile_empiler(pile* stack,int data);
+//Dépiler un élément de la pile
+int pile_depiler(pile* stack);
+//Consulter l'élément au sommet de la pile
+int pile_sommet(pile stack);
+//Tester si la pile est vide
+bool pile_est_vide(pile stack);
+//Compter le nombre d'éléments de la pile:
+int pile_count(pile stack);
+#endif
+
+
+
+
+

source_codes/piles/pile_ptr_int_skel.c

+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "pile_ptr_int.h"
+
+//Creer une nouvelle pile vide
+pile pile_creer() {
+   return NULL;
+}
+
+//Tester si la pile est vide
+bool pile_est_vide(pile stack) {
+   return (NULL == stack);
+}
+
+//Inserer un élement en début de pile
+void pile_empiler(pile* stack,int val) {
+   element* elmt = malloc(sizeof(element));
+   elmt->data = val;
+   elmt->next = *stack;
+   *stack = elmt;
+}
+
+//Consulter l'élément au sommet de la pile
+int pile_sommet(pile stack) {
+   assert(!pile_est_vide(stack));
+   return stack->data;
+}
+
+//Supprimer un élément de la pile
+int pile_depiler(pile* stack) {
+   int data = pile_sommet(*stack);
+   // à compléter    
+   return data; 
+}
+
+//Désallouer complètement la pile
+void pile_detruire(pile* stack) {
+   // à compléter   
+}
+
+//Compter le nombre d'éléments de la pile:
+int pile_count(pile stack) {
+   int cnt = 0;
+   // à compléter
+   return cnt;
+}
+
+