Dizi: 5 9 * 8 + 4 6 * 7 + * 
 Stack: boş 
  
 Dizi[0] = 5 
 Stack: 5 
  
 Dizi[1] = 9 
 Stack: 9 5 
  
 Dizi[2] = * 
 Stackten 2 sayı çekilir: 9 ve 5 
 İşleme sokulur: 9 * 5 = 45 
 Stack: 45 
  
 Dizi[3] = 8 
 Stack: 8 45 
  
 Dizi[4] = + 
 Stackten 2 sayı çekilir: 8 ve 45 
 İşlem: 8 + 45 = 53 
 Stack: 53 
  
 Dizi[5] = 4 
 Stack: 4 53 
  
 Dizi[6] = 6 
 Stack: 6 4 53 
  
 Dizi[7] = * 
 Stackten 2 sayı çekilir: 6 ve 4 
 İşlem: 6 * 4 = 24 
 Stack: 24 53 
  
 Dizi[8] = 7 
 Stack: 7 24 53 
  
 Dizi[9] = + 
 Stackten 2 sayı çekilir: 7 ve 24 
 İşlem: 7 + 24 = 31 
 Stack: 31 53 
  
 Dizi[10] = * 
 Stackten 2 sayı çekilir: 31 ve 53 
 İşlem: 31 * 53 = 1643 
 Stack: 1643 
  
 Dizi bitti. 
 Stackte kalan son sayı: 1643 işlemin sonucudur.

 
 #include <stdio.h> 
 #include <stdlib.h> 
  
 struct stackNode { 
     int data; 
     struct stackNode* nextPtr; 
 }; 
  
 typedef struct stackNode StackNode; 
 typedef StackNode* StackNodePtr; 
  
 void push(StackNodePtr*, int); 
 int pop(StackNodePtr*); 
 StackNodePtr newStackNode(int); 
 void deleteStack(StackNodePtr); 
  
 int isEmpty(StackNodePtr); 
 void printStack(StackNodePtr); 
  
 int isDigit(char); 
 int calculate(int, int, char); 
  
 int main() { 
  
     // Boş stack oluştur 
     StackNodePtr stackPtr = NULL; 
     char A[11] = {5,9,'*', 8, '+', 4, 6, '*', 7, '+', '*'}; 
  
     // Dizinin tüm elemanlarını gez 
     int i, x, y; 
     for(i=0; i<sizeof(A); i++) { 
         // Eğer eleman bir rakam değilse (operatörse) 
         if(!isDigit(A[i])) { 
             // Stackten 2 rakam çekilip işleme sokulacak. 
             // Stackte rakam yoksa ifadede olması gerekenden fazla operatör vardır. 
             if(isEmpty(stackPtr)) { 
                 printf("ERROR: Too many operators!\n"); 
                 return 1; 
             } 
             // Stackten bir rakam çek 
             x = pop(&stackPtr); 
             // Stackten bir rakam çekilince, stackte başka rakam kalmadıysa ifadede 1 rakam eksik demektir. 
             if(isEmpty(stackPtr)) { 
                 printf("ERROR: Missing operands!\n"); 
                 return 1; 
             } 
             // İkinci rakamı çek: 
             y = pop(&stackPtr); 
             // İki rakamı işleme sokup, sonucu stacke at 
             push(&stackPtr, calculate( y, x, A[i] ) ); 
         } 
         else { 
             // Eğer eleman rakamsa sadece stack'e at 
             push(&stackPtr, A[i]); 
         } 
  
     } 
  
     // Stackte kalan son eleman sonuçtur: 
     printf("Result: %d\n", pop(&stackPtr)); 
     // Hafızayı temizle 
     deleteStack(stackPtr); 
     return 0; 
 } 
 void printStack(StackNodePtr stackPtr) { 
     StackNodePtr ptr = stackPtr; 
     while(ptr != NULL) { 
         printf("%d ", ptr->data); 
         ptr = ptr->nextPtr; 
     } 
 } 
 int calculate(int x, int y, char operation) { 
     switch(operation) { 
         case '+': return x+y; 
         case '-': return x-y; 
         case '*': return x*y; 
         case '/': return x/y; 
     } 
     printf("ERROR: Invalid operator \"%c\"\n", operation ); 
     exit(EXIT_FAILURE); 
     return 0; 
 } 
 int isDigit(char c) { 
     return (c > -1 && c < 10) ? 1 : 0; 
 } 
 void push(StackNodePtr* stackPtr, int data) { 
      
     if(*stackPtr == NULL) { 
         // Stack boşsa, yeni oluşturulan node stack'in ilk elemanıdır 
         *stackPtr = newStackNode(data); 
  
     } else { 
         // Stack doluysa, oluşturulan yeni node'un nextPtr değeri, stack pointerı gösterir 
         // Yeni stack pointer da, son eleman olan, yeni node'u göstermeli. 
         StackNodePtr temp = *stackPtr; 
         *stackPtr = newStackNode(data); 
         (*stackPtr)->nextPtr = temp; 
     } 
 } 
 int pop(StackNodePtr* stackPtr) { 
     // Stack pointerın tuttuğu veri return edilmeli 
     // Stack pointerın gösterdiği node free edilmeli 
     // Stack pointer artık, eski stack pointerın nextPtr değerini almalı. 
     StackNodePtr ptr = *stackPtr; 
     ptr = ptr->nextPtr; 
     int data = (*stackPtr)->data; 
     free(*stackPtr); 
     *stackPtr = ptr; 
     return data; 
 } 
 int isEmpty(StackNodePtr stackPtr) { 
     return stackPtr == NULL ? 1 : 0; 
 } 
 StackNodePtr newStackNode(int data) { 
     StackNodePtr stackPtr = malloc( sizeof(StackNode) ); 
     stackPtr->data = data; 
     stackPtr->nextPtr = NULL; 
     return stackPtr; 
 } 
 void deleteStack(StackNodePtr stackPtr) { 
     StackNodePtr nextNode = stackPtr; 
     while(stackPtr != NULL) { 
         nextNode = nextNode->nextPtr; 
         free(stackPtr); 
         stackPtr = nextNode; 
     } 
 }