Notasi Polish, Merubah Infix ke Postfix dan Perhitungannya

Merubah Notasi Infix ke Notas Postfix. Ini salah satu tugas akhir Struktur Data semester 4 ini. Program ini dibuat dengan menggunakan struktur Stack dan array dinamis atau disebut List. Keterbatasan dari program ini adalah user hanya dapat menginputkan data dari 1-9 dan operator yang digunakan hanya +,-,*,/,^. Untuk kedepan gak janji dikembangkan tapi tetep diusahain.


Oke ini Codenya :

#include <stdio.h>
#include <string.h>
#define MAX 10
#define Kosong -1


struct stack
{
        char data[MAX];
        int top;
};

int cekKosong(struct stack *s);
void KosongkanStack(struct stack* s);
void push(struct stack* s,int item);
char pop(struct stack* s);
void tampil(struct stack s);
int cekOperator(char e);
int cekPrioritas(char e);
void konversi(char* infix, char* postfix, int spasi);
int Hitung(char *postfix);


int main()
{
        char in[50],post[50];

        strcpy(&post[0],"");
        printf("Masukan Statement Hitungan : ");
        fflush(stdin);
        gets(in);
        printf("%s",in);
        konversi(&in[0],&post[0],1);
        printf("Bentuk Postfix dari Statement Hitungan diatas adalah : %s\n",&post[0]);
        printf("\nHasil perhitungannya adalah : %i", Hitung(&post[0]));
        
        getch();
        return 0;
}


//fungsi untuk mengecek kosong atau tidaknya stack
int cekKosong(struct stack *s)
{
        if(s->top == Kosong)
            return 1;
        else
            return 0;
        
}

// fungsi untuk mengosongkan stack
void KosongkanStack(struct stack* s)
{
        s->top=Kosong;  
}

// fungsi untuk memasukan data ke stack
void push(struct stack* s,int item)
{
        if(s->top == (MAX-1)) // jika topnya ke max - 1, berarti stack penuh
        {
                printf("\nStack Penuh, silakan pop atau hapus stack");
        }
        else  //jika tidak
        {
                ++s->top;  // naikan stack s, lalu pindahkan topnya
                s->data[s->top]=item;  // list data dari top diisi dari item
        }
}

char pop(struct stack* s)
{
        char ret=(char)Kosong;  // inisialisasi variabel ret = 0 jadi char
        if(!cekKosong(s))  // mengecek kosong atau tidak, bila tidak ?
        {
                ret= s->data[s->top];   //tempatkan ret pada list s di posisi top
                --s->top;   // lalu mundurkan list s satu list dan jadikan top
                // ini berarti ret berada di list paling belakang
        }
		
        return ret;  // keluarkan si ret
}

void tampil(struct stack s)
{
        while(s.top != Kosong)  // selama s gak kosong
        {
                printf("\n%d",s.data[s.top]);  // tampilkan data list s pada posisi top
                s.top--; // mundurkan list ke posisi sebelumnya
        }
}

// fungsi untuk mengecek operator
int cekOperator(char e)
{
        if(e == '+' || e == '-' || e == '*' || e == '/' || e == '^')
        {
            printf(" operator benar\n");
            getch();
            return 1;    // jika operatornya + , - , * , / , ^(pangkat) , berarti OK
        }
        else
        {
            printf(" operator salah\n");
            getch();  // jika selain operator itu,, anggap invalid operator
            return 0;
        }
        
}

// fungsi untuk mengecek prioritas suatu operator
int cekPrioritas(char e)
{
        int pri = 0;  // inisialisasi nilai variabel pri
        
        if (e == '^')
           pri = 3;  // jika terdapat tanda pangkat (^), dia menjadi prioritas no wahid
        else
        {
            if(e == '*' || e == '/')
            pri = 2;  // jika * atau / maka jadi prioritas ke 2
            else
            {
                if(e == '+' || e == '-')
                    pri = 1;  // jika + atau - jadi prioritas ke 3
            }
        }
        
        return pri;  // ngeluarin nilai variabel prioritas
        
}


// Fungsi proses konversinya
void konversi(char* infix, char* postfix, int spasi)
{
        char *i,*p; 
        struct stack X;
        char n1;
        
        KosongkanStack(&X);
        i = &infix[0];
        p = &postfix[0];
        
        printf("cek operator hasilnya : %i\n",cekOperator(*i));

        while(*i)
        {
                while(*i == ' ' || *i == '\t')  // melewatkan spasi dan tab
                {
                        i++; 
                }

                if( isdigit(*i) || isalpha(*i) )
                {
                        while( isdigit(*i) || isalpha(*i))
                        {
                                *p = *i;
                                p++;
                                i++;
                        }
                        /*SPACE CODE*/
                        if(spasi)
                        {
                                *p = ' ';
                                p++;
                        }
                        /*END SPACE CODE*/
                }

                if( *i == '(' )
                {
                        push(&X,*i);
                        i++;
                }

                if( *i == ')')
                {
                        n1 = pop(&X);
                        while( n1 != '(' )
                        {
                                *p = n1;
                                p++;
                                /*SPACE CODE*/
                                if(spasi)
                                {
                                        *p = ' ';
                                        p++;
                                }
                                /*END SPACE CODE*/
                                n1 = pop(&X);
                        }
                        i++;
                }

                if( cekOperator(*i))
                {
                        if(cekKosong(&X))
                                push(&X,*i);
                        else
                        {
                                n1 = pop(&X);
                                while(cekPrioritas(n1) >= cekPrioritas(*i))
                                {
                                        *p = n1;
                                        p++;
                                        /*SPACE CODE*/
                                        if(spasi)
                                        {
                                                *p = ' ';
                                                p++;
                                        }
                                        /*END SPACE CODE*/
                                        n1 = pop(&X);
                                }
                                push(&X,n1);
                                push(&X,*i);
                        }
                        i++;
                }
                
        }
        while(!cekKosong(&X))
        {
                n1 = pop(&X);
                *p = n1;
                p++;
                /*SPACE CODE*/
                if(spasi)
                {
                        *p = ' ';
                        p++;
                }
                /*END SPACE CODE*/
        }
        *p = '\0';
}


int Hitung(char *postfix)
{
        char *p;
        struct stack stk;
        int op1,op2,hasil;

        cekKosong(&stk);
        p = &postfix[0];

        while(*p != '\0')
        {
           /* code ini untuk menghilangkan spasi dan tab saat perhitungan */
                while(*p == ' ' || *p == '\t')
                {
                        p++;  // kalo benar ada maka lewatkan ke statement berikutnya
                }
          /* if is digit */
                if(isdigit(*p))
                {
                        push(&stk,*p - 48);
                }
                else
                {
                   /* it is an operator */
                        op1 = pop(&stk);
                        op2 = pop(&stk);
                        
                        switch(*p)
                        {
                                case '+':{
                                              hasil = op2 + op1;
                                              break;
                                         }

                                case '-':{
                                              hasil = op2 - op1;
                                              break;
                                         }
                                case '/':{
                                              hasil = op2 / op1;
                                              break;
                                         }

                                case '*':{
                                             hasil = op2 * op1;
                                             break;
                                         }

                                case '^':{
                                             hasil = pow(op2,op1);
                                             break;
                                         }

                             
                        }
                        push(&stk,hasil);  // tempatkan hasil sementara pada stack
                }
                p++;  // lanjut ke statement berikutnya
        }
        hasil = pop(&stk);  //  keluarkan hasil yang tersimpan pada stack
        return hasil;
}

Semoga berguna buat yg search mengenai tema ini…

Iklan

7 thoughts on “Notasi Polish, Merubah Infix ke Postfix dan Perhitungannya

Silahkan Komentar...

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout / Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout / Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout / Ubah )

Foto Google+

You are commenting using your Google+ account. Logout / Ubah )

Connecting to %s