Sabtu, 14 Januari 2012

Guru vs Master


Perbedaan antara Guru dan Master

Kebanyakan dari kita bingung tentang kata-kata guru dan masterKedua meskipun,memberikan pengetahuan kepada murid mereka, namun berbeda dalam peran dan alam.Seorang guru mengajarkan subjek sedangkan master telah memperoleh keahlian dalamsubjek tertentu. Master khususnya dari seni rupaseni bela diri, seni pertunjukan seperti musik, tari dan olahraga. Mereka tidak perlu mengajar subjek. Seorang guru dalam rangka untuk mendapatkan kecakapan dalam bidang harus menguasai tetapi masterdapat menjadi guru atau tidakPengajaran pengikutnya atau murid adalah semata-matadidasarkan pada kebijaksanaannya. Seorang master percaya dalam berbagi pengetahuan ia telah memperoleh dan berkonsultasi dengan banyak murid atau guruuntuk pemahaman yang lebih baik dari subjek.
Dalam olahragamereka juga mempertimbangkan dan jangka pemain sangat baiksebagai masterMisalnya, Anda mungkin pernah mendengar tentang pemain kriket IndiaSachin Tendulkar dikenal sebagai Guru Kecil. Catur adalah salah satu permainan sepertidi mana judul master diakui sebagai salah satu pencapaian terbesarSeorang mastertidak diragukan lagi merupakan ahli dalam cabang pengetahuan-Nya sementara gurumengajar di sekolah atau perguruan tinggi tentang apa yang telah ia pelajari dalam aliranitu.
Seorang master pameran pengetahuannya dengan tulisan-tulisan, kuliah atau pertunjukandan tidak seperti guru, tidak selalu dengan tujuan menanamkan pengetahuan murni.Sebagai contohseorang musisi dapat menulis sebuah buku tentang belajar dan tidakdapat mengajar orang lain tentang bidangnya. Demikian pulaatlet suatu pameranketerampilan dalam tanah dan disebut master karena penampilannyaSeorang gurumungkin namun mengajarkan musik dan seni, tetapi tidak perlu menjadi pemain yang baikJaditidak mengherankan bahwa Anda mungkin telah mengamati bahwa ketika datang ke musik dan tari, kita bisa menemukan guru-guru yang mengajar tetapi tidak melakukan dan ada pemain yang melakukan tetapi tidak mengajar.

Program C++ : penjelasan Step 1 dan step 2


1.    penjelasan Step 1
Class node                                                    :nama kelas = node
Public:
Nilai : bertipe integer
Node selanjutnya
Node sebelumnya
Class dlist                                                      :nama kelas dlist
Public:
Node *front                                                    : menunjuk ke listterdepan
Node *back                                                   :menunjuk listyang paling belakang
Dlist()                                                             :fungsi Dlist
Depan                                                          
Belakang                                                      


Fungi insertFront(int value)  :berfungsi untuk menambahkan node yang didepan
Fungsi insertBack(int value) : berfungsi untuk menambahkan node yang dibelakang
Fungsi removeFront ()          : berfungsi menghapus node didepan
Fungsi removeBack()            :berfungsi menghapus node dibelakang
Fungsi insertBefore(int value, node *nodeB): berfungsi memasukkan sebelum nilai value
Fungsi insert:fter(int value, node *node:) : berfungsi memasukkan sesudah nilaivalue
Fungsi removeBefore(node *nodeB)       : menghapus node sebelum node B
Fungsi remove:fter(node *node:)              :menghapus node sesudah node
Fungsi removenode(node *newNode)    :menghapus new Node
Fungsi printDlistFront()                              :untuk mencetak dlist depan
Fungsi printDlistBack()                              : untuk mencetak dlist akhir

Jadi dalam step 01 berisi fungsi yang terdapat pada double link list yang nantinya akan dipanggil difungsi main dan seluruh fungsi operasi-operasi yang akan dijalankan pada program tersebut.

2.   Penjelasan step 2
Class dan fungsinya sama seperti step 01, tetapi ada penjelasan dari beberapa fungsi dan langkah operasinya.

Menambah node di depan:
Void dlist::insertFront(int value)
Node *newnode                                                       : untuk node baru
newNode=new node()                                            : node baru=fungsi new node
this ->front=newNode                                             : pointer depan menunjuk newNode
this <-back=newNode                                             : pointer belakang menunjuk newNode
newNode:prev=Null                                                 :pointer awal dan akhir bernilai 0
newNode:next =Null
newNode:value=value                                                       : elemen value disisipkanke newNode value menampilkan elemen double link list dari depan

void dlist::printDlistFront()
node*curr 2
curr2 =this:front                                            :pointer curr 2 dimulai dari depan
while(curr2!=NULL) {                                   : menampilkan isi  link list curr2
cout<<" |"<<curr2->value<<"|";
curr2=curr2->next;
            }

Main fu ction()
dlist *st ;                                                         : memanggil kelas Dlist dg variabel st
            st= new dlist();         
st->insertFront(1)     ;                                   : memasukan nilai 1 pada fungsi tambah depan
            st->printDListFront ();                      : mencetak link list
st->insertFront(2) ;
            st->printDListFront ()

Stuktur Data : Menggabungkan 2 Queen menjadi 1 !


Definisi Queue
Jika diartikan secara harafiah, queue berarti antrian, queue merupakan salah satu contoh aplikasi dari pembuatan double linked list yang cukup sering kita temui dalam kehiduypan sehari-hari, misalnya saat Anda mengantri di loket untuk membeli tiket. Istilah yang cukup sering dipakai seseorang masuk dalam sebuah antrian adalah enqueue. Dalam suatu antrian, yang dating terlebih dahulu akan dilayani lebih dahulu. Istilah yang sering dipakai bila seseorang keluar dari antrian adalah dequeue. Walaupun berbeda implementasi, struktur data queue setidaknya harus memiliki operasi-operasi sebagai berikut :
  • EnQueue Memasukkan data ke dalam antrian
  • DeQueue Mengeluarkan data terdepan dari antrian
  • Clear Menghapus seluruh antrian
  • IsEmpty Memeriksa apakah antrian kosong
  • IsFull Memeriksa apakah antrian penuh
Berikut ini adalah Implementasi Dalam C++
cekidot ^^
#include <iostream.h>
#include <conio.h>
#define maks 10

class queue{
      friend ostream& operator<<(ostream&, const queue&);
public:
       queue();
       int penuh(int);
       int kosong(int);
       void cetak();
       char enqueue(char);
       char dequeue();
       void bagi(queue &, queue&);
private:
        char A[maks];
        int banyak;};

ostream& operator<<(ostream& out, const queue& s){
         out<<"\nIsi Antrian : ";
         for(int i=0;i<s.banyak;i++)
         out<<s.A[i]<<" ";
         return out;}

queue::queue(){
               banyak=0;
               for(int i=0; i<maks; i++)
               A[i]='0';}

int queue::penuh(int s){
    return s==maks?1:0;}

int queue::kosong(int s){ 
    return s==0?1:0;}

void queue::cetak (){
     cout<<"\nIsi Antrian : ";
     for(int i=0;i<banyak;i++)
     cout<<A[i]<<" ";}

char queue::enqueue(char x){
     if (A[0]=='0'){
        A[0]=x;
        banyak++;}
     else{
          for (int i=banyak; i>=0; i--)
          A[i+1]=A[i];
          A[0]=x;
          banyak++;}}

char queue::dequeue(){
     char temp=A[--banyak];
     A[banyak]='0';
     return temp; }

void queue::bagi(queue &q1, queue &q2){
     char a[5],b[5];
     queue q3;
     cout<<"\n\nAntrian Gabungan";
     for(int i=0;i<5;i++){
     a[i]=q1.dequeue();
     q3.enqueue(a[i]);}
     for(int i=0;i<5;i++){
     b[i]=q2.dequeue();
     q3.enqueue(b[i]);}
     cout<<q3<<endl;}

int main(){
queue p,q,r;
char z[5] = {69,68,67,66,65};
char y[5] = {74,73,72,71,70};
cout<<"Antrian Pertama";
for(int i=5-1;i>=0;i--){
p.enqueue(z[i]);
cout<<p;}
cout<<"\n\nAntrian Kedua";
for(int j=5-1;j>=0;j--){
q.enqueue(y[j]);
cout<<q;}
r.bagi(p,q);
getch();
return 0;}

QUEUE (ANTREAN)

ANTREAN (Queue) 

Suatu bentuk khusus dari linear list, dengan operasi penyisipan (insertion) hanya diperbolehkan pada salah satu sisi, yang disebut REAR, dan operasi penghapusan (deletion) hanya diperbolehkan pada sisi yang lainnya, yang disebut FRONT dari list.

Antrean Q = [Q1, Q2, ... , QN]

  • Front(Q)        = Q1                  bagian depan antrean
  • Rear(Q)          = QN                 bagian belakang antrean
  • Noel(Q)          = N                    jumlah elemen dalam antrean

Operasi Antrean : FIFO (First In First Out)
Elemen yang pertama masuk merupakan elemen yang pertama keluar.

  • Operator :        Penyisipan         : Insert
                              Penghapusan     : Remove
Empat operasi dasar antrean, yaitu :
1.     CREATE 
2.     ISEMPTY 
3.     INSERT 
4.     REMOVE 

·            CREATE (Q)
Operator yang menunjukkan suatu antrean hampa Q.
Berarti :        Noel (Q) = 0
                    Front (Q) & Rear (Q) = tidak terdefinisi

·            ISEMPTY (Q)
Operator yang menunjukkan apakah antrean Q hampa.
Operand          : tipe data antrean
Hasil               : tipe data boolean

ISEMPTY (CREATE (Q)) = True

·            INSERT (E, Q)
Operator yang menginsert elemen E ke dalam antrean Q.
E ditempatkan di bagian belakang antrean.
Hasil : antrean yang lebih besar.

REAR (INSERT (E, Q)) = E
ISEMPTY (INSERT (E, Q)) = False
REMOVE (Q)
Operator yang menghapus elemen bagian depan dari antrean Q.
Hasil : antrean yang lebih pendek.
Pada setiap operasi, Noel (Q) berkurang 1 dan elemen ke-2 menjadi elemen terdepan.
Jika Noel (Q) = 0 maka Q = hampa
       Remove (Q) = kondisi error (underflow condition)
       Remove (Create (Q)) = kondisi error (underflow condition)

PENYAJIAN DARI ANTREAN
1. One Way List (Linear Linked List)
2. Array 

Array Queue
Kalau tidak disebutkan lain, maka Antrean disajikan dalam Array Queue, dilengkapi 2 variabel penunjuk : 
FRONT (elemen depan antrean)
REAR (elemen belakang antrean)


Program C++ : Binary Searh Tree (Pohon struktur data)

Dalam ilmu komputer, sebuah Pohon adalah suatu struktur data yang digunakan secara luas yang menyerupai struktur pohon dengan sejumlah simpul yang terhubung.
Dibawah ini adalah Implementasi dalam program c++ :


cekidot ^^

#include <iostream>
#include <cstdlib>
using namespace std;

class BinarySearchTree
{
    private:
        struct tree_node
        {
           tree_node* left;
           tree_node* right;
           int data;
        };
        tree_node* root;
    public:
        BinarySearchTree()
        {
           root = NULL;
        }
        bool isEmpty() const { return root==NULL; }
        void print_inorder();
        void inorder(tree_node*);
        void print_preorder();
        void preorder(tree_node*);
        void print_postorder();
        void postorder(tree_node*);
        void insert(int);
        void remove(int);
};

void BinarySearchTree::insert(int d)
{
    tree_node* t = new tree_node;
    tree_node* parent;
    t->data = d;
    t->left = NULL;
    t->right = NULL;
    parent = NULL;

  if(isEmpty()) root = t;
  else
  {

    tree_node* curr;
    curr = root;

    while(curr)
    {
        parent = curr;
        if(t->data > curr->data) curr = curr->right;
        else curr = curr->left;
    }

    if(t->data < parent->data)
       parent->left = t;
    else
       parent->right = t;
  }
}

void BinarySearchTree::remove(int d)
{

    bool found = false;
    if(isEmpty())
    {
        cout<<" This Tree is empty! "<<endl;
        return;
    }
    tree_node* curr;
    tree_node* parent;
    curr = root;
    while(curr != NULL)
    {
         if(curr->data == d)
         {
            found = true;
            break;
         }
         else
         {
             parent = curr;
             if(d>curr->data) curr = curr->right;
             else curr = curr->left;
         }
    }
    if(!found)
         {
        cout<<" Data not found! "<<endl;
        return;
    }


    if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL
&& curr->right == NULL))
    {
       if(curr->left == NULL && curr->right != NULL)
       {
           if(parent->left == curr)
           {
             parent->left = curr->right;
             delete curr;
           }
           else
           {
             parent->right = curr->right;
             delete curr;
           }
       }
       else
       {
          if(parent->left == curr)
           {
             parent->left = curr->left;
             delete curr;
           }
           else
           {
             parent->right = curr->left;
             delete curr;
           }
       }
     return;
    }


         if( curr->left == NULL && curr->right == NULL)
    {
        if(parent->left == curr) parent->left = NULL;
        else parent->right = NULL;
                  delete curr;
                  return;
    }


    if (curr->left != NULL && curr->right != NULL)
    {
        tree_node* chkr;
        chkr = curr->right;
        if((chkr->left == NULL) && (chkr->right == NULL))
        {
            curr = chkr;
            delete chkr;
            curr->right = NULL;
        }
        else
        {

            if((curr->right)->left != NULL)
            {
                tree_node* lcurr;
                tree_node* lcurrp;
                lcurrp = curr->right;
                lcurr = (curr->right)->left;
                while(lcurr->left != NULL)
                {
                   lcurrp = lcurr;
                   lcurr = lcurr->left;
                }
                                    curr->data = lcurr->data;
                delete lcurr;
                lcurrp->left = NULL;
           }
           else
           {
               tree_node* tmp;
               tmp = curr->right;
               curr->data = tmp->data;
                              curr->right = tmp->right;
               delete tmp;
           }

        }
         return;
    }

}

void BinarySearchTree::print_inorder()
{
  inorder(root);
}

void BinarySearchTree::inorder(tree_node* p)
{
    if(p != NULL)
    {
        if(p->left) inorder(p->left);
        cout<<" "<<p->data<<" ";
        if(p->right) inorder(p->right);
    }
    else return;
}

void BinarySearchTree::print_preorder()
{
  preorder(root);
}

void BinarySearchTree::preorder(tree_node* p)
{
    if(p != NULL)
    {
        cout<<" "<<p->data<<" ";
        if(p->left) preorder(p->left);
        if(p->right) preorder(p->right);
    }
    else return;
}

void BinarySearchTree::print_postorder()
{
  postorder(root);
}

void BinarySearchTree::postorder(tree_node* p)
{
    if(p != NULL)
    {
        if(p->left) postorder(p->left);
        if(p->right) postorder(p->right);
        cout<<" "<<p->data<<" ";
    }
    else return;
}

int main()
{
    BinarySearchTree b;
    int n,ch,tmp,tmp1;
      cout<<"\tOperasi Pohon KHAIRUDIN \n\n";
    cout<<"Masukkan banyak data: ";
           cin>>n;
                    for (int i=0; i<=n; i++){
                    cout<<"Angka :";cin>>i;
                    b.insert(i);}
                 
                    cout<<"\n\nIn-Order Traversal "<<endl;
                    cout<<"-------------------"<<endl;
                    b.print_inorder();
                  
                    cout<<"\n\nPre-Order Traversal "<<endl;
                    cout<<"-------------------"<<endl;
                    b.print_preorder();
                
                    cout<<"\n\nPost-Order Traversal "<<endl;
                    cout<<"--------------------"<<endl;
                    b.print_postorder();
                    cout<<endl;
                 
           system("pause");
                    return 0;
                 
}