RSS

Category Archives: Algotima C++

Hapus Array dan Geser Elemen Array C++

#include <cstdlib>
#include <iostream>
#define maks5

using namespace std;

class Array1D{
 friend ostream& operator<<(ostream&, const Array1D&);
 friend istream& operator>>(istream&, Array1D&);
public:
 Array1D();
 void cetak();
 void geser_kiri();
 void geser_kanan();
 void hapus_elemen();

private:
 char A[5];
 int posisi;
};

Array1D::Array1D(){
 for(int i=0;i<5;i++)
 A[i]='O';
}

void Array1D::cetak(){
 for(int i=0;i<5;i++)
 cout<<A[i]<<" ";
}

ostream& operator<<(ostream& out, const Array1D& x){
 for(int i=0;i<5;i++)
 out<<x.A[i]<<" ";
 out<<endl;
 return out;
}

istream& operator>>(istream& in, Array1D& x){
 int posisi;
 for (int posisi=1; posisi<=5; posisi++){
 cout<<"masukkan nilai array posisi ke- : ";
 in>>x.posisi;
 if(posisi >= 0 && posisi <= 5){cout<<"masukkan elemen arraynya :";
 in>>x.A[posisi-1];
 }
 }
 return in;
}

void Array1D::geser_kanan(){
 int n=5;
 int temp=A[n-1];
 for(int i=n-1;i>=0;i--)
 A[i+1]=A[i];
 A[0]=temp;
}

void Array1D::geser_kiri(){
 int n=5;
 int temp=A[0];
 for(int i=0;i<n;i++)
 A[i]=A[i+1];
 A[n-1]=temp;
}

void Array1D::hapus_elemen(){
 int posisi;
 cout<<"Pilih indeks berapa yg akan di hapus : ";
 cin>>posisi;
 if(posisi>0 && posisi<=5)
 A[posisi-1]='O';
 else cout<<"indeks yg anda masuukan salah karena indek hanya terdiri dari 1 - 5\n";
}

int main(int argc, char *argv[])
{
 Array1D x;
 cout<<"Array masih kosong : "<<x;
 cin>>x;

 cout<<"Isi Array saat ini : "<<x;
 x.geser_kiri();
 cout<<"Isi Array setelah di geser kiri : "<<x;
 x.geser_kanan();
 cout<<"Isi Array setelah di geser kanan : "<<x;
 cout<<"Urutan elemen pada indeksnya saat ini : "<<x;
 x.hapus_elemen();
 cout<<"Setelah dihapus menjadi : "<<x;

 system("PAUSE");
 return EXIT_SUCCESS;
}
 
Leave a comment

Posted by on 20 February 2011 in Algotima C++

 

Contih Program C++ Stack

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

#define MAXSTACK 100

typedef int itemType;
typedef struct
{
int item[MAXSTACK];
int jml;
} Stack;

void init(Stack *s)
{
s->jml=0;
}

int kosong(Stack *s)
{
return (s->jml==0);
}

int penuh(Stack *s)
{
return (s->jml==MAXSTACK);
}

void isi(itemType x, Stack *s)
{
if(penuh(s))
printf(“\nMaaf data sudah penuh\n”);
else
{
s->item[s->jml]=x;
++(s->jml);
}
}

void ambil(Stack *s, itemType *x)
{
if(kosong(s))
printf(“\nMaaf data masih kosong\n”);
else
{
–(s->jml);
*x=s->item[s->jml];
s->item[s->jml]=0;
printf(“\nData %i berhasil diambil\n”,*x);
}
}

void tampil(Stack *s)
{
if(kosong(s))
printf(“\nMaaf Data masih kosong\n”);
else
printf(“\n”);
for(int i=s->jml-1;i>=0;i–)
{
printf(“Data: %d\n”,s->item[i]);
}
}

void hapus(Stack *s)
{
s->jml=0;
printf(“\nSemua data berhasil dihapus\n”);
}

void main()
{
int pil;
Stack tumpukan;
itemType data;
init(&tumpukan);

do
{
printf(“\nMENU: \n 1. Isi\n 2. Ambil\n 3. Lihat\n 4. Hapus\n 5. Keluar\n”);
printf(“Masukkan pilihan: “); scanf(“%i”,&pil);

switch(pil)
{
case 1:
printf(“\nMasukkan data: “); scanf(“%i”,&data);;
isi(data,&tumpukan);
break;
case 2:
ambil(&tumpukan,&data);
break;
case 3:
tampil(&tumpukan);
break;
case 4:
hapus(&tumpukan);
break;
}
}while(pil!=5);

getch();
}

 
1 Comment

Posted by on 17 December 2010 in Algotima C++

 

Contoh Linked List C++

#include <iostream.h>

struct node
  {  char name[20];    // Name of up to 20 letters
     int age;          // D.O.B. would be better
     float height;     // In metres
     node *nxt;// Pointer to next node
  };

node *start_ptr = NULL;
node *current;		 // Used to move along the list
int option = 0;

void add_node_at_end()
  {  node *temp, *temp2;   // Temporary pointers

     // Reserve space for new node and fill it with data
     temp = new node;
     cout << "Please enter the name of the person: ";
     cin >> temp->name;
     cout << "Please enter the age of the person : ";
     cin >> temp->age;
     cout << "Please enter the height of the person : ";
     cin >> temp->height;
     temp->nxt = NULL;

     // Set up link to this node
     if (start_ptr == NULL)
       { start_ptr = temp;
	 current = start_ptr;
       }
     else
       { temp2 = start_ptr;
         // We know this is not NULL - list not empty!
         while (temp2->nxt != NULL)
           {  temp2 = temp2->nxt;
              // Move to next link in chain
           }
         temp2->nxt = temp;
       }
  }

void display_list()
  {  node *temp;
     temp = start_ptr;
     cout << endl;
     if (temp == NULL)
       cout << "The list is empty!" << endl;
     else
       { while (temp != NULL)
	   {  // Display details for what temp points to
              cout << "Name : " << temp->name << " ";
              cout << "Age : " << temp->age << " ";
	      cout << "Height : " << temp->height;
	      if (temp == current)
		cout << " <-- Current node";
              cout << endl;
	      temp = temp->nxt;

	   }
	 cout << "End of list!" << endl;
       }
  }

void delete_start_node()
   { node *temp;
     temp = start_ptr;
     start_ptr = start_ptr->nxt;
     delete temp;
   }

void delete_end_node()
   { node *temp1, *temp2;
     if (start_ptr == NULL)
          cout << "The list is empty!" << endl;
     else
        { temp1 = start_ptr;
          if (temp1->nxt == NULL)
             { delete temp1;
               start_ptr = NULL;
             }
          else
             { while (temp1->nxt != NULL)
                { temp2 = temp1;
                  temp1 = temp1->nxt;
                }
               delete temp1;
               temp2->nxt = NULL;
             }
        }
   }

void move_current_on ()
   { if (current->nxt == NULL)
      cout << "You are at the end of the list." << endl;
     else
      current = current->nxt;
   }

void move_current_back ()
   { if (current == start_ptr)
      cout << "You are at the start of the list" << endl;
     else
      { node *previous;     // Declare the pointer
        previous = start_ptr;

        while (previous->nxt != current)
          { previous = previous->nxt;
          }
        current = previous;
      }
   }

void main()
  {  start_ptr = NULL;
     do
	{
	  display_list();
	  cout << endl;
	  cout << "Please select an option : " << endl;
	  cout << "0. Exit the program." << endl;
	  cout << "1. Add a node to the end of the list." << endl;
	  cout << "2. Delete the start node from the list." << endl;
	  cout << "3. Delete the end node from the list." << endl;
	  cout << "4. Move the current pointer on one node." << endl;
          cout << "5. Move the current pointer back one node." << endl;
          cout << endl << " >> ";
	  cin >> option;

	  switch (option)
	    {
	      case 1 : add_node_at_end(); break;
	      case 2 : delete_start_node(); break;
	      case 3 : delete_end_node(); break;
	      case 4 : move_current_on(); break;
              case 5 : move_current_back();
	    }
	}
     while (option != 0);
  }
 
Leave a comment

Posted by on 12 December 2010 in Algotima C++

 

Algoritma Sorting

ada beberapa Algoritma Sorting, yaitu :
1.Insertion Sort
Salah satu algoritma sorting yang paling sederhana adalah insertion sort. Ide dari algoritma ini dapat dianalogikan seperti mengurutkan kartu. Penjelasan berikut ini menerangkan bagaimana algoritma insertion sort bekerja dalam pengurutan kartu.
Anggaplah anda ingin mengurutkan satu set kartu dari kartu yang bernilai paling
kecil hingga yang paling besar. Seluruh kartu diletakkan pada meja,sebutlah meja
ini sebagai meja pertama, disusun dari kiri ke kanan dan atas ke bawah. Kemudian
kita mempunyai meja yang lain,meja kedua, dimana kartu yang diurutkan akan diletakkan.Ambil kartu pertama yang terletak pada pojok kiri atas meja pertama
dan letakkan pada meja kedua. Ambil kartu kedua dari meja pertama, bandingkan
dengan kartu yang berada pada meja kedua, kemudian letakkan pada urutan yang
sesuai setelah perbandingan. Proses tersebut akan berlangsung hingga seluruh kartu
pada meja pertama telah diletakkan berurutan pada meja kedua.
Algoritma insertion sort pada dasarnya memilah data yang akan diurutkan menjadi
dua bagian, yang belum diurutkan (meja pertama) dan yang sudah diurutkan (meja
kedua). Elemen pertama diambil dari bagian array yang belum diurutkan dan
kemudian diletakkan sesuai posisinya pada bagian lain dari array yang telah
diurutkan. Langkah ini dilakukan secara berulang hingga tidak ada lagi elemen yang
tersisa pada bagian array yang belum diurutkan.

2.Selection Sort
Jika anda diminta untuk membuat algoritma sorting tersendiri, anda mungkin akan
menemukan sebuah algoritma yang mirip dengan selection sort. Layaknya insertion
sort, algoritma ini sangat rapat dan mudah untuk diimplementasikan. Mari kita kembali menelusuri bagaimana algoritma ini berfungsi terhadap satu paket kartu. Asumsikan bahwa kartu tersebut akan diurutkan secara ascending. Pada awalnya, kartu tersebut akan disusun secara linier pada sebuah meja dari kiri ke kanan, dan dari atas ke bawah. Pilih nilai kartu yang paling rendah, kemudian tukarkan posisi kartu ini dengan kartu yang terletak pada pojok kiri atas meja. Lalu cari kartu dengan nilai paling rendah diantara sisa kartu yang tersedia. Tukarkan kartu yang baru saja terpilih dengan kartu pada posisi kedua. Ulangi langkah–langkah tersebut hingga posisi kedua sebelum posisi terakhir dibandingkan dan dapat digeser dengan kartu yang bernilai lebih rendah.Ide utama dari algoritma selection sort adalah memilih elemen dengan nilai paling rendah dan menukar elemen yang terpilih dengan elemen ke-i. Nilai dari i dimulai dari 1 ke n, dimana n adalah jumlah total elemen dikurangi

3.Merge Sort
Sebelum mendalami algoritma merge sort, mari kita mengetahui garis besar dari
konsep divide and conquer karena merge sort mengadaptasi pola tersebut.
Pola Divide and Conquer
Beberapa algoritma mengimplementasikan konsep rekursi untuk menyelesaikan
permasalahan. Permasalahan utama kemudian dipecah menjadi sub-masalah,
kemudian solusi dari sub-masalah akan membimbing menuju solusi permasalahan
utama.
Pada setiap tingkatan rekursi, pola tersebut terdiri atas 3 langkah.
- Divide
Memilah masalah menjadi sub masalah
- Conquer
Selesaikan sub masalah tersebut secara rekursif. Jika sub-masalah tersebut
cukup ringkas dan sederhana, pendekatan penyelesaian secara langsung akan
lebih efektif
- Kombinasi
Mengkombinasikan solusi dari sub-masalah, yang akan membimbing menuju
penyelesaian atas permasalahan utama

4.Quicksort
Quicksort ditemukan oleh C.A.R Hoare. Seperti pada merge sort, algoritma ini juga
berdasar pada pola divide-and-conquer. Berbeda dengan merge sort, algoritma ini
hanya mengikuti langkah – langkah sebagai berikut :
1. Divide
Memilah rangkaian data menjadi dua sub-rangkaian A[p…q-1] dan A[q+1…r]
dimana setiap elemen A[p…q-1] adalah kurang dari atau sama dengan A[q]
dan setiap elemen pada A[q+1…r] adalah lebih besar atau sama dengan
elemen pada A[q]. A[q] disebut sebagai elemen pivot. Perhitungan pada
elemen q merupakan salah satu bagian dari prosedur pemisahan.
2. Conquer
Mengurutkan elemen pada sub-rangkaian secara rekursif
Pada algoritma quicksort, langkah ”kombinasi” tidak di lakukan karena telah terjadi
pengurutan elemen – elemen pada sub-array

Algoritma Binary Search

Binary Search adalah algoritma pencarian yang lebih efisien daripada algorima Sequential Search. Hal ini dikarenakan algoritma ini tidak perlu menjelajahi setiap elemen dari tabel. Kerugiannya adalah algoritma ini hanya bisa digunakan pada tabel
yang elemennya sudah terurut baik menaik maupun menurun.Pada intinya, algoritma ini menggunakan prinsip divide and conquer, dimana sebuah masalah atau tujuan diselesaikan dengan cara mempartisi masalah menjadi bagian yang lebih kecil. Algoritma ini membagi sebuah tabel menjadi dua dan memproses satu bagian dari tabel itu saja.
Algoritma ini bekerja dengan cara memilih record dengan indeks tengah dari tabel
dan membandingkannya dengan record yang hendak dicari. Jika record tersebut lebih rendah atau lebih tinggi, maka tabel tersebut dibagi dua dan bagian tabel yang bersesuaian akan diproses kembali secara
rekursif.

_____________________________________________________________________________________________

Contoh Program sort, binary, sequential  pada C++

Ini adalah program sorting paling lengkap.

contoh program sort c++ :

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

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

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

void bubble_sort()
{
for(int i=1;i<n;i++)
{
for(int j=n-1;j>=i;j–)
{
if(data[j]<data[j-1]) tukar(j,j-1);
}
}
cout<<”bubble sort selesai!”<<endl;
}

void exchange_sort()
{
for (int i=0; i<n-1; i++)
{
for(int j = (i+1); j<n; j++)
{
if (data [i] > data[j]) tukar(i,j);
}
}
cout<<”exchange sort selesai!”<<endl;
}

void selection_sort()
{
int pos,i,j;
for(i=0;i<n-1;i++)
{
pos = i;
for(j = i+1;j<n;j++)
{
if(data[j] < data[pos]) pos = j;
}
if(pos != i) tukar(pos,i);
}
cout<<”selection sort selesai!”<<endl;
}

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;
}
cout<<”insertion sort selesai!”<<endl;
}

void QuickSort(int L, int R) //the best sort i’ve ever had
{
int i, j;
int mid;

i = L;
j = R;
mid = data[(L+R) / 2];

do
{
while (data[i] < mid) i++;
while (data[j] > mid) j–;

if (i <= j)
{
tukar(i,j);
i++;
j–;
};
} while (i < j);

if (L < j) QuickSort(L, j);
if (i < R) QuickSort(i, R);
}

void Input()
{
cout<<”Masukkan jumlah data = “; cin>>n;
for(int i=0;i<n;i++)
{
cout<<”Masukkan data ke-”<<(i+1)<<” = “; cin>>data[i];
data2[i] = data[i];
}
}

void Tampil()
{
cout<<”Data : “<<endl;
for(int i=0;i<n;i++)
{
cout<<data[i]<<” “;
}
cout<<endl;
}

void AcakLagi()
{
for(int i=0;i<n;i++)
{
data[i] = data2[i];
}
cout<<”Data sudah teracak!”<<endl;
}

void main()
{
int pil;
clrscr();
do
{
clrscr();
cout<<”Program Sorting Komplit!!!”<<endl;
cout<<”*********************************************”<<endl;
cout<<” 1. Input Data”<<endl;
cout<<” 2. Bubble Sort”<<endl;
cout<<” 3. Exchange Sort”<<endl;
cout<<” 4. Selection Sort”<<endl;
cout<<” 5. Insertion Sort”<<endl;
cout<<” 6. Quick Sort”<<endl;
cout<<” 7. Tampilkan Data”<<endl;
cout<<” 8. Acak Data”<<endl;
cout<<” 9. Exit”<<endl;
cout<<”    Pilihan Anda = “;  cin>>pil;
switch(pil)
{
case 1:Input(); break;
case 2:bubble_sort(); break;
case 3:exchange_sort(); break;
case 4:selection_sort(); break;
case 5:insertion_sort(); break;
case 6:QuickSort(0,n-1);
cout<<”quick sort selesai!”<<endl;
break;
case 7:Tampil(); break;
case 8:AcakLagi(); break;
}
getch();
}while(pil!=9);
}

contoh program searching (binary) pada c++ :

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

int data[10] = {1,3,4,7,12,25,40,65,78,90};  //variabel global

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 < data[m])
r = m-1;
else l = m+1;
}
if(ketemu == 1) return 1; else return 0;
}

void main()
{
clrscr();
int cari,hasil;
cout<<”masukkan data yang ingin dicari = “;
cin>>cari;
hasil = binary_search(cari);
if(hasil == 1)
{
cout<<”Data ada!”<<endl;
}
else
if(hasil == 0)
cout<<”Data Tidak ada!”<<endl;
getch();
}

contoh program searching (sequential) pada c++ :

#include <iostream.h>
#include <conio.h>
void main()
{
clrscr();
int data[8] = {8,10,6,-2,10,7,1,100};
int cari,index;
int ketemu=0;
cout<<”masukkan data yang ingin dicari = “;
cin>>cari;
for(int i=0;i<8;i++)
{
if(data[i] == cari)
{
ketemu=1;
index = i;
break;
}
}
if(ketemu == 1)
{
cout<<”Data ada!”<<endl;
cout<<”Data terletak di index ke – “<<index;
}
else cout<<”Data Tidak ada!”<<endl;
getch();
}

 
1 Comment

Posted by on 7 December 2010 in Algotima C++

 

Algortima POINTER

Penjelasan tentang pointer
pointer adalah built-in type di C dan C++, dimana C++ mengambil konsep pointer dari C. Pointer sebenarnya sangat terkait dengan “Abstract C Machine”, yaitu model mesin abstrak dimana program C bekerja. Abstract C Machine adalah mesin abstrak dimana mesin tersebut memiliki prosesor untuk menginterpretasikan stream of instruction, dan addressable memory yang terbagi kedalam 3 bagian : automatic memory, static memory dan free memory. Addressable memory adalah memory yang konten-nya dapat diambil jika diketahui alamatnya. Lebih jauh lagi, terdapat asumsi bahwa konten memori dapat di ambil dengan waktu konstan, tidak peduli berapa nilai alamat.Hal ini disebut dengan Random Access Memory.

— Penggunaan Awal Pointer
Jika variabel merupakan isi memori, dan untuk mengakses isi memori tersebut diperlukan address, lalu bagaimana cara kita mengetahui alamat dari suatu variabel ? Jawabannya adalah : untuk kebanyakan kasus kita sama sekali tidak perlu tahu alamat dari sebuah variabel. Untuk mengakses sebuah variabel kita hanya perlu nama dari variabel tersebut. Tugas kompiler lah yang mentranslasikan nama ke alamat mesin yang diperlukan oleh komputer.

Akan tetapi terdapat beberapa kasus dimana kita tidak mungkin memberi nama pada sebuah entitas di program kita. Hal ini terjadi terutama saat kita menggunakan data struktur dinamis seperti linked list, resizeable array, tree dan lain sebagainya. Hal ini karena kita tidak mungkin memberi nama terhadap entitas yang mungkin ada atau tidak ada. Struktur seperti linked list hampir mustahil dibuat tanpa pointer tanpa harus mendefinisikan LISP-like list.

Inilah awal mula penggunaan pointer sebagai moniker. Istilah moniker di sini berarti sesuatu yang menunjuk atau mengacu kepada entitas lain. Istilah moniker ini bukanlah istilah standard dan lazim , tetapi sesuatu yang saya pilih impromptu untuk membedakan dengan pointer atau reference yang sudah memiliki arti tersendiri.

Penggunaan lain pointer sebagai moniker adalah untuk mengatasi kelemahan bahasa C awal : Dahulu fungsi – fungsi di C hanya mengerti pass by value. Pointer digunakan untuk mengemulasi pass by reference karena pointer berisi alamat ke objek lain, sehingga fungsi tersebut dapat mengubah objek tersebut dengan memanipulasi pointer.

Pertanyaanya : siapa yang bertugas menentukan alamat objek yang di tunjuk oleh pointer dalam kasus ini ? jelas bukan kompiler karena objek tersebut tidak bernama. Apakah kita sebagai programmer menentukannya sendiri ? ternyata tidak. Hal tersebut ditentukan oleh fungsi malloc dan sejenisnya (dan juga new di C++), atau untuk kasus passing pointer ke dalam fungsi, operator &. Jadi dalam hal ini kita tidak juga menentukan alamat sebuah objek.

— Builtin Array di C dan C++
Sebelum membahas array di C dan di C++, ada baiknya kita membahas tentang array. Array adalah asosiasi antara sebuah index dengan nilai. Jika diketahui sebuah index, kita akan mengetahui nilainya. Dari definisi ini :
1. Tidak disebutkan bahwa index harus integer, atau tipe tertentu.
2. Tidak disebutkan range dari indexnya dimulai dari nilai tertentu, Bahkan tidak disebutkan bahwa indeks nya memiliki batas bawah maupun batas atas.
3. Tidak disebutkan bahwa nilai harus disimpan secara contigous, bahkan tidak disebutkan bahwa nilainya harus di simpan sama sekali.

akan tetapi :
1. Banyak bahasa pemrograman yang di desain tahun 60-an hingga tahun 70-an menentukan bahwa index array adalah integer atau sesuatu yang bisa dikonversi menjadi integer atau sesuatu yang memiliki nilai berurutan seperti integer.

2. Beberapa bahasa menentukan bahwa array dimulai dengan

 
Comments Off

Posted by on 7 December 2010 in Algotima C++

 

Contoh Program C++ LINKED LIST

Linked list (list bertaut) adalah salah satu struktur data dasar yang sangat fundamental dalam bidang ilmu komputer. Dengan menggunakan linked list maka programmer dapat menimpan datanya kapanpun dibutuhkan. Linked list mirip dangan array, kecuali pada linked list data yang ingin disimpan dapat dialokasikan secara dinamis pada saat pengoperasian program (run-time).

Linked List sering disebut juga Senarai Berantai
Linked List saling terhubung dengan bantuan variabel pointer

Masing-masing data dalam Linked List disebut dengan node (simpul) yang menempati alokasi memori secara dinamis dan biasanya berupa struct yang terdiri dari beberapa field.

Operasi-Operasi yang ada pada Linked List
Insert
Istilah Insert berarti menambahkan sebuah simpul baru ke dalam suatu linked list.
IsEmpty
Fungsi ini menentukan apakah linked list kosong atau tidak.
Find First
Fungsi ini mencari elemen pertama dari linked list
Find Next
Fungsi ini mencari elemen sesudah elemen yang ditunjuk now
Retrieve
Fungsi ini mengambil elemen yang ditunjuk oleh now. Elemen tersebut lalu dikembalikan oleh fungsi.
Update
Fungsi ini mengubah elemen yang ditunjuk oleh now dengan isi dari sesuatu
Delete Now
Fungsi ini menghapus elemen yang ditunjuk oleh now. Jika yang dihapus adalah elemen pertama dari linked list (head), head akan berpindah ke elemen berikut.
Delete Head
Fungsi ini menghapus elemen yang ditunjuk head. Head berpindah ke elemen sesudahnya.
Clear
Fungsi ini menghapus linked list yang sudah ada. Fungsi ini wajib dilakukan bila anda ingin mengakhiri program yang menggunakan linked list. Jika anda melakukannya, data-data yang dialokasikan ke memori pada program sebelumnya akan tetap tertinggal di dalam memori.

Operasi-operasi untuk Stack dengan Linked List
IsEmpty
Fungsi memeriksa apakah stack yang adamasih kosong.
Push
Fungsi memasukkan elemen baru ke dalam stack. Push di sini mirip dengan insert dalam single linked list biasa.
Pop
Fungsi ini mengeluarkan elemen teratas dari stack.
Clear
Fungsi ini akan menghapus stack yang ada.

Operasi-operasi Queue dengan Double Linked List
IsEmpty
Fungsi IsEmpty berguna untuk mengecek apakah queue masih kosong atau sudah berisi data. Hal ini dilakukan dengan mengecek apakah head masih menunjukkan pada Null atau tidak. Jika benar berarti queue masih kosong.
IsFull
Fungsi IsFull berguna untuk mengecek apakah queue sudah penuh atau masih bisa menampung data dengan cara mengecek apakah Jumlah Queue sudah sama dengan MAX_QUEUE atau belum. Jika benar maka queue sudah penuh.
EnQueue
Fungsi EnQueue berguna untuk memasukkan sebuah elemen ke dalam queue (head dan tail mula-mula meunjukkan ke NULL).
DeQueue
Procedure DeQueue berguna untuk mengambil sebuah elemen dari queue. Hal ini dilakukan dengan cara menghapus satu simpul yang terletak paling depan (head).

Single Linked List Circular

Single Linked List Circular (SLLC) adalah Single Linked List yang pointer nextnya menunjuk pada dirinya sendiri. Jika Single Linked List tersebut terdiri dari beberapa node, maka pointer next pada node terakhir akan menunjuk ke node terdepannya.

Pengertian:
Node : rangkaian beberapa simpul
Single : artinya field pointer-nya hanya satu buah saja dan satu arah.
Linked List : artinya node-node tersebut saling terhubung satu sama lain.
Circular : artinya pointer next-nya akan menunjuk pada dirinya sendiri sehingga berputar

Deklarasi:
Deklarasi node dibuat dari struct berikut ini:
typedef struct TNode{
int data;
TNode *next;
};

Pembentukan node baru
Digunakan keyword new yang berarti mempersiapkan sebuah node baru
berserta alokasi memorinya.

TNode *baru;
baru = new TNode;
baru->data = databaru;
baru->next = baru;

Dibutuhkan satu buah variabel pointer: head
Head akan selalu menunjuk pada node pertama
Penambahan data di depan
Penambahan node baru akan dikaitan di node paling depan, namun pada saat pertama kali (data masih kosong), maka penambahan data dilakukan pada head nya.
Pada prinsipnya adalah mengkaitkan data baru dengan head, kemudian head akan menunjuk pada data baru tersebut sehingga head akan tetap selalu menjadi data terdepan. Untuk menghubungkan node terakhir dengan node terdepan dibutuhkan pointer bantu.

Penambahan data di depan

void insertDepan(int databaru){
TNode *baru,*bantu;
baru = new TNode;
baru->data = databaru;
baru->next = baru;
if(isEmpty()==1){
head=baru;
head->next=head;
}
else {
bantu = head;
while(bantu->next!=head){
bantu=bantu->next;
}
baru->next = head;
head = baru;
bantu->next = head;
}
printf(”Data masuk\n“);
}
Penambahan data di belakang
Penambahan data dilakukan di belakang, namun pada saat pertama kali data langsung ditunjuk pada head-nya.
Penambahan di belakang lebih sulit karena kita membutuhkan pointer bantu untuk mengetahui data terbelakang, kemudian dikaitkan dengan data baru. Untuk mengetahui data terbelakang perlu digunakan perulangan.

Penambahan data di belakang

void insertBelakang (int databaru){
TNode *baru,*bantu;
baru = new TNode;
baru->data = databaru;
baru->next = baru;
if(isEmpty()==1){
head=baru;
head->next=head;
}
else {
bantu = head;
while(bantu->next != head){
bantu=bantu->next;
}
bantu->next = baru;
baru->next = head;
}
printf(”Data masuk\n“);
}

Operasi Penghapusan

Penghapusan node dilakukan dengan memutus rantai node kemudian menghapus node. Jika node berada di tengah rangkaian, rangkaian yang terputus perlu disambung kembali. Untuk memudahkan penghapusan simpul dibutuhkan dua cursor sebagai simpul bantu. Selain cursor juga dibutuhkan simpul head sebagai acuan awal simpul dalam rangkaian.

Berikut langkah langkah untuk menghapus simpul dalam rangkaian:

  • Buat cursor bantu yang menunjuk ke awal node(simpul).
  • Pindahkan cursor ke node berikutnya
  • Putus sambungan awal node dengan node berikutnya.
  • Hapus rangkaian
  • Jika berada di akhir rangkaian, putuskan dari rangkaian sebelumnya
  • Jika di tengah rangkaian, pindahkan penunjukan node berikutnya, atau di akhir, atau setelah node yang akan dihapus

Ilustrasi Hapus Depan

void hapusDepan (){
TNode *hapus,*bantu;
if (isEmpty()==0){
int d;
hapus = head;
d = head->data;
if(head->next != head){
bantu = head;
while(bantu->next!=head){
bantu=bantu->next;
}
head = head->next;
delete hapus;
bantu->next = head;
}else{
head=NULL;
}
printf(“%d terhapus\n“,d);
} else printf(”Masih kosong\n“);
}

Ilustrasi Hapus Belakang

void hapusBelakang(){
TNode *hapus,*bantu;
if (isEmpty()==0){
int d;
hapus = head;
if(head->next == head){
head = NULL;
}else{
bantu = head;
while(bantu->next->next != head){
bantu = bantu->next;
}
hapus = bantu->next;
d = bantu->data;
bantu->next = head;
delete hapus;
}
printf(“%d terhapus\n“,d);
} else printf(”Masih kosong\n“);
}

semoga tulisan ini dapat bermanfaat bagi anda yang membutuhkanya

 
5 Comments

Posted by on 7 December 2010 in Algotima C++

 
 
Follow

Get every new post delivered to your Inbox.