Langsung ke konten utama

Memahami Struktur Stack dalam Bahasa C++

Konversi Bilangan Desimal ke Biner, Oktal dan Heksa Menggunakan Stack

#include<stdio.h>
#include<conio.h>

int MAXSTACK;
typedef int itemtype;

typedef struct
{
      itemtype item[300];
      int count;
}stack;

void initializestack(stack *s)
{
      s->count = 0;
}

int empty(stack *s)
{
      return (s->count == 0);
}

int full(stack *s)
{
      return (s->count == MAXSTACK);
}

void push(itemtype x, stack *s)
{
      if(full(s))
      printf("stack penuh !\n");
      else
 {
      s->item[s->count]=x;
 ++(s->count);
 }
}

int pop(stack *s)
{
      if(empty(s))
      printf("stack kosong\n");
      else
 {
 --(s->count);
 return (s->item[s->count]);
 }
 return 0;
}
//deklarasi
int i, n, m, o,p,pilih;
int input;
stack tumpukan;
void biner();
void oktal();
void heksa();
main()
{
       printf("\n-------Konversi Desimal ke Biner Oktal dan Heksadesimal------\n");
       initializestack(&tumpukan);
       printf("\nMasukkan Bilangan Desimal = ");
       scanf("%d", &input);
       printf("\n---MENU---\n");
       printf("1 Untuk Konversi ke Biner\n");
       printf("2 Untuk Konversi ke Oktal\n");
       printf("3 Untuk Konversi ke Heksa\n");
       printf("4 Untuk Keluar");
 while(pilih<4){
      printf("\n\nPilih :  ");
      scanf("%d",&pilih);
 switch(pilih)
 {
      case 1:
            printf("Bilangan Binernya\n");
            biner();break;
      case 2:
            printf("Bilangan Oktalnya\n");
            oktal();break;
      case 3:
            printf("Bilangan Heksadesimalnya\n");
            heksa();break;
       case 4:
             printf("--Silahkan Tekan Enter Sekali Lagi");
 }}
      getch();
      return 0;
}
//ke oktal
void oktal(){
      for(o=1,n=input;n>0;n=n/8,o++)
      {
             MAXSTACK=o;
             m=n%8;
             push(m,&tumpukan);
      }
      for(i=MAXSTACK;i>0;i--)
      {
      printf("%d", pop(&tumpukan));
      }
}
//ke biner
void biner(){
      for(o=1,n=input;n>0;n=n/2,o++)
       {
             MAXSTACK=o;
            m=n%2;
             push(m,&tumpukan);
       }
       for(i=MAXSTACK;i>0;i--)
       {
       printf("%d", pop(&tumpukan));
       }
}
//ke heksa desimal
void heksa(){
      for(o=1,n=input;n>0;n=n/16,o++)
       {
             MAXSTACK=o;
             m=n%16;
       push(m,&tumpukan);
       }
       for(i=MAXSTACK;i>0;i--)
       {
            p=pop(&tumpukan);
            if(p<=9)
            printf("%d",p);
            else if(p==10)printf("A");
            else if(p==11)printf("B");
            else if(p==12)printf("C");
            else if(p==13)printf("D");
            else if(p==14)printf("E");
            else if(p==15)printf("F");
       }
}


Pembalik Kalimat Menggunakan Stack
 
Contoh : Untuk membalik kata Struktur Data menjadi ataD rutkurtS

#include <iostream>
#include<stdlib.h>
#include<conio.h>
#include <windows.h>

using namespace std;

struct Tumpukan
    {

    char isi[25];
    int atas;

    }T;

void push (char x){
    if(T.atas==25){

        cout<<"Tumpukan Sudah Penuh";
        getch();
    }else{

        T.atas=T.atas+1;
       T.isi[T.atas]=x;
    }
}
char pop(){
    char hasil;
    if(T.atas == 0){
    cout<<"Tumpukan Sudah Kosong";
      hasil = ' ';
   }
   else{
    hasil = T.isi[T.atas];
      T.atas = T.atas - 1;
   }
   return hasil;
}

int main()
{
    int i;
    char kalimat[25];
    system("CLS");
    T.atas=0;

      cout<<"\n-------Program Membalikkan Kata-------"<<endl;
    cout<<"\nMasukan Kalimat : ";cin.getline(kalimat,sizeof(kalimat));

    system("CLS");
    cout<<"\nKalimat Asli : "<<kalimat;

     for(i=0; i<strlen(kalimat); i++)
      {
        push(kalimat[i]);
      }
    cout<<"\n\nKalimat Setelah di Balik : ";

    for(i=0; i<strlen(kalimat); i++)
    {
        cout<<pop();
    }
    cout<<endl;

    return 0;
}


Pengecekan Palindrom (sebuah kata, frasa, angka maupun susunan lainnya yang dapat dibaca dengan sama baik dari depan maupun belakang) atau Bukan Menggunakan Stack

#include <iostream>
#include <string.h>

using namespace std;

int main(int argc, char** argv) {
 char kata[15];
int belakang;
bool palindrome = true;

cout<<"\n------Program Pengecekan Palindrom------"<<endl;
cout <<"\nMasukkan Satu Kata : ";
cin.getline(kata, sizeof(kata));

int panjang = strlen(kata);
belakang = panjang-1;

for(int a=0; a<panjang; a++)

    {

        if((char)tolower(kata[a])!=(char)tolower(kata[belakang]))
            {
                 palindrome = false;
                 break;
            }
        belakang--;
    }

        if(palindrome)
    {
        cout<<"Kata "<<kata ;
        cout<<" Merupakan Kata Palindrom";
        cout<<endl;
    }
        else
    {
        cout<<"Kata "<<kata ;

        cout<<" Bukan Merupakan Kata Palindrom";
        cout<<endl;
    }

 return 0;

}


Implementasi Notasi Infix ke Postfix Menggunakan Stack

a.   Notasi infix dibaca satu per satu
b.   Jika berupa operand maka langsung dicetak dan tidak disimpan
c.   Stack hanya digunakan untuk menyimpan operator
d.   Operator mempunyai tingkatan level dengan urutan (dari level tertinggi ke terendah) : ‘^’, ‘*’ dan ‘/’, ‘+’ dan ‘-’
e.   Jika operator maka mengikuti aturan sbb :
     •    Jika notasi ‘(‘ PUSH ke stack
     •    Jika notasi ‘)’ POP dan cetak s/d tanda ‘)’ tetapi tidak dicetak
     •    Jika operator, cek bila stack Kosong atau level operator > level operator TOS maka PUSH
     •    Lainnya POP dan cetak lalu PUSH, ulangi perbandingan
f.   Jika notasi infix sudah berakhir, POP stack sampai Kosong


Ilustrasi Konversi Infix ke Postfix




Algoritma Konversi Notasi Infix ke Postfix
a.    Sediakan stack untuk menyimpan operator (tipe : char)
b.    Baca setiap karakter notasi infix dari awal
  1. Jika berupa operand maka langsung dicetak
  2. Jika berupa notasi/tanda ‘(‘ PUSH ke stack
  3. Jika berupa notasi/tanda ‘)’ POP dan cetak semua isi stack sampai TOS = ‘(‘. POP juga tanda ‘(‘ ini, tetapi tidak dicetak
  4. Jika berupa operator :
    ·       cek bila stack kosong atau derajad operator lebih tinggi dibanding derajad TOS, maka PUSH operator ke dalam stack.
    ·       Jika tidak, POP dan cetak; kemudian ulangi pembandingan dengan TOS.
  5.  Kemudian di-push
 c.    Jika akhir notasi infix telah tercapai, dan stack masih belum kosong, pop semua isi stack dan cetak hasilnya


Implementasi Operasi Notasi Postfix Menggunakan Stack


Menghitung Hasil Operasi Postfix
a.    Stack akan menyimpan operand dan hasil operasi
b.    Siapkan variabel opLeft dan opRight untuk menyimpan operan kiri dan kanan
c.    Dibaca satu persatu, misalnya : 34+
  1. Ketemu operand ‘3’, maka PUSH ‘3’
  2. Ketemu operand ‘4’, maka PUSH ‘4’
  3. Ketemu Operator ‘+’ , maka POP ‘4’ ke opRight, lalu POP ‘3’ ke opLeft, kemudian lakukan operasi ‘+’
  4. Hasil operasinya ‘7’ lalu PUSH ke stack 
d.    Bila notasi berakhir, POP stack sebagai hasil operasi 


Algoritma Hasil Operasi Postfix
a.    Baca notasi postfix satu per satu
b.    Jika notasi adalah operan maka PUSH ke stack
c.    Jika notasi adalah operator maka
  1. POP ke OpRight
  2. POP ke OpLeft
  3. Hasil = OpLeft operator OpRight
  4. PUSH Hasil
d.    Jika notasi postfix berakhir, POP stack sebagai hasil operasi



 






Label:

Komentar

Posting Komentar