SEARCH (SEQUENTIAL SEARCH DAN BINARRY SEARCH) DALAM BAHASA C++

Searching adalah metode pencarian informasi dalam suatu aplikasi, dengan suatu kunci( key ). Pencarian diperlukan untuk mencari informasi khusus dari table pada saat lokasi yang pasti dari informasi tersebut sebelumnya tidak diketahui. Pencarian selalu dinyatakan dengan referensi pada adanya sekelompok data yang tersimpan secara terorganisasi, kelompok data tersebut kita sebut table.

SEQUENTIAL SEARCH

Pencarian sekuensial (sequential search) atau sering disebut pencarian linier menggunakan prinsip sebagai berikut : data yang ada di bandingkan satu persatu secara berurutan dengan yang dicari. Pada dasarnya, pencarian ini hanya melakukan pengulangan dari 1 sampai dengan jumlah data. Pada setiap perulangan , di bandingkan data ke-i dengan yang dicari. Apabila sama , berarti data telah ditemukan . Sebaliknya apabila sampai akhir pengulangan , tidak ada yang sama berarti data tidak ada.

Contoh program SEQUENTIAL SEARCH :

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

void main()
{
clrscr();
int data[8] = {3,4,8,13,11,5,2,18};
int cari,index;
int ketemu=0;
cout<<"Inputkan data yang ingin di cari = ";
cin>>cari;
for(int i=0;i<8;i++)
{
if(data[i] == cari)
{
ketemu=1;
index=1;
break;
}
}
if(ketemu == 1)
{
cout<<"Data tersedia!"<
cout<<"Data Terletak di index ke - "<
}
else cout<<"Data tidak tersedia!"<
getch();
}

BINARRY SEARCH

Salah satu syarat pencarian biner (binary search) dapat dilakukan adalah data sudah dalam keadaan terurut. Dengan kata lain, apabila data belum dalam keadaan terurut , pencarian biner tidak dapat dilakukan.

Contoh Program BINARRY SEARCH :

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

int data[10] = {1,4,7,8,19,23,35,49,60,70};
int binary_search(int cari)
{
int l,r,m;
int n = 10;
l = 0;
r = n-1;
int ketemu = 0;
while(l<=r && ketemu==0)
{
m = (l+r)/2;
if ( data[m] == cari )
ketemu = 1;
else
if (cari <>
r = m-1;
else l = m+1;
}
if(ketemu == 1) return 1; else return 0;
}
void main()
{
clrscr();
int cari,hasil;
cout<<"Masukan data yang ingin dicari = ";
cin>>cari;
hasil = binary_search(cari);
if(hasil == 1)
{
cout<<"Data tersedia!"<
}
else
if(hasil == 0)
cout<<"Data tidak tersedia!"<
getch();
}

Sumber Referensi Dari :
http://www.blogyin.com/2015/03/searching-binary-search-dalam-bahasa-c.html

SORTING (SELECTION SORT DAN INSERTION SORT) DALAM BAHASA C++

Sorting  adalah sebuah metode untuk pengurutan data, misalnya dari data yang terbesar ke data yang terkecil. Dengan cara program yang dibuat harus dapat membandingkan antar data yang di inputkan. Artinya jika ada deretan data, maka data yang pertama akan membandingkan dengan data yang kedua. Jika data yang pertama lebih besar dari pada data yang kedua maka data yang pertama akan bertukar posisi dengan data yang kedua, begitu seterusnya sampai benar-benar data terurut dari yang terbesar hingga yang terkecil.

SELECTION SORT
Selection Sort adalah metode sorting dimana elemen- elemen di perbandingkan satu-persatu sampai pada elemen terakhir dan disusun berdasarkan ketentuan ketentuan berlaku (terbesar atau terkecil).

 

Contoh program SELECTION SORT :

#include<iostream>

#include<conio.h>

int main()
{  

    int a,k,c,d,g;

    k=4;
    int b[4];

    cout<<"\t\t\t===PROGRAM SELECTION SORT===\n\n"<<endl;

    cout<<"Mengurutkan Nilai Dari Besar ke Kecil"<<endl<<endl;
    for(a=0;a<k;a++)
    {
        cout<<"Masukkan Nilai "<<a+1<<" : ";cin>>b[a];
    }
    for(a=0;a<k-1;a++)
    {
    c=a;
        for(d=a+1;d<k;d++)
        {
            if(b[c]<b[d])
            {
                c=d;
            }
        }
        g=b[c];
        b[c]=b[a];
        b[a]=g;
    }
    cout<<"\n Setelah Diurutkan Akan Menjadi : \n";
    for(a=0;a<k;a++)
    {
        cout<<b[a]<<" \n";
    }
}

INSERTION SORT

Insertion sort adalah sebuah metode pengurutan data dengan menempatkan setiap elemen data pada pisisinya dengan cara melakukan perbandingan dengan data – data yang ada.

Contoh program INSERTION SORT :

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


int data[10],data2[10];
int n;

void tukar(int a, int b)
{
 int t;
 t = data[b];
 data[b] = data[a];
 data[a] = t;
}

void insertion_sort()
{
 int temp,i,j;
 for(i=1;i<=n;i++)
 {
  temp = data[i];
  j = i -1;
  while(data[j]>temp && j>=0)
  {
   data[j+1] = data[j];
   j--;
  }
 data[j+1] = temp;
 }
}
int main()
{
 cout<<"\t\t\t===PROGRAM INSERTION SORT===\n\n"<<endl;

 //Input Data
 cout<<"Masukkan Jumlah Data : ";
 cin>>n;
 cout<<"\n";
 for(int i=1;i<=n;i++)
 {
  cout<<"Masukkan Data ke "<<i<<" : ";
  cin>>data[i];
  data2[i]=data[i];
 }

 insertion_sort();

 cout<<"\n\n";
 //tampilkan data
 cout<<"Data Setelah di Sort : ";
 for(int i=1; i<=n; i++)
 {
  cout<<" "<<data[i];
 }

 getch();
}

 

Sumber Referensi Dari : 

http://www.haliemzulvio.com/2015/03/selection-sort-dalam-bahasa-cc.html

http://yuliana.lecturer.pens.ac.id/Struktur%20Data%20C/Prak%20SD%20-%20pdf/Praktikum%207.pdf

QUEUE DALAM BAHASA C++

QUEUE 

Queue (antrian) adalah barisan elemen yang apabila elemen ditambah maka penambahannya berada di posisi belakang (rear) dan jika dilakukan pengambilan elemen dilakukan di elemen paling depan (front). Oleh karena itu, queue bersifat FIFO (first in first out).

Operasi-operasi dasar dari sebuah queue adalah :
1. Enqueue : proses penambahan elemen di posisi belakang
2. Dequeue : proses pengambilan elemen di posisi depan
Selain operasi dasar di atas, ada pula operasi-operasi lain yang dapat dilakukan terhadap sebuah queue yaitu :
1. Operasi pemeriksaan queue kosong (fungsi kosong)
2. Operasi pemeriksaan queue penuh (fungsi penuh).
3. Operasi inisialisasi queue (fungsi inisialisasi)

Adapun presentasi queue dapat dilakukan dengan 2 cara yaitu :
Dengan menggunakan array statis
Operasi-operasi yang dapat dilakukan dalam queue yang menggunakan representasi array statis adalah :

- Pendeklarasian sebuah queue
Setiap queue memiliki elemen-elemen (field) berupa posisi depan, posisi belakang, elemen antrian, dan maksimal elemennya.

Adapun pendeklarasian queue dalam bahasa C adalah :

#define maks 5
struct TQueue{
int depan,belakang;
int maks_queue;
int antrian[maks];
};
TQueue Q,Queue,Q2;//deklarasi variable bertipe TQueue

- Inisialisasi Queue
Inisialisasi queue adalah proses pemberian nilai 0 untuk field depan dan belakang dari queue dan juga pemberian nilai maks ke maks_queue yang menunjukan banyaknya maksimal data dalam queue.
Karena dalam bahasa C elemen sebuah array dimulai dengan 0 maka proses inisialisasi nilai depan dan belakang bukan 0 tetapi -1 sehingga ketika ada proses penambahan elemen (enqueue) akan bernilai 0 sehingga elemen tersebut akan disimpan dalam elemen antrian pada posisi 0.
Implementasi fungsi inisialisasi queue dalam bahasa C adalah
void inisialisasi(TQueue *Q)
{
Q->maks_queue=maks;
Q->depan=-1;
Q->belakang=-1;
}
Cara pemanggilannya adalah :
Inisialisasi(&Q);

- Fungsi Kosong
Fungsi kosong digunakan untuk memeriksa apakan keadaan queue tidak memiliki elemen. Fungsi kosong didapatkan dengan memeriksa field belakang dari queue. Jika field belakang bernilai 0 maka berarti queue kosong dan jika tidak 0 maka berarti queue mempunyai elemen.
Implementasi dalam bahasa C agak berbeda karena elemen array dimulai dari 0 sehingga pemeriksaan nilai belakang dilakukan dengan membandingkannya dengan nilai -1. Jika nilai belakang bernilai -1 maka queue kosong (true) dan jika lebih dari -1 berarti queue tidak kosong (false). Sehingga implementasinya dalam bahasa C adalah :
int kosong(TQueue Q)
{
if (Q.belakang==-1)
return 1;
else
return 0;
}
Cara pemanggilannya adalah :
if(kosong(Q))// jika queue Q kosong
……
- Fungsi Penuh
Fungsi penuh berguna untuk memeriksa apakah suatu queue telah penuh. Fungsi ini diperlukan ketika proses enqueue. Fungsi ini akan bernilai benar (true) jika field belakang sama dengan nilai maks_queue jika tidak sama dengan berarti queue belum penuh.
Dalam bahasa C perbandingan yang dilakukan adalah bukan dengan maks_queue tetapi dengan nilai maks_queue-1 karena elemen array dalam bahasa C dimulai dari posisi 0. Implementasi dalam bahasa C adalah :
int penuh(TQueue Q)
{
if(Q.belakang==Q.maks_queue-1)
return 1;
else
return 0;
}
Cara pemanggilannya adalah :
If(!penuh(Q)) //if queue Q tidak(!) penuh
.....

- Operasi Enqueue
Proses enqueue adalah proses untuk penambahan di posisi belakang. Penambahan ini dilakukan jika kondisi queue tidak penuh. Jika keadaan masih kosong, maka field depan dan belakang bernilai 1 tetapi jika sudah mempunyai elemen maka yang nilai belakang harus bertambah 1. Kemudian data baru disimpan di array pada posisi belakang.
Implementasi dalam C harus melakukan penyesuaian karena elemen array C dimulai dari 0 sehingga ketika queue masih kosong pemberian nilai depan dan belakang adalah 0 bukan 1. Untuk lebih jelasnya perhatikan potongan program di bawah ini :
void enqueue(TQueue *Q, int data)
{
if(!penuh(*Q))
{
if(empty(*Q)
{
Q->depan=0;
Q->belakang=0;
}
else
Q->belakang++;
Q->antrian[Q->belakang]=data;
}
else
printf("Queue Telah Penuh\n");
}
Cara penggunaannya :
int data=7
enqueue(&Q,data);

- Operasi Dequeue
Operasi dequeue adalah proses pengambilan elemen queue. Tentunya elemen yang diambil selalu dari elemen pertama (1). Setelah elemen pertama diambil, maka akan diperlukan proses pergeseran elemen data setelah elemen data yang diambil (dari posisi ke-2 sampai posisi paling belakang), dan kemudian posisi belakang akan dikurangi 1 karena ada data yang diambil.
Implementasi dalam bahasa C dilakukan dengan pengambilan elemen pada posisi 0, sehingga fungsi dequeue-nya menjadi :

int dequeue(TQueue *Q)
{
int data,i;
if(!kosong(*Q))
{
data=Q->antrian[Q->depan];
for(i=0;i<=Q->belakang-1;i++)
Q->antrian[i]=Q->antrian[i+1];
Q->belakang--;
return data;
}
else
{
printf("Queue Kosong.\n");
return 0;
}
}
Cara penggunaan fungsi tersebut adalah :
int data;
data=dequeue(&Q); //ambil data dari dequeue pada queue Q
printf(“%d”,data);

2. Dengan menggunakan linked list.
Proses penyimpanan elemen queue dalam linked list mirip dengan operasi pada single linked list yang menggunakan penyimpanan tambah akhir dan hapus awal.

Operasi Enqueue
Proses enqueue dalam queue linked list adalah dengan menambahkan elemen baru ke posisi paling belakang (sambungkan field berikutnya dari field belakang ke posisi pointer baru). Setelah itu, pointer penunjuk belakang harus berpindah ke posisi baru tersebut. Proses ini seperti proses penambahan di belakang pada single linked list.

Operasi Dequeue
Proses dequeue untuk queue linked list adalah dengan mengambil data yang ditunjuk pointer depan dan kemudian pointer yang depan tersebut diambil dan kemudian dihapus. Pointer depan harus berpindah ke elemen antrian berikutnya. Proses tersebut dilakukan hanya jika linked list tidak kosong. Proses ini mirip dengan proses penghapusan data awal pada single linked list.

QUEUE DENGAN CIRCULAR ARRAY
Jika kita menggunakan array untuk queue seperti di atas, maka ketika ada proses pengambilan (dequeue) ada proses pergeseran data. Proses pergeseran data ini pasti memerlukan waktu apalagi jika elemen queue-nya banyak. Oleh karena itu solusi agar proses pergeseran dihilangkan adalah dengan metode circular array.Atau agar lebih jelas, array di atas dapat dibayangkan ke dalam bentuk seperti lingkaran di bawah ini. Aturan-aturan dalam queue yang menggunakan circular array adalah :

1. Proses penghapusan dilakukan dengan cara nilai depan (front) ditambah 1 : depan=depan + 1.
2. Proses penambahan elemen sama dengan linear array yaitu nilai belakang ditambah 1 : belakang=belakang + 1.
3. Jika depan = maks dan ada elemen yang akan dihapus, maka nilai depan = 1.
4. Jika belakang = maks dan depan tidak 1 maka jika ada elemen yang akan ditambahkan, nilai belakang=1

5. Jika hanya tinggal 1 elemen di queue (depan = belakang), dan akan dihapus maka depan diisi 0 dan belakang diisi dengan 0 (queue kosong).

Operasi-operasi yang dapat terjadi dalam queue yang menggunakan circular array adalah :

1. Pendeklarasian Queue
Setiap queue memiliki elemen-elemen (field) berupa posisi depan, posisi belakang, elemen antrian, dan maksimal elemennya.

2. Inisialisasi Queue
Inisialisasi queue adalah proses pemberian nilai 0 untuk field depan dan belakang dari queue dan juga pemberian nilai maks ke maks_queue yang menunjukan banyaknya maksimal data dalam queue.
Karena dalam bahasa C elemen sebuah array dimulai dengan 0 maka proses inisialisasi nilai depan dan belakang bukan 0 tetapi -1 sehingga ketika ada proses penambahan elemen (enqueue) akan bernilai

3. Fungsi Kosong
Suatu queue yang menggunakan circular array dapat dikatakan kosong jika nilai yang menunjuk posisi depan atau belakang mempunyai nilai 0.
Implementasi dalam bahasa C, perbandingan posisi depan atau belakang dilakukan bukan dengan angka 0 tetapi angka -1 karena angka 0 menunjukan elemen pertama dari array.

4. Fungsi Penuh
Suatu queue akan disebut penuh jika terjadi 2 hal yaitu jika nilai depan mempunyai nilai 1 dan posisi belakang sama dengan maks_queue atau jika posisi depan sama dengan posisi belakang +1. Jika salah satu dari 2 hal tersebut terjadi maka fungsi penuh mempunyai nilai true dan jika tidak terjadi 2 hal tersebut maka fungsi bernilai false.
Implementasi dalam bahasa C agar beda karena posisi awal array bukan 1 tapi 0 dan posisi terakhir data adalah maks_queue-1 bukan maks_queue.

5. Operasi Enqueue
Proses enqueue data hanya bisa dilakukan jika queue tidak kosong. Ada beberapa hal yang harus diperhatikan ketika akan melakukan enqueue pada circular array, diantaranya adalah :

- Kondisi ketika queue masih kosong. Jika ini terjadi, maka posisi depan dan belakang bernilai 0.
- Ketika ketika nilai belakang sama dengan maks_queue, maka posisi belakang adalah 0. Ini terjadi ketika posisi depan lebih besar dari 0 (pernah ada dequeue).
- Ketika nilai belakang masih lebih kecil dari maks_queue maka posisi belakang ditambah 1 : belakang=belakang+1;

Dari ketentuan-ketentuan di atas dapat diimplementasikan dalam bahasa C dengan mengganti beberapa hal yaitu posisi perbandingan/pengisian dengan nilai 0 diganti dengan perbandingan/pengisian dengan nilai -1 dan perbandingan dengan nilai maks_queue diganti dengan maks_queue-1. Itu disebabkan karena dalam bahasa C array dimulai dari 0.

6. Operasi Dequeue
Proses dequeue hanya bisa dilakukan jika queue dalam keadaan tidak kosong. Ada beberapa kondisi yang harus diperhatikan ketika dequeue elemen queue yaitu :

- Kondisi ketika posisi depan sama dengan posisi belakang (queue hanya memiliki 1 elemen) maka nilai depan dan belakang diisi dengan 0 (queue kosong).
- Jika posisi depan sama dengan posisi maks_queue maka posisi depan berpindah ke 1.
- Selain itu, posisi depan ditambah dengan 1 : depan=depan+1

Ketika kita mengimplementasikannya dalam bahasa C, maka ada beberapa hal yang harus diganti adalah semua pengisian/perbandingan dengan angka 1 diganti dengan 0 (karena elemen array dalam bahasa C adalah 0), serta ketika ada perbandingan/pengisian dengan nilai 0 diganti dengan -1 dan perbandingan/pengisian dengan nilai maks_queue diganti dengan maks_queue-1.

Contoh Program QUEUE :

#include <conio.h>
#include <stdio.h>
#include <iostream.h>
#include <iomanip.h>
#define max 6

typedef struct
{
 int head;
   int tail;
}antrian;

antrian ue;

typedef struct
{
   char *nm[max], *almt[max], *tgl[max];
} variabel;

variabel qu;


void creat()
{
 ue.head=ue.tail=-1;
}

empty()
{
 if(ue.tail==-1)
      return 1;
   else
      return 0;
}

full()
{
 if(ue.tail==max-1)
      return 1;
   else
      return 0;
}

void en(char *a, char *b, char *c)
{
 if(empty()==1)
   {
      ue.head=ue.tail=0;
      qu.nm[ue.tail]=a;
      qu.almt[ue.tail]=b;
      qu.tgl[ue.tail]=c;
   }

   else if(full()==0)
   {
    ue.tail++;
      qu.nm[ue.tail]=a;
      qu.almt[ue.tail]=b;
      qu.tgl[ue.tail]=c;
   }

   else if(full()==1)
   {
    cout<<"QUEUE PENUH";
   }
}

de()
{
 if(empty()==0)
 {
  int i;
      char *aa=qu.nm[ue.tail];
      char *bb=qu.almt[ue.tail];
      char *cc=qu.tgl[ue.tail];

       for(i=ue.head; 1<=ue.tail-1; i++)
    {
       qu.nm[i]=qu.nm[i+1];
         qu.almt[i]=qu.almt[i+1];
     qu.tgl[i]=qu.tgl[i+1];
   }

    ue.tail--;
      cout<<"DATA YANG DIHAPUS ADALAH : \n";

      cout<<"NAMA   : "<<aa<<endl;
      cout<<"ALAMAT : "<<bb<<endl;
      cout<<"TANGGAL: "<<cc<<endl;
   }


   else if(empty()==1)
   { cout<<"DATA EROR......QUEUE KOSONG"; }

   return 1;
}

void clear()
{
   ue.head=ue.tail=-1;
   cout<<"QUEUE CLEAR";
}

void view()
{
 if(empty()==0)
   {
  cout<<"NO NAMA       ALAMAT            TANGGAL\n";

   for(int i=ue.head; i<=ue.tail; i++)
   {
     cout<<setiosflags(ios::left)<<setw(3)<<i;
      cout<<setiosflags(ios::left)<<setw(11)<<qu.nm[i];
      cout<<setiosflags(ios::left)<<setw(18)<<qu.almt[i];
      cout<<setiosflags(ios::left)<<setw(9)<<qu.tgl[i]<<endl;
   }
   }
   else
   { cout<<"NO NAMA       ALAMAT            TANGGAL\n"; }
}

main()
{

 int menu;
   char nm[20], almt[40], tgl[20];

creat();

do{

clrscr();

cout<<"===========================\n";
cout<<"    MENU PROGRAM QUEUE\n";
cout<<"===========================\n";
cout<<"1.ENQUEUE\n";
cout<<"2.DEQUEUE\n";
cout<<"3.CLEAR\n";
cout<<"4.VIEW\n";
cout<<"5.EXIT\n";
cout<<"===========================\n";
cout<<"PILIH MENU : ";       cin>>menu;

if(menu==1)
{     cout<<"MASUKAN NAMA   : ";   gets(nm);
     cout<<"MASUKAN ALAMAT : ";   gets(almt);
         cout<<"MASUKAN TANGGAL: ";      gets(tgl);
     en(nm, almt, tgl);
}

else if(menu==2)
{
   de();
}

else if(menu==3)
{
    clear();
}

else if(menu==4)
{
    view();
}

else if(menu==5)
{
    cout<<"exiiitttt......";
}
getch();

}while(menu!=5);

}

Sumber Referensi Dari :

http://masiyak.com/queue-antrian-di-struktur-data/

STACK DALAM BAHASA C++

STACK

    Bagi yang mengikuti matakuliah Algoritma dan Struktur Data maupun Praktikum Algoritma dan Struktur Data. Pada mata kuliah tersebut, pasti menemukan materi seperti Stack, Queue, Single Linked List, Double Linked List, dan lain-lain. Tapi disini aku mau bahas dulu apa itu Stack dan Queue.

     Stack adalah suatu urutan elemen yang elemennya dapat diambil dan ditambah hanya pada posisi akhir (top) saja. Contoh dalam kehidupan sehari-hari adalah tumpukan piring di sebuah restoran yang tumpukannya dapat ditambah pada bagian paling atas dan jika mengambilnya pun dari bagian paling atas pula. Lihat gambar 1.

             Ada 2 operasi paling dasar dari stack yang dapat dilakukan, yaitu :
1. Operasi push yaitu operasi menambahkan elemen pada urutan terakhir (paling atas).
2. Operasi pop yaitu operasi mengambil sebuah elemen data pada urutan terakhir dan menghapus elemen tersebut dari stack.
         Sebagai contoh, misalkah ada data sebagai berikut : 1 3 5 6, maka data tersebut dapat tersimpan dalam bentuk sebagai berikut :

         Contoh lain adalah ada sekumpulan perintah stack yaitu push(5), push(7), pop, push(3), pop. Jika dijalankan, maka yang akan terjadi adalah :

           Selain operasi dasar stack (push dan stack), ada lagi operasi lain yang dapat terjadi dalam stack yaitu:
1. Proses deklarasi yaitu proses pendeklarasian stack.
2. Proses isempty yaitu proses pemeriksaan apakah stack dalam keadaan kosong.
3. Proses isfull yaitu proses pemeriksaan apakah stack telah penuh.
4. Proses inisialisasi yaitu proses pembuatan stack kosong, biasanya dengan pemberian nilai untuk top.

            Operasi-operasi stack secara lengkap adalah sebagai berikut :
1. Pendeklarasian stack
Proses pendeklarasian stack adalah proses pembuatan struktur stack dalam memori. Karena stack dapat direpresentasikan dalam 2 cara, maka pendeklarasian stack pun ada 2 yaitu :
a. Pendeklarasian stack yang menggunakan array. Suatu stack memiliki beberapa bagian yaitu

• top yang menunjuk posisi data terakhir (top)
• elemen yang berisi data yang ada dalam stack. Bagian ini lah yang berbentuk array.
• maks_elemen yaitu variable yang menunjuk maksimal banyaknya elemen dalam stack.

Dalam bahasa C, pendeklarasiannya adalah :

b. Pendeklarasian stack yang menggunakan single linked list
Adapun stack yang menggunakan single linked list, hanya memerlukan suatu pointer yang menunjuk ke data terakhir (perhatikan proses di halaman sebelumnya). Setiap elemen linked list mempunyai 2 field yaitu elemen datanya dan pointer bawah yang menunjuk posisi terakhir sebelum proses push.
Pendeklarasian dalam bahasa C adalah :

2. Inisialisasi

Inisialisasi stack adalah proses pembuatan suatu stack kosong. Adapun langkah-langkah proses tersebut berdasarkan jenis penyimpanannya adalah :

a. Inisialisasi stack yang menggunakan array.

Proses inisialisasi untuk stack yang menggunakan array adalah dengan mengisi nilai field top dengan 0 (nol) jika elemen pertama diawali dengan nomor 1. Kalau elemen pertama array dimulai dengan 0 (contoh bahasa C), maka top diisi dengan nilai -1. Implementasinya dalam bahasa C adalah :

b. Inisialisasi stack yang menggunakan single linked list

Proses inisialisasi untuk stack yang menggunakan single linked list adalah dengan mengisi nilai pointer stack dengan NULL. Implementasi dalam bahasa C adalah :

3. Operasi IsEmpty

Operasi ini digunakan untuk memeriksa apakah stack dalam keadaan kosong. Operasi ini penting dilakukan dalam proses pop. Ketika suatu stack dalam keadaan kosong, maka proses pop tidak bisa dilakukan. Adapun langkah-langkah operasi ini adalah :

a. Operasi IsEmpty pada stack yang menggunakan array.

Operasi ini dilakukan hanya dengan memeriksa field top. Jika top bernilai 0 (untuk elemen yang dimulai dengan index 1) atau top bernilai -1 (untuk elemen yang dimulai dengan index 0), maka berarti stack dalam keadaan empty (kosong) yang akan me-return-kan true (1) dan jika tidak berarti stack mempunyai isi dan me-return-kan nilai false (0)

Implementasi dalam bahasa C adalah :

int isempty(tstack stack)
{
if (stack.top==-1)
return 1;
else
return 0;
}

Cara penggunaannya adalah :

//Penggunaan isempty dalam statement if
if( isempty(stack) ) ...

b. Operasi IsEmpty pada stack yang menggunakan single linked list.

Operasi IsEmpty pada stack yang menggunakan single linked list adalah dengan memeriksa apakah pointer stack bernilai NULL. Jika stack bernilai NULL maka menandakan stack sedang keadaan empty (kosong) dan akan me-return-kan nilai 1 dan jika tidak NULL maka menandakan stack mempunyai isi (tidak kosong) sehingga operasi tersebut akan me-return-kan nilai false (0).

Implementasinya dalam bahasa C adalah :

int isempty(PStack stack)
{
if (stack==NULL)
return 1;
else
return 0;
}

Cara penggunaannya adalah

//Penggunaan isempty dalam statement if
if( isempty(stack) ) ... 

==========================

CONTOH PROGRAM STACK C
==========================
#include <stdio.h>

#include <conio.h>

#define max 5

typedef struct {

int top;

int data[max+1];

}stack;

stack tumpukan;

void createEmpty();

int IsEmpty();

int IsFull();

void push(int x);

void pop();

main(){

int lagi;

int input;

int pilih;

createEmpty();

pilih = 0;

puts("-----IKA SANJAYA (140010048)-----");

while (pilih != 5){

puts("=====================================");

puts("             MENU UTAMA");

puts("=====================================");

puts("1. Cek kondisi Stack");

puts("2. Tambah data");

puts("3. Keluarkan isi stack");

puts("4. Kosongkan stack");

puts("5. Keluar");

printf("Pilihan: ");

scanf("%d",&pilih);

switch(pilih){

case 1: if (IsFull() == 1)

puts("Stack sudah penuh.");

else

{

printf("Masukkan data: ");

scanf("%d",&input);

push(input);

printf("%d",tumpukan.top);

printf("%d",IsFull());

printf("%d",IsEmpty());

}

break;

case 2: if (IsEmpty() == 1)

puts("Stack masih kosong");

else if ((IsEmpty() == 0) && (IsFull() == 0))

puts("Stack sudah terisi, tapi belum penuh");

else

puts("Stack sudah penuh");

getch();

break;

case 3: while (IsEmpty() == 0)

{

printf("%d \n",tumpukan.data[tumpukan.top]);

pop();

}

getch();

break;

case 4: createEmpty();

puts("Stack sudah kosong. Top = 0");

getch();

break;

case 5: puts("Sayonara ^_^"); getch();

break;

}

}

}

void createEmpty(){

tumpukan.top = 0;

}

int IsEmpty(){

if (tumpukan.top == 0)

return 1;

else

return 0;

}

int IsFull(){

if (tumpukan.top == max)

return 1;

else

return 0;

}

void push(int x){

tumpukan.top = tumpukan.top + 1;

tumpukan.data[tumpukan.top] = x;

}

void pop(){

tumpukan.top = tumpukan.top - 1;

}

 
Sumber Referensi Dari :
http://www.inilahjalanku.com/stack-pada-bahasa-pemrograman-c/