Senin, 29 Oktober 2012

refleksi kuliah struktur data minggu ke 7

pada minggu ke 7,membahas tentang double linked list..
contoh programnya:
#include <iostream>

using namespace std;
class node
{
public:
int value;           //value stored in the node
node *next;          //pointer to next node
node *prev;          //pointer to previous node
};

class dlist
{
public:
node *front;       //pointer to front of list  
node *back;        //pointer to back of list 

dlist()
{
front=NULL;
back=NULL;
}

void insertFront(int value);            
void insertBack(int value);
void removeFront();
void removeBack();
void insertBefore(int value,node *nodeB);
void insertAfter(int value,node *nodeA);
void removeBefore(node *nodeB);
void removeAfter(node *nodeA);
void removeNode(node *newNode);
void printDListFront();
void printDListBack();
};

//insert a node before nodeB
void dlist::insertBefore(int value,node *nodeB)   
{
node *newNode;
newNode=new node();
newNode->prev=nodeB->prev;
newNode->next =nodeB;
newNode->value =value;
if(nodeB->prev==NULL)
{
this->front=newNode;
}
nodeB->prev=newNode;

}

//insert a node before the front node
void dlist::insertFront (int value)
{
node *newNode;
if(this->front==NULL)
{
newNode=new node();
this->front=newNode;
this->back =newNode;
newNode->prev=NULL;
newNode->next=NULL;
newNode->value=value;

}
else
{
insertBefore(value,this->front );
}
}

//insert a node after  nodeB
void dlist::insertAfter(int value,node *nodeB)
{
node *newNode;
newNode=new node();
newNode->next= nodeB->next ;
newNode->prev  =nodeB;
newNode->value =value;

if(nodeB->next==NULL)
{
cout<<"\n "<< endl;
this->back =newNode;
}
nodeB->next=newNode;
cout<<"2"<<endl;
}
//insert a node after the last node
void dlist::insertBack (int value)
{         
if(this->back==NULL)
{
cout<<"insert at back";
insertFront(value);
}
else
{
cout<<"insert at back";
insertAfter(value,this->back  );
}
}

//remove the front node
void dlist::removeFront ()
{
removeNode(this->front);
}

//remove a back node
void dlist::removeBack  ()
{
removeNode(this->back);

}

//remove before a node
void dlist::removeBefore(node *nodeB)
{

if(nodeB->prev==this->front)
{
this->front=nodeB;
this->front->prev=NULL;
}
else
{
removeNode(nodeB->prev);
}
}

//remove after a node
void dlist::removeAfter(node *nodeA)
{
if(nodeA->next==this->back)
{
this->back=nodeA;
this->back->next=NULL;
}
else
{
removeNode(nodeA->next);
}
}

//remove a perticular node
void dlist::removeNode(node *nodeToRemove)
{
if(nodeToRemove==this->front)
{
this->front=this->front->next;
this->front->prev=NULL;
}
else if (nodeToRemove==this->back)
{
this->back=this->back->prev;
this->back->next=NULL ;
}
else
{
nodeToRemove->prev->next=nodeToRemove->next;
nodeToRemove->next->prev=nodeToRemove->prev;
}
}

//Print the list from front
void dlist::printDListFront()
{
node* curr2;
curr2= this->front;
cout<<"\n-----\n";
cout<<"Queue\n";
cout<<"-----\n";
//cout<<"size:"<<getQueueSize()<<endl;
while(curr2!=NULL)
{
cout<<" |"<<curr2->value<<"|";
curr2=curr2->next;
}
cout<<endl;
}// print the Double Linked List from front


// print the Double Linked List from backwards
void dlist::printDListBack()
{
node* curr2;
curr2= this->back;
cout<<"\n-----\n";
cout<<"Queue\n";
cout<<"-----\n";
//cout<<"size:"<<getQueueSize()<<endl;
while(curr2!=NULL)
{
cout<<" |"<<curr2->value<<"|";
curr2=curr2->prev;
}
cout<<endl;
}// print the Double Linked List from back

int main()
{
dlist *st ;
st= new dlist();
st->insertBack(8);
st->printDListFront ();
st->insertBack(5);
st->printDListFront ();
st->insertBack(6);
st->printDListFront ();
st->insertFront(1) ;
st->printDListFront ();
st->insertFront(3) ;
st->printDListFront ();
st->insertBack(7);
st->printDListFront ();
st->removeFront();
st->printDListFront ();
st->removeBack();
st->printDListFront ();


system ("PAUSE");
}
outputnya:


selain diatas,dibahs tentang cara menulis struktur datanya dan algoritmanya.. ditulis dipapan tulis tentang menambah elemen didepan,setelah elemen tertentu,diakhir,dan menghapus elemen tertentu,elemen didepan,dan dibelakang. sekian dulu,,lanjut besok lagi yaaaaaaaaaa????????

refleksi kuliah struktur data minggu ke 6

sore,, pada minggu ke 6 mempelajari operasi CIRCULAR link lis.
ini contoh programnya:
#include <iostream>

using namespace std;

template <class T>
struct Node
{
  T data;
  Node * next;
  Node(T data) : data(data), next(NULL) {} //contruktor
};

template <class T>
class CircularLinkedList
{
public:
  CircularLinkedList() : head(NULL) {}
  ~CircularLinkedList();
  void addNode(T data);
  void deleteNode(T data);
  template <class U>
  friend std::ostream & operator<<(std::ostream & os, const CircularLinkedList<U> & cll);
private:
  Node<T> * head;
};

template <class T>
CircularLinkedList<T>::~CircularLinkedList()
{
  if (head)
    {
      Node<T> * tmp = head;
      while (tmp->next != head)
        {
          Node<T> * t = tmp;
          tmp = tmp->next;
          delete(t);
        }
      delete tmp;
      head = NULL;
    }
}

template <class T>
void CircularLinkedList<T>::addNode(T data)
{
  Node<T> * t = new Node<T>(data);

  if (head == NULL)
    {
      t->next = t;
      head = t;
      return;
    }

  Node<T> * tmp = head;
  while (tmp->next !=  head)
    {
      tmp = tmp->next; //menempatkan pada elemen terakhir/ujung
    }

  tmp->next = t;
  t->next = head; //menunjukkan melingkar
}

template <class T>
void CircularLinkedList<T>::deleteNode(T data)
{
  Node<T> * tmp = head;
  Node<T> * prev = NULL;
  while (tmp->next !=  head)
    {
      if (tmp->data == data) break;
      prev = tmp;
      tmp = tmp->next;
    }

  if (tmp == head)
    {
      while (tmp->next != head)
        {
          tmp = tmp->next;
        }
      tmp->next = head->next;
      delete head;
      head = tmp->next;
    }
  else
    {
      prev->next = tmp->next;
      delete tmp;
    }
}

template <class U>
std::ostream & operator<<(std::ostream & os, const CircularLinkedList<U> & cll)
{
  Node<U> * head = cll.head;
  if (head)
    {
      Node<U> * tmp = head;
      while (tmp->next != head)
        {
          os << tmp->data << " ";
          tmp = tmp->next;
        }
      os << tmp->data;
    }
  return os;
}

int main()
{
  CircularLinkedList<int> cll;

  cll.addNode(1);
  cll.addNode(2);
  cll.addNode(3);
  cll.addNode(4);
  cll.addNode(5);

  cout << cll << endl;

  cll.deleteNode(3);
  cll.deleteNode(1);
  cll.deleteNode(5);

  cout << cll << endl;

  system("PAUSE");
}

outputnya:



itulah sekiranya program yang dipelajari minggu ke 6,namun di minggu ke 6 ini dijelaskan pula cara menulis struktur datanya. perintah mencari elemen tertentu,menambah,dah mencetak semua,, cukup paham, oke terimakasih.. :)

refleksi kuliah struktur data minggu ke 5

assalamu'alaikum wr wb..
sore teman2, langsung saja ya.. buat feleksi minggu ke 5 ini membahas tentang Operasi Link List.
menjalankan program menggunakan borland
 #include <iostream.h>
#include "chain.h"

void main(void)
{
   try {
      Chain<int> L;
      cout << "Length = " << L.Length() << endl;
      cout << "IsEmpty = " << L.IsEmpty() << endl;
      L.Insert(0,2).Insert(1,6);
      cout << "List is " << L << endl;
      cout << "IsEmpty = " << L.IsEmpty() << endl;
      int z;
      L.Find(1,z);
      cout << "First element is " << z << endl;
      cout << "Length = " << L.Length() << endl;
      L.Delete(1,z);
      cout << "Deleted element is " << z << endl;
      cout << "List is " << L << endl;
      }
   catch (...) {
      cerr << "An exception has occurred" << endl;
      }
}

setelah itu menjelaskan:
 a. Chain<T>& Insert(int k, const T& x); //digunakan untuk menyisipkan elemen x sesudah posisi ke k
   b. int Find(int k, T& x) const; // jika elemen ke k di set ke x,tetapi jika ada
   c. int Search(const T& x) const; //digunakan untuk mengembalikan letak(posisi) elemen x
   d. Chain<T>& Delete(int k, T& x); //digunakan untuk mengeset elemen ke k pada x,kemudian dihapus
   e. int Length() const; //digunakan untuk menghitung banyaknya elemen pada linier list

itulah yg dipelajari dikelas..
diakhir pertemuan diberi penjelasan jg tentang menghitung polinomial menggunakan array..

Jumat, 12 Oktober 2012

refleksi kuliah struktur data minggu ke 4

halooo haloo sudah minggu ke 4 ini.. :|
diminggu ini minimal harus ngumpulin uji kompetensi sampe minggu ke 3,trus  ngumpulin judul TP juga.
nih lhoo dijelasin gambar kyak gini,,
minggu ini bahannya tentang "MENGGAMBAR" iyaa disuruh "MENGGAMBAR" bukan malah "MENULIS" :O maksudnya ya menggambar pointer itu. menggambar macam-macam aplikasi link list,cara mengetahui isi link list,menghapus elemen pertama,dan menghapus elemen terakhir. Minggu ini membahas tentang pointer dan linked list.
Pointer merupakan salah satu data terstruktur.Dengan menggunakan pointer,suatu variabel dapat diciptakan 
atau dihapus selama pengeksekusian program. variabel pointer bukan berisi data.
nah,, itu sedikit penjelasannya,, cukup mudeng..
sekian,,

refleksi Kuliah Struktur Data minggu ke-3

selamat pagiii,, walau nulisnya malam,tp kan kuliahnya pagi,, :)
ini refleksi kuliah struktur data minggu ke 3, membahas tentang Array Statis dan Dinamis. 

Array statis itu tidak dapat diubah lagi banyaknya tempat penyimpanan, array statis merupakan pointer.
sedangkan Array dinamis  bisa  mengubah banyaknya elemen yang dapat disimpan, dan dapat mengembangkan array dinamis dengan menggunakan pointer.

skenarionya ada pada http://tif.uad.ac.id/new_forum/index.php?topic=1325.0 

salah satu program yg kami coba seperti ini
#include<cstdlib>
#include<iostream>
//#include 'xcept.h'

using namespace std;

//template
class Array1D {
      friend ostream& operator<<(ostream&, const Array1D&);
      //friend istream & operator >> (istream&, Array1D&);

public :     
       Array1D ( int size= 0);
       Array1D ( const Array1D& v);
       ~Array1D (){delete [] element;}
       int& operator [] (int i) const;
       int Size() {return size;}
       Array1D & operator = (const Array1D& v);
       Array1D  operator + ()const;
       Array1D  operator + (const Array1D& v)const;
       Array1D  operator - ()const;
       Array1D  operator - (const Array1D& v) const;
       Array1D  operator * (const Array1D& v) const;
       Array1D & operator+=(const int& x);
       Array1D & ReSize(int sz);
       void geser_kiri();
       void geser_kanan();

private :
       int size ;
        int * element ;
};   

//template
Array1D::Array1D(int sz)
{
 if ( sz < 0);
 size = sz;
 element = new int[sz];
}

//template
Array1D::Array1D(const Array1D& v)
{
 size = v.size;
 element =new int[size]; // get space
 for (int i=0; i
 element[i] = v.element[i];
}

//template
 int& Array1D::operator[](int i)const
{
   if(i<0||i>=size); //throw OutOfBounds();
   return element[i];
}

//template
 Array1D & Array1D::operator =(const Array1D& v)
 {
   if (this != &v){
            size= v.size;
            delete[] element;
            element = new int[size];
            for (int i=0; i< size; i++)
            element [i] = v.element[i];
            }
            return *this;
            }

 //template
 Array1D Array1D::operator +(const Array1D& v) const
 {
  if (size != v.size); //throw SizeMismatch();
  Array1D w(size);
  for(int i=0; i < size; i++)
  w.element[i] = element[i] + v.element [i];
  return w;
}

//template
Array1D Array1D::operator-(const Array1D& v) const
{
 if (size!= v.size); //throw SizeMistach();
 Array1D w(size);
 for (int i=0; i
 w.element[i] = element [i]- v.element [i];
 return w;
}

//template
Array1D Array1D::operator-() const
{
 Array1D w(size);
 for (int i=0; i
 w.element[i] = -element[i];
 return w;
}

//template
Array1D Array1D::operator*(const Array1D& v)const
{
 if (size != v.size);//throw SizeMistach();
 Array1D w(size);
 for(int i=0; i < size; i++)
 w.element[i] = element [i] * v.element[i];
 return w;
}

//tempalte
Array1D& Array1D::operator+=(const int& x)
{
 for (int i=0; i < size; i++)
 element [i] += x;
 return *this;
}

//tempalte
ostream& operator <<( ostream& out, const Array1D& x)
{
 for (int i=0; i
 out << x.element[i] << " ";
 return out;
}

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

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

//template
Array1D& Array1D::ReSize(int sz)
{
 if (sz < 0);//throw BadInitializer();
 delete [] element;
 size = sz;
 element = new int [size];
 return *this;
}                     

int main(int argc, char *argv[])
{
    try {
        Array1D X(10),Y,Z;
        for (int i=0; i<10; i++)
        X[i] = i;
        cout <<"X[3]=" << X[3] << endl;
        cout <<"X is " << X << endl;
        Y=X;
        cout <<"Y is " << Y << endl;
        X +=2;
        cout <<"X incremented by 4 is " << X << endl;
        Z = (Y+X)*Y;
        cout << "(Y + X)* Y is" << Z << endl;
        cout << "-(Y + X)* y is" << -Z << endl;
              Z.geser_kiri();
              cout<<"isi Array seteleh digeser ke kiri;"<<
              Z.geser_kanan();
              cout<<"Isi Array setelah digeser ke kanan:"<<        
        }
        catch (...) {
              cerr << "An execption has occurred" << endl;}

              system("PAUSE");
              return EXIT_SUCCESS;
        }