Partage
  • Partager sur Facebook
  • Partager sur Twitter

implémentation pile tableau

    19 janvier 2022 à 11:47:15

    Bonjour openclassrooms, 

    Je suis débutant en programmation C.

    Je veux implémenter une pile à l'aide d'un tableau, en commençant par vérifier si la pile est vide j'ai fait ça : 

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct Stack stack;//array
    struct stack
    {
        int maxsize;    // define max capacity of the stack
        int top;
        int *items;
    };
    
    struct stack* newStack(int capacity)
    {
        struct stack *pt = (struct stack*)malloc(sizeof(struct stack));
     
        pt->maxsize = capacity;
        pt->top = -1;
        pt->items = (int*)malloc(sizeof(int) * capacity);
     
        return pt;
    }
    
    int isEmpty(struct stack *pt) {
        return pt->top == -1;                 
    }

    il y a moyen de faire : stack à la place de int pour retourner la pile vide

    stack isEmpty(struct stack *pt) {
        return pt->top == -1;                 
    }




    -
    Edité par ManaMana2 19 janvier 2022 à 12:15:02

    • Partager sur Facebook
    • Partager sur Twitter
      19 janvier 2022 à 14:24:56

      Ton typedef défini un type qui correspond à struct Stack or tu n'as pas défini de structure struct Stack.

      (Tu as bien une structure, mais elle se nomme struct stack).

      • Partager sur Facebook
      • Partager sur Twitter
        19 janvier 2022 à 15:12:12

        Bonjour,

        Ton typedef inverse Stack et stack donc il n'est pas utilisable. Ou bien met partout une majuscule à stack, ça simplifiera.

        Quand à ta question, pourquoi veux tu que la fonction isEmpty() retourne un struct stack? Ça n'a pas de sens. La fonction peut retourner un int ou mieux elle devrait retourner un bool qui serait true ou false pour indiquer si la pile est vide ou pas.

        bool  isEmpty( const struct stack *pt ) {
            return  pt->top == -1;
        }

        Si tu veux une fonction qui te retourne une pile vide, c'est la fonction newStack() qu'il faut appeler.

        • Partager sur Facebook
        • Partager sur Twitter

        En recherche d'emploi.

          19 janvier 2022 à 16:23:12

          Merci pour vos réponses,

          J'ai fait ces fonctions pour implémenter la pile en utilisant des liste chainées. Quelqu'un pour me corriger. J'ai du mal aussi à voir ce que je vais utiliser dans le fichier.h (mes prototypes et le typedef). J'ai déjà implémenté la liste sous cette forme 

          struct List {
            D element;
            struct List *next;
          };
          
          /* Pre-condition : list is non-empty */
          static void setNext(PList, PList);
          
          /*Pre-condition : list is non-empty */
          static void setElement(PList, D);
          
          PList emptyList() {
            return NULL;
          }
          
          PList getNext(PList list) {
            return list->next;
          }
          
          void setNext(PList list, PList p) {
            list->next = p;
          }
          
          D getElement(PList list) {
            return list->element;
          }
          
          void setElement(PList list, D x) {
            list->element = x;
          }
          
          bool isEmptyList(PList list) {
            return list == NULL;
          }
          
          PList addAtTheBeginning(PList list, D x) {
            PList p = malloc(sizeof(struct List));
            if (p == NULL) {
              fprintf(stderr, "Error: addAtTheBeginning: malloc");
              exit(1);
            }
            setElement(p, x);
            setNext(p, list);
            return p;
          }



          typedef ?? Stack 



          Stack emptyStack() {
          return NULL;
          }
          
          D getTop(Stack s) {
          return s->array[s->top];
          }
          
          void push(Stack s, D x) {
          s->array[++s->top] = x;
          }
          
          void pop(Stack s) {
          s->top--;
          }
          
          bool isEmptyStack(Stack s) {
          return s->top == -1;
          }



          -
          Edité par ManaMana2 19 janvier 2022 à 16:44:32

          • Partager sur Facebook
          • Partager sur Twitter
            19 janvier 2022 à 16:46:52

            Les deux transtypages

            struct stack *pt = (struct stack*)malloc(sizeof(struct stack));
            pt->items =         (int*)        malloc(sizeof(int) * capacity);

            sont inutiles.

            Et donc nuisibles, parce qu'ils constituent des distractions dans la lecture du code.

            struct stack *pt = malloc(sizeof(struct stack));
            pt->items        = malloc(sizeof(int)* capacity);
              

            Je sais bien que tout le monde copie bêtement le code de Sedgewick de 1989, mais il n'y a aucune raison de vouloir systématiquement allouer dynamiquement les struct stack.

            On peut très bien se munir d'une fonction qui initialise une struct pile

            void stack_init(struct stack *s, int capacity)
            {
                s->maxsize = capacity;
                s->top = -1;
                s->items = malloc(sizeof(int) * capacity);
            }

            alloués statiquement ou dynamiquement, si on veut et si on en a besoin.

             Alternative, une fonction qui retourne une structure initialisée

            struct stack  empty_stack(int capacity)
            {
                struct stack tmp;
                ...
                return tmp;
            }
            


            e pile



            -
            Edité par michelbillaud 19 janvier 2022 à 16:47:19

            • Partager sur Facebook
            • Partager sur Twitter
              19 janvier 2022 à 16:54:51

              ManaMana2 a écrit:

              typedef ?? Stack 
              typedef struct stack Stack;
              struct stack
              {
                  int maxsize;  
                  int top;
                  int *items;
              };
              Il faut être attentifs aux minuscule majuscule dans les noms de types (ou de variables) ce n'est pas équivalent.
              • Partager sur Facebook
              • Partager sur Twitter
                19 janvier 2022 à 19:38:54

                ManaMana2 a écrit:

                J'ai fait ces fonctions pour implémenter la pile en utilisant des liste chainées.

                il faudrait ouvrir un autre sujet parce que là, ça ne correspond plus du tout au titre.

                • Partager sur Facebook
                • Partager sur Twitter

                implémentation pile tableau

                × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                • Editeur
                • Markdown