Implémentation de pile en C

Nous pouvons implémenter la structure de données via la langue C. Il existe plusieurs types de structure de données disponibles pour stocker et accéder aux données de manière efficace. La pile est l'une d'entre elles.

Une pile est une version modifiée du tableau. Nous pouvons ajouter ou supprimer un élément à une extrémité de la pile. Cette fin est au Haut de la pile.

La pile est un moyen spécialisé de gérer, de stocker, d'insérer, de supprimer, d'accéder aux données. C'est de nature abstraite.

Tableau et pile

1. Il y a un peu de différence entre le tableau et la pile en termes de leur accessibilité. Nous pouvons accéder à n'importe quel élément à partir du tableau à n'importe quelle condition, mais dans le cas de Stack, nous pouvons insérer ou supprimer l'élément d'une extrémité un par un. Cette extrémité est appelée haut. En termes d'accessibilité, le tableau est plus rapide que la pile.
2. Stack a deux fonctions principales appelées push et pop.
3. La fonction de poussée est utilisée pour insérer dans une pile et la fonction POP est utilisée pour supprimer un élément de la pile.

Représentation

Nous ne pouvons accéder qu'au dernier élément inséré dans la pile. C'est le haut de la pile. Nous pouvons soit insérer ou supprimer du haut.

Ceci est connu comme le dernier de Fast Out (LIFO) et le Fast in Last Out (Filo).

Mise en œuvre

La pile peut être implémentée comme suit:

-> Array -> Array dynamique -> Liste de liens

Opération

-> Push -> pop

Algorithme push: push (pile, top, maxstk, item)

1. [La pile est pleine]

Si top == maxstk

Voir le message: Débordement et retour

2. Set top = top + 1
3. Set stack [top] = item
4. Retour

Algorithme pop: pop (pile, haut, article)

1. [élément supprimé de la pile]

Si top == -1

Voir le message: Underflow et retour

2. Set item = stack [top]
3. Top: Top -1
4. Retour

Pile à l'aide du tableau

Struct arraystack

INT TOP;
capacité non signée;
Int * Array;

Ici, nous définissons un type de données défini par l'utilisateur appelé ArrayStack. Il compte trois membres de données nommés Top, Capacité, et un pointeur nommé * Array.

Notation polonaise

La notation polonaise rédige les opérateurs d'une expression avant ou après leur opérande.

Façons d'écrire:

Infix 2. Préfixe 3. Postfix

Inspirer

Les opérateurs sont maintenus entre les deux opérandes.

Exemple: A + B

Préfixe

Les opérateurs sont conservés avant leurs opérandes.

Exemple: + a b

Postfix

Les opérateurs sont conservés après leurs opérandes.

Exemple: A B +

Convertir

1.

Infix:
(A + b) * c
Préfixe:
* + A b c
Postfix:
A b + c *

2.

Infix:
A + (b * c)
Préfixe:
+ A * B C
Postfix:
A b c * +

3.

Infix :( a + b) / (c - d)
Préfixe: / + a b - c d
Postfix: a b + c d - /

Toute cette conversion peut être effectuée à l'aide de pile. Maintenant, nous voulons montrer comment une pile peut être créée et comment l'élément ou les données est insérée. Les éléments peuvent être retirés de la pile par programmation.

Exemple de programmation

#inclure
#inclure
Int item;
struct arraystack // définir un type de données;

INT TOP;
Capacité int;
Int * Array;
;
struct arraystack * CreateStack (int cap) // Créer une pile;

struct arraystack * pile;
stack = malloc (sizeof (struct arraystack));
pile-> top = - 1;
Stack-> Capacité = CAP;
stack-> array = malloc (sizeof (int) * stack-> capaciment);
return (pile);

int complet (struct arraystack * pile) // vérification de la pile est pleine ou non.

if (stack-> top == Stack-> Capacité - 1)
retour (1);
autre
return (0);

int vide (struct arraystack * pile) // vérification de la pile est vide ou non.

if (pile-> top == -1)
retour (1);
autre
return (0);

void push (struct arraystack * pile, int item) // insérer des éléments dans la pile;

si ( !un paquet entier ) )

pile-> top ++;
stack-> array [stack-> top] = item;


int pop (struct arraystack * pile) // supprimer les éléments de la pile;

si ( !vide (pile))

item = stack-> array [stack-> top];
pile-> top--;
retourner l'objet ) ;

return (-1);

int main()

INT Choice;
struct arraystack * pile;
Stack = CreateStack (4);
tandis que (1)

printf ("\ n 1 . pousser " ) ;
printf ("\ n 2 . populaire " ) ;
printf ("\ n 3 . exit \ n ");
printf ("Entrez votre choix \ n");
scanf ("% d", & choix);
commutateur (choix)

cas 1:
printf ("Entrez un nombre \ n");
scanf ("% d", & item);
push (pile, item);
casser ;
Cas 2:
item = pop (pile);
if (item == - 1)
printf ("pile est vide");
autre
printf ("La valeur poptée est% d", item);
casser ;
Cas 3:
sortie (0);


retour 0;

Sortir:

Explication

Comme nous l'avons dit plus tôt, nous définissons un type de données défini par l'utilisateur nommé ArrayStack. Il compte trois membres de données nommés Top, Capacité et un tableau de pointeur. Ensuite, nous définissons une fonction nommée Createstack où nous passons une valeur que le bloc total de la table est créé. La fonction malloc () crée ce tableau et renvoie l'adresse à la pile variable qui est le type ArrayStack. Le tableau de pile-> contient l'adresse du tableau qui est créé par la fonction malloc ().

Ensuite, nous définissons une autre fonction nommée Full () pour vérifier si la pile est pleine ou non.

Créer une autre fonction nommée vide pour vérifier si la pile est vide.

Ensuite, nous définissons une autre fonction nommée push () où nous insérons les éléments un par un dans la pile à partir d'une extrémité appelée Top. Pour insérer l'élément de la pile, nous vérifions d'abord si la pile est pleine.

Ensuite, nous définissons une autre fonction nommée POP () où nous supprimons les éléments un par un de la pile d'une extrémité appelée Top. Pour supprimer l'élément de la pile, nous vérifions d'abord si la pile est vide.

Ensuite, à l'intérieur de la fonction Main (), nous écrivons le boîtier de commutateur pour donner à l'utilisateur une option de menu pour sélectionner son choix si l'élément est inséré ou supprimé dans la pile.

Conclusion

D'après la discussion sur la pile, nous sommes venus à conclure que Stack est une structure de données bien définie qui est utilisée pour gérer les données de manière structurelle. Notre pile de vie quotidienne est mise en œuvre dans divers domaines pour stocker, insérer ou supprimer des éléments.