praktikum

PRAKTIKUM KE-1

<POST TEST>

ini adalah postes praktikum pertama saya dalam kelas struktur data ini. dalam postes ini temen – temen sekalian dapat belajar tentang struktur – struktur kelas, operator – operator overloading nya. selamat mencoba!!

#include <cstdlib>
#include <iostream>

using namespace std;

class Bilangan{
friend ostream& operator<<(ostream&, const Bilangan&);
friend istream& operator>>(istream&, Bilangan&);
public :
Bilangan(int a0=0, float b0=0.0) : a(a0), b(b0) { }
void banding_int(const Bilangan&, const Bilangan&);
Bilangan& operator=(const Bilangan&);
Bilangan operator+(const Bilangan&) const;
Bilangan operator-()const;
private:
int a;
float b;
};

ostream& operator<<(ostream& out, const Bilangan& x){
out << “Bagian integer : ” << x.a << endl;
out << “Bagian float   : ” << x.b << endl;
return out;
}

void Bilangan::banding_int(const Bilangan& x, const Bilangan& y)
{
if (x.a > y.a) cout << x.a << “::x lebih besar dari ” << y.a << “::y”;
else cout << x.a << “::x lebih kecil dari ” << y.a << “::y”;
}

Bilangan& Bilangan::operator=(const Bilangan& x)
{   a = x.a;
b = x.b;
return *this;
}

istream& operator>>(istream& in, Bilangan& x)
{
cout <<“\nMasukkan bagian integer : “;
in >> x.a;
cout <<“Masukkan bagian float   : “;
in >> x.b;
return in;
}

Bilangan Bilangan::operator+(const Bilangan& x) const
{   Bilangan cc;
cc.a = a + x.a;
cc.b = b + x.b;
return cc;
}

Bilangan Bilangan::operator-() const
{   Bilangan x;
x.a = -a;
x.b = -b;
return x;
}

int main(int argc, char *argv[])
{
Bilangan s, t(-2,3.14), d;
cout << “Nilai awal s\n” << s;
cout << “Nilai awal t dari deklarasi\n” << t;
s = t;
cout << “Setelah s di-assign t\n”;
cout << “Nilai s\n” << s;
cout << “Masukkan nilai-nilai objek d”;
cin >> d;
cout << “Setelah d + t => \n” << d+t;
cout << “Nilai d dinegatifkan\n” << -d;

system(“PAUSE”);
return EXIT_SUCCESS;
}

nalisis output program:
1. dalam program tersebut disajikan nilai awal s(0.0) dan t(-2,3.14) yang masing-masing bertipe integer dan float

ostream& operator<<(ostream&out, const Bilangan& x)
{
out<<”Bagian integer: “<<x.a<<endl;
out<<”Bagian float: “<<x.b<<endl;
return out;
}
void Bilangan::banding_int(const Bilangan& x, const Bilangan&y)
{
if(x.a>y.a)cout <<x.a<<”::x lebih besar dari “<<y.a<<”::y”;
else cout<<x.a<<”::x lebih kecil dari ” <<y.a<<”::y”;
}
Bilangan& Bilangan::operator=(const Bilangan& x)
{a=x.a;
b=x.b;
return*this;
}
2.menginputkan nilai d
istream& operator>>(istream& in, Bilangan& x)
{
cout<<”\n Masukkan bagian integer:”;
in>>x.a;
cout<<”Masukkan bagian float:”;
in>>x.b;
return in;
}
3.kemudian nilai d ditambah dengan t
Bilangan Bilangan::operator+(const Bilangan& x) const
{ Bilangan cc;
cc.a=a+x.a;
cc.b=b+x.b;
return cc;
}
4.hasil akhir nilai d dinegatifkan
Bilangan Bilangan::operator-()const
{ Bilangan x;
x.a = -a;
x.b = -b;
return x;
}

jawaban postes
a. kelas:
program di atas tersebut merupakan kelas bilangan
class Bilangan{

};
b. kontruktor :terdapat 5 konstruktor yaitu:
Bilangan(int a0=0, float b0=0.0): a(a0),b(b0){}
void banding_int(const Bilangan&, const Bilangan&);
Bilangan& operator=(const Bilangan&);
Bilangan operator+(const Bilangan&) const;
Bilangan operator-()const;
c. method : dalam kelas tersebut terdapat 1 method yaitu
int main(int argc, char *argv[])
{
Bilangan s,t(-2,3.14),d;
cout<<”Nilai awal sn” <<s; //operator biner<<output
cout<<”Nilai awal t dari deklarasin”<<t;
s = t;                      // operator biner=
cout <<”Setelah s di-assign tn”;
cout <<”Nilai sn”<<s;
cout<<”Masukkan nilai-nilai objek d”;
cin>>d;                     //operator>>input
cout<<”Setelah d+t=>n”<<d+t; //operator biner+
cout<<”Nilai d dinegatifkann”<<-d; //operator biner-
d. data member :
terdapat 2 data member yaitu a bertipe int dan b bertipe float
e. operator overloading:
friend ostream& operator<<(ostream&,const Bilangan&);
friend istream& operator>>(istream&, B

PRAKTIKUM  KE-2

<POSTEST>

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

template <class T>
class Kompleks{
friend class Operasi<T>;
friend ostream& operator<<(ostream&, const Kompleks<T>&);
friend istream& operator>>(istream&, Kompleks<T>&);
public :
Kompleks(T s=0,T t=0):a(s),b(t){}
void cetak();
Kompleks operator-();
Kompleks operator-(const Kompleks<T>&);
Kompleks operator+(const Kompleks<T>&);
private :
T a;
T b;
};

template <class T>
void Kompleks<T>::cetak()
{
if(b>0) cout<<“bilangan kompleks :”<<a<<“+”<<b<<“i”;
else cout<<“bilangan kompleks: “<<a<<b<<“i”;
cout<<endl;
}

template <class T>
Kompleks<T> Kompleks<T>::operator-()
{ Kompleks x;
x.a=a;
x.b=-b;
return x;
}

template <class T>
Kompleks<T> Kompleks<T>::operator-(const Kompleks<T>& m)
{Kompleks x;
x.a=a-m.a;
x.b=b-m.b;
return x;
}

template <class T>
Kompleks<T> Kompleks<T>::operator+(const Kompleks<T>& m)
{ Kompleks x;
x.a=a+m.b;
x.a=b+m.b;
return x;
}

template<class T>
ostream& operator<<(ostream& out, const Kompleks<T>& x){
if(x.b==0)out<<“[“<<x.a<<“]”;
else if(x.a==0&&x.b==1)out<<“[“<<“i”<<“]”;
else if(x.a==0&&x.b==-1)out<<“[“<<“-i”<<“]”;
else if(x.a==0&&x.b>1)out<<“[“<<x.b<<“i”<<“]”;
else if(x.a==0&&x.b<-1)out<<“[“<<x.b<<“i”<<“]”;
else if(x.b==1)out<<“[“<<x.a<<“+”<<“i”<<“]”;
else if(x.b>0)out<<“[“<<x.a<<“+”<<x.b<<“i”<<“]”;
else if(x.b==-1)out<<“[“<<x.a<<“-i”<<“]”;
else out<<“[“<<x.a<<“i”<<“]”;
return out;
}

template <class T>
istream& operator>>(istream& in, Kompleks<T>& x){
cout<<“masukan bilangan real : “;
in>>x.a;
cout<<“masukan bagian imajiner :”;
in>>x.b;
return in;
}

template <class T>
class Operasi{
public :
Kompleks<T>jumlah(const Kompleks<T>&, const Kompleks<T>&);
Kompleks<T>kali(const Kompleks<T>&, const Kompleks<T>&);
Kompleks<T>kurang(const Kompleks<T>&, const Kompleks<T>&);
};

template <class T>
Kompleks<T> Operasi<T>::jumlah(const Kompleks<T>& m, const Kompleks<T>& n)
{ Kompleks<T>temp;
temp.a=m.a+n.a;
temp.b=m.b+n.b;
return temp;
}

template <class T>
Kompleks<T> Operasi<T>::kurang(const Kompleks<T>& m, const Kompleks<T>& n)
{ Kompleks<T>temp;
temp.a=m.a-n.a;
temp.b=m.b-n.b;
return temp;
}

template <class T>
Kompleks<T> Operasi<T>::kali(const Kompleks<T>& m, const Kompleks<T>& n)
{ Kompleks<T>temp;
temp.a=(m.a*n.a)-(m.b*n.b);
temp.b=(m.a*n.b)-(m.b*n.a);
return temp;
}

int main(){
Kompleks<int> x(2,3),y(4,-4),t;
Operasi<int>z;
cout<<“menggunakan cetak() : “; x.cetak();
cout<<“menggunakan overloading : “<<x;
cout<<“konjugat”<<-x;
y.cetak();
cout<<“\n penjumlahan menggunakan methods: “;
t=z.jumlah(x,y);
t.cetak();
cout<<“penjumlahan menggunakan operator : “;
t=x+y;
cout<<x<<“+”<<y<<“=”<<t;
cout<<“\n Perkalian menggunakan methods : “;
t=z.kali(x,y);
t.cetak();
cout<<“\n Perkalian menggunakan operator : “;
//t=x*y;
cout<<x<<“*”<<y<<“=”<<t;
t=x-y;
cout<<“\n”<<x<<“-“<<y<<“=”<<t<<endl;
Kompleks<int>n;
cin>>n;
cout<<n;
return 0;
}

 

 

 

 

 

 

Dalam praktikum kedua ini yang dipelajari masih tentang operator overloading, hanya saja semua itu dibungkus menggunakan template. untuk pengertian template sendiri bisa dilihat di halaman utama blog ini.

 

PRAKTKUM KE- 3

Ini adalah pretes dan postes Praktikum ke-3 (Inheritance)

<PRETES>

class Bil_float : public Bilangan {
friend istream& operator>>(istream&, Bil_float&);
friend ostream& operator<<(ostream&, const Bil_float&);
private :
float a;
public :
Bil_float(float x=0.0) : a(x){}
void banding_float(const Bil_float& y, const Bil_float& z){
if(y.a>z.a) cout<<y.a<<“:: y lebih besar dari “<<z.a<<“::z”;
else cout<<y.a<<“::y lebih kecil dari”<<z.a<<“::z”;
}
};

istream& operator>>(istream& in, Bil_float& masuk){
cout<<“masukan bilangan”; in>>masuk.a;
return in;
}

ostream& operator<<(ostream& out, const Bil_float& keluar){
out<<“tampilkan bilangan”<<keluar.a;
return out;
}

<POSTES>

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

class Bilangan{
friend ostream& operator<<(ostream&, const Bilangan&);
friend istream& operator>>(istream&, Bilangan&);
public :
Bilangan(int a0=0,float b0=0.0):a(a0),b(b0){}
void banding_int(const Bilangan&, const Bilangan&);
Bilangan& operator=(const Bilangan&);
Bilangan operator+(const Bilangan&)const;
Bilangan operator-()const;
protected :
int a;
float b;
};

ostream& operator<<(ostream& out, const Bilangan& x){
out<<“Bagian integer :”<<x.a<<endl;
out<<“Bagian float :”<<x.b<<endl;
return out;
}

void Bilangan::banding_int(const Bilangan& x, const Bilangan& y){
if(x.a>y.a)cout<<x.a<<“::x lebih besar dari”<<y.a<<“::y”;
else cout<<x.a<<“::x lebih kecil dari”<<y.a<<“::y”;
}

Bilangan& Bilangan::operator=(const Bilangan& x){
a=x.a;
b=x.b;
return *this;
}

istream& operator>>(istream& in, Bilangan& x){
cout<<“\nmasukan bagian integer :”;
in>>x.a;
cout<<“masukan Bagian float “;
in>>x.b;
return in;
}

Bilangan Bilangan::operator+(const Bilangan& x)const{
Bilangan cc;
cc.a=a+x.a;
cc.b=b+x.b;
return cc;
}

Bilangan Bilangan::operator-()const{
Bilangan x;
x.a=-a;
x.b=-b;
return x;
}

class Bil_char:public Bilangan{
friend ostream& operator<<(ostream&, const Bil_char&);
public:
Bil_char(int a0=0,int b0=0, char ch=’x’):Bilangan(a0,b0),c(ch){}
private :
char c;
};

ostream& operator<<(ostream& out, const Bil_char& x){
out<<“Bagian integer :”<<x.a<<endl;
out<<“Bagian float :”<<x.b<<endl;
out<<“Bagian char :”<<x.c<<endl;
return out;
}

#include <iostream.h>
void main(){
Bilangan s,t(-2,3.14),d;
cout<<“Nilai awal s\n”<<s;
cout<<“Nilai awal t dari deklarasi\n”<<t;
s=t;
cout<<“Setelah s di-assign t\n”;
cout<<“Nilai s\n”<<s;
cout<<“Masukan Nilai-nilai objek d”;
cin>>d;
cout<<“Setelah d+t => \n”<<d+t;
cout<<“Nilai d dinegatifkan\n”<<-d;
Bil_char ss;
cout<<“Nilai awal ss\n”<<ss;
}

 

praktikum ke-3 berbicara menggenai inheritance atau pewarisan, suatu kelas dapat memiliki anak-anak kelas. dan sifat yang dimiliki atau oleh ayah diwarisi oleh anak-anaknya, yaitu pada bagian public dan protected, bagian private hanya bisa dipakai oleh kelas yang memilikinya. class dalam c++ deklarasi dalam penulisan inheritance class adalah Bil_char:public Bilangan{}; dimana class Bil_char tersebut merupakan turunan dari class Bilangan. sehingga didalam kelas Bil char tersebut kita bisa menggunakan seluruh atribut dan operasi yang berada pada bagian public dan protected class bilangan.

PRAKTIKUM  4

#include <iostream.h>
#define maks 5

class Array1D{
friend ostream& operator<<(ostream&, const Array1D&);
friend istream& operator>>(istream&, Array1D&);
public :
Array1D();
void cetak();
void geser_kiri();
void geser_kanan();
private :
char A[maks];
};

Array1D::Array1D(){
for(int i=0;i<maks;i++)
A[i]=’0′;
}

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

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

istream& operator>>(istream& in, Array1D& x){
int posisi;
cout<<“Mengisi array pada posisi ke : “;
in>>posisi;
if(posisi>0&&posisi<=maks){
cout<<“Masukan elemen array-nya : “;
in>>x.A[posisi-1];
}
else
cout<<“Anda memasukan posisi diluar range….”;
return in;
}

void Array1D::geser_kanan(){
int n=maks;
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=maks;
int temp= A[0];
for(int i=0;i<n;i++)
A[i]=A[i+1];
A[n-1]=temp;
}

int main(){
Array1D x;
cout<<“Array masih kosong : “<<x;
cin>>x;
cout<<“isi array saat ini : “<<x;
x.geser_kiri();
cout<<“isi array setelah digeser kekiri :”<<x;
x.geser_kanan();
cout<<“isi array setelah digeser kekanan :”<<x;
return 0;
}

 

Array statis, pada praktikum kali ini asisten meminta ku untuk memodifikasi program pada minggu ke-4 , yaitu :Array statis adalah array yang apabila array[0] digeser kekiri maka element tersebut akan hilang dan element berikutnya akan menjadi element pertama, untuk sebab itu , dalam penggeseran baik geser kiri maupun kanan, dilai array[0] bila geserkiri atau array[maks]bila geserkanan nilainya harus disimpan terlebih dahulu; dan baru dialokasikan lagi ke element pertama maupun element terakhir.

1.inputan harus manual dari keyboard

2. setelah diinputkan , element harus dalam keadaam terurut

3. tambah method hapus_element, dimana user bisa memilih element keberapa yang bisa dihapus.

jawab :

1.untuk membuat manual sangatlah mudah, menambahkan fungsi cin untuk memasukan data. dengan dimasukan didalam looping/perulangan

contoh :

int array[];

for(int i=0;i<maks;i++){

cin>>array[i]

}

2.untuk penggurutan kita bisa menggunakan sorting, disini saya mengunakan buble sort, yaitu membandingkan antara element yang masuk dengan element yang ada, bila elemen yang masuk lebih besar maka element yang masuk ditaruh disebelah kanan element yang lebih kecil.

 

3.untuk penambahan/ penyisipan bisa digunakan fungsi geser kanan.

sedangkan untuk pengurangan element bisa digunakan geser kiri,

catatan : untuk penambahan  element, kita harus mengubah nilai maks nya dulu.

praktikum 5

// exception classes for various error types

#ifndef Xcept_
#define Xcept_

#include <except.h>
#include <new.h>

// bad initializers
class BadInitializers {
public:
BadInitializers() {}
};

// insufficient memory
class NoMem {
public:
NoMem() {}
};

// change new to throw NoMem instead of xalloc
void my_new_handler()
{
throw NoMem();
};

new_handler Old_Handler_ = set_new_handler(my_new_handler);

// improper array, find, insert, or delete index
// or deletion from empty structure
class OutOfBounds {
public:
OutOfBounds() {}
};

// use when operands should have matching size
class SizeMismatch {
public:
SizeMismatch() {}
};

// use when zero was expected
class MustBeZero {
public:
MustBeZero() {}
};

// use when zero was expected
class BadInput {
public:
BadInput() {}
};

#include <iostream.h>
#include <conio.h>
template<class T>
class Array1D{
friend ostream& operator<<(ostream&, const Array1D<T>&);
public :
Array1D(int size=0);
Array1D(const Array1D<T>& v);
~Array1D(){delete []element;}
T& operator[](int i)const;
int Size(){return size;}
Array1D<T>& operator&=(const Array1D<T>& v);
Array1D<T> operator+()const;
Array1D<T> operator+(const Array1D<T>& v)const;
Array1D<T> operator-()const;
Array1D<T> operator-(const Array1D<T>& v)const;
Array1D<T> operator*(const Array1D<T>& v)const;
Array1D<T> operator+=(const T& x);
Array1D<T>& Resize(int sz);
private :
int size;
T *element;

};

template<class T>
Array1D<T>::Array1D(int sz)
{
if(sz<0) throw BadInitializers();
size=sz;
element=new T[sz];
}

template<class T>
Array1D<T>::Array1D(const Array1D<T>& v){
size=v.size;
element=new T[size];
for(int i=0;i<size;i++)
element[i]=v.element[i];
}

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

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

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

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

template<class T>
Array1D<T> Array1D<T>::operator-() const{
Array1D<T> w(size);
for(int i=0;i<size;i++)
w.element[i]=-element[i];
return w;
}

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

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

template<class T>
ostream& operator<<(ostream& out, const Array1D<T>& x){
for(int i=0;i<x.size;i++)
out<<x.element[i]<<” “;
return out;
}

template<class T>
Array1D<T>& Array1D<T>::Resize(int sz){
if(sz<0) throw BadInitializers();
delete[]element;
size=sz;
element=new T[size];
return *this;
}

#include <iostream.h>
//#include “array1d.h”

void main(void){

try{
Array1D<int> 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 2 is”<<X<<endl;
Z=(Y+X)*Y;
cout<<“(Y+X)*Y is”<<Z<<endl;
cout<<“-(Y+X)*Y is “<<-Z<<endl;
}
catch(…){
cout<<“An exception has occurred”<<endl;}
}
#

dalam praktikum ini masih menggunakan array, tapi bedanya praktikum kali ini menggunakan array dinamis, yang tidak perlu menyimpan data awal maupun terakhirnya ke variable. kali ini asisten hanya meminta qw untuk membuat method/fungsi yang didalamnya terdapat perintah untuk mengeser element ke kiri maupun kekanan.

 

PRAKTIKUM 6

#include <iostream.h>#include <conio.h>
template <class T>class Node{ friend class List<T>; friend ostream& operator<<(ostream&, const List<T>&); public : Node(T& t, Node<T>* p):info(t),berikut(p){} protected : T info; Node *berikut;};
template <class T>class List{ friend ostream& operator<<(ostream&, const List<T>&);public : List():kepala(0){} ~List(); void sisip(T t); int hapus(T& t); int kosong(){return(kepala==0);} void cetak();protected : Node<T>* kepala; Node<T>* nodeBaru(T& t, Node<T>* p) {Node<T>* q=new Node<T>(t,p); return q;}};
template<class T>ostream& operator<<(ostream& out, const List<T>& k){ for(Node<T>* p=k.kepala; p; p=p->berikut) out<<p->info<<” -> “; out<<“*\n”;return out;}
template<class T>List<T>::~List(){ Node<T>* temp; for(Node<T>* p=kepala;p;) temp=p; p=p->berikut; delete temp; }
template<class T>void List<T>::sisip(T t){ cout<<t<<“masuk list : “; Node<T>* p=nodeBaru(t,kepala); kepala=p;}
template<class T>int List<T>::hapus(T& t){ if(kosong())return 0; t=kepala->info; Node<T>* p=kepala; kepala=kepala->berikut; delete p; return 1;}
template <class T>void List<T>::cetak(){ for(Node<T>* p=kepala;p;p=p->berikut)  cout<<p->info<<” -> “; cout<<“*\n”;}
void main(){List<char> x;char data;x.sisip(‘a’);cout<<x;x.sisip(‘b’);cout<<x;x.sisip(‘c’);cout<<x;x.sisip(‘d’);cout<<x;for(int i=0;i<5;i++){ x.hapus(data); cout<<data<<“dihapus dari list : “; cout<<x;}getch();}

PRAKTIKUM 7

// exception classes for various error types

#ifndef Xcept_
#define Xcept_

#include <except.h>
#include <new.h>

// bad initializers
class BadInitializers {
public:
BadInitializers() {}
};

// insufficient memory
class NoMem {
public:
NoMem() {}
};

// change new to throw NoMem instead of xalloc
void my_new_handler()
{
throw NoMem();
};

new_handler Old_Handler_ = set_new_handler(my_new_handler);

// improper array, find, insert, or delete index
// or deletion from empty structure
class OutOfBounds {
public:
OutOfBounds() {}
};

// use when operands should have matching size
class SizeMismatch {
public:
SizeMismatch() {}
};

// use when zero was expected
class MustBeZero {
public:
MustBeZero() {}
};

// use when zero was expected
class BadInput {
public:
BadInput() {}
};

#endif
// file stack.h
// formula-based stack

#ifndef Stack_
#define Stack_

template<class T>
class Stack {
// LIFO objects
public:
Stack(int MaxStackSize = 10);
~Stack() {delete [] stack;}
int IsEmpty() const {return top == -1;}
int IsFull() const {return top == MaxTop;}
T Top() const;
Stack<T>& Add(const T& x);
Stack<T>& Delete(T& x);
private:
int top;    // current top of stack
int MaxTop; // max value for top
T *stack;   // element array
};

template<class T>
Stack<T>::Stack(int MaxStackSize)
{// Stack constructor.
MaxTop = MaxStackSize – 1;
stack = new T[MaxStackSize];
top = -1;
}

template<class T>
T Stack<T>::Top() const
{// Return top element.
if (IsEmpty()) throw OutOfBounds(); // Top fails
else return stack[top];
}

template<class T>
Stack<T>& Stack<T>::Add(const T& x)
{// Add x to stack.
if (IsFull()) throw NoMem(); // add fails
stack[++top] = x;
return *this;
}

template<class T>
Stack<T>& Stack<T>::Delete(T& x)
{// Delete top element and put in x.
if (IsEmpty()) throw OutOfBounds(); // delete fails
x = stack[top–];
return *this;
}

#endif
// match parentheses

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

const int MaxLength = 100; // max expression length

void cek_tandakurung(char *expr)
{// Parenthesis matching.
Stack<int> s(MaxLength);
int j, length = strlen(expr);

// scan expression expr for ( and )
for (int i = 1; i <= length; i++) {
if (expr[i – 1] == ‘(‘) s.Add(i);
else if (expr[i – 1] == ‘)’)
try {s.Delete(j);  // unstack match
cout <<“(buka kurung at “<< j <<“)”<< ‘ ‘ <<“(tutup kurung at “<< i <<“)”<< endl;}
catch (OutOfBounds)
{cout << “tanda kurung kelebihan di no”
<< i << endl;}
}

// remaining ( in stack are unmatched
while (!s.IsEmpty()) {
s.Delete(j);
cout << “tanda kurung kelebihan di no ”
<< j << endl;}
}

void main(void)
{
char expr[MaxLength];
cout << “masukan sembarang karekter yang mempunyai tanda kurung max (”
<< MaxLength <<“)”<< endl;
cin.getline(expr, MaxLength);
cout <<“karakter yang anda masukan adalah”
<< endl;
puts(expr);
cout<<endl;
cek_tandakurung(expr);
cout<<“\ntanda kurung seimbang “;
}

stack atau tumpukan, kali ini tugas qw hanya membuat suatu pengecekan tanda kurung. jika karakter merupakan sebuah tanda kurung maka 1 karakter tersebut akan dimasukan ke stack dan bila bertemu tutup kurung keluarkan karakter ke stack, sehingga kita bisa tahu di akhrir apakah tanda kurung yang kita masukan seimbang. caran mengerjakannya gampang,misal diberikan karakter secara manual lewat keyboard yaitu (a+(b/c)) kita hanya menggunakan seleksi, atau if . bila karakter = tanda kurung -> masukan no karakter ke stack dan tampilkan karakter . atau dalam c++ bisa ditampilkan if(kar=='(‘) push(kar) dan bila bertemu tanda tutup kurung ->pop no karakter dari stack : if(kar==’)’)  pop(kar); jika tidak bertemu kedua karakter tersebut maka langsung menuju ke karakter berikutnya. Silahkan mencoba.

praktikum 8

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

#define maks 5

class Queue{
friend ostream& operator<<(ostream&, const Queue&);

public :
Queue();
int penuh(int);
int kosong(int);
void cetak();
void enqueue(char);
char dequeue();
private:
char A[maks];
int banyak;
};
ostream& operator<<(ostream& out, const Queue& s){
cout<<“\nIsi Queue : “;
for(int i;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 Queue : “;
for(int i=0;i<banyak;i++)
cout<<A[i]<<” “;
}

void Queue::enqueue( char x){
cout<<“\nElemen “<<x<<” masuk antrian “;
if(penuh(banyak)) cout<<“Queue penuh”;
else 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];
cout<<“\nDequeue elemen –> “<<temp;
A[banyak]=’0′;
return temp;
}

main(){
Queue q;
for(char c=’a’;c<‘d’;c++){
q.enqueue(c);
}
q.cetak();
char p=q.dequeue();
q.cetak();
cout<<“\n\nCetak pakai overloading “<<q;
getch();
return 0;

}

praktikum 9

#include <cstdlib>
#include <iostream>
#define maks 5

using namespace std;

class Queue{
friend ostream& operator<<(ostream&, const Queue&);
public :
Queue();
int penuh(int);
int kosong(int);
void cetak();
void enqueue();
char dequeue();

private :
char A[maks];
int banyak;
char x;
};

ostream& operator<<(ostream& out, const Queue& s){
cout<<“\nIsi Quueue sebanyak : “<<s.banyak<<” yaitu : “;
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 Queue : “;
for(int i=0;i<banyak;i++)
cout<<A[i]<<” “;
}

void Queue::enqueue(){
cin>>x;
cout<<“Elemen :”<<x<<” masuk antrian”;
if(penuh(banyak))cout<<“queue penuh “;
else if(A[0]==’0′){
A[0]=x;
banyak++;
}
else{
int tempat=0;
while(A[tempat]>x)tempat++;
if(banyak!=tempat)
for(int i=banyak;i>=tempat;i–)
A[i+1] = A[i];
A[tempat]=x;
banyak++;
}
}

char Queue::dequeue(){
char temp=A[–banyak];
cout<<“\nDequeue elemen –> “<<temp;
A[banyak]=’0′;
return temp;
}

int main(int argc, char *argv[])
{
Queue p;
for(int i=1;i<=5;i++){
cout<<“masukan elemnt :”;p.enqueue();
cout<<endl;
}
cout<<p;

for(int i=1;i<=5;i++){
p.dequeue();cout<<p;
if(i==5) cout<<“\n\n\n element kosong”;
cout<<endl;
}
system(“PAUSE”);
return EXIT_SUCCESS;
}

 

queue priority atau antrian prioritas, dimana setiap element yang lebih tinggi nilainya akan masuk dan didepan antrian yang lebih kecil, dalam praktikum ini saya diminta untuk menginputkan antrian secara manual, dan tidak urut. setelah itu program tersebut otomatis akan mengurutkan sesuai nilai karakter yang di enqueue. ini mirip dengan cara sorting. yaitu membandingkan element yang baru masuk kepada element yang didepannya, jika element tersebut mempunyai nilai yang lebih besar maka element tersebut akan bergeser kesebelah kiri sampai bertemu nilai yang lebih tinggi lagi. setelah itu aku juga diminta untuk men-dequeue element menggunakan looping / perulangan hingga element kosong menampilkan tulisan element kosong.

praktikum 10

#include <iostream.h>
// exception classes for various error types

#ifndef Xcept_
#define Xcept_

#include <except.h>
#include <new.h>

// bad initializers
class BadInitializers {
public:
BadInitializers() {}
};

// insufficient memory
class NoMem {
public:
NoMem() {}
};

// change new to throw NoMem instead of xalloc
void my_new_handler()
{
throw NoMem();
};

new_handler Old_Handler_ = set_new_handler(my_new_handler);

// improper array, find, insert, or delete index
// or deletion from empty structure
class OutOfBounds {
public:
OutOfBounds() {}
};

// use when operands should have matching size
class SizeMismatch {
public:
SizeMismatch() {}
};

// use when zero was expected
class MustBeZero {
public:
MustBeZero() {}
};

// use when zero was expected
class BadInput {
public:
BadInput() {}
};

#endif

#ifndef Node_
#define Node_

template <class T> class LinkedStack;
template <class T> class LinkedQueue;

template <class T>
class Node {
friend LinkedStack<T>;
friend LinkedQueue<T>;
private:
T data;
Node<T> *link;
};

#endif
// header file lqueue.h
// linked queue

#ifndef LinkedQueue_
#define LinkedQueue_

template<class T>
class LinkedQueue {
// FIFO objects
public:
LinkedQueue() {front = rear = 0;} // constructor
~LinkedQueue(); // destructor
int IsEmpty() const
{return ((front) ? 0 : 1);} //false : true);}
int IsFull() const;
T First() const; // return first element
T Last() const; // return last element
LinkedQueue<T>& Add(const T& x);
LinkedQueue<T>& Delete(T& x);
private:
Node<T> *front;  // pointer to first node
Node<T> *rear;   // pointer to last node
};

template<class T>
LinkedQueue<T>::~LinkedQueue()
{// Queue destructor.  Delete all nodes.
Node<T> *next;
while (front) {
next = front->link;
delete front;
front = next;
}
}

template<class T>
int LinkedQueue<T>::IsFull() const
{// Is the queue full?
Node<T> *p;
try {p = new Node<T>;
delete p;
return 0;} //false;}
catch (NoMem) {return 1;} //true;}
}

template<class T>
T LinkedQueue<T>::First() const
{// Return first element of queue.  Throw
// OutOfBounds exception if the queue is empty.
if (IsEmpty()) throw OutOfBounds();
return front->data;
}

template<class T>
T LinkedQueue<T>::Last() const
{// Return last element of queue.  Throw
// OutOfBounds exception if the queue is empty.
if (IsEmpty()) throw OutOfBounds();
return rear->data;
}

template<class T>
LinkedQueue<T>& LinkedQueue<T>::Add(const T& x)
{// Add x to rear of queue.  Do not catch
// possible NoMem exception thrown by new.

// create node for new element
Node<T> *p = new Node<T>;
p->data = x;
p->link = 0;

// add new node to rear of queue
if (front) rear->link = p;  // queue not empty
else front = p;             // queue empty
rear = p;

return *this;
}

template<class T>
LinkedQueue<T>& LinkedQueue<T>::Delete(T& x)
{// Delete first element and put it in x.  Throw
// OutOfBounds exception if the queue is empty.

if (IsEmpty()) throw OutOfBounds();

// save element in first node
x = front->data;

// delete first node
Node<T> *p = front;
front = front->link;
delete p;

return *this;
}

template<class T> class BinaryTree;
template <class T>
class BinaryTreeNode{
friend void Visit(BinaryTreeNode<T>*);
friend void InOrder(BinaryTreeNode<T>*);
friend void PreOrder(BinaryTreeNode<T>*);
friend void PostOrder(BinaryTreeNode<T>*);
friend void LevelOrder(BinaryTreeNode<T>*);
friend void main(void);
public :
BinaryTreeNode(){LeftChild=RightChild=0;}
BinaryTreeNode(const T& e){
data=e;
LeftChild=RightChild=0;
}
BinaryTreeNode(const T& e, BinaryTreeNode *l, BinaryTreeNode *r){
data=e;
LeftChild=l;
RightChild=r;
}
private :
T data;
BinaryTreeNode<T> *LeftChild, *RightChild;
};

template<class T>
void Visit(BinaryTreeNode<T> *x){
cout<<x->data<<” “;
}

template<class T>
void PreOrder(BinaryTreeNode<T> *t){
if(t){
Visit(t);
PreOrder(t->LeftChild);
PreOrder(t->RightChild);
}
}

template<class T>
void InOrder(BinaryTreeNode<T> *t){
if(t){
InOrder(t->LeftChild);
Visit(t);
InOrder(t->RightChild);
}
}

template<class T>
void PostOrder(BinaryTreeNode<T> *t){
if(t){
PostOrder(t->LeftChild);
PostOrder(t->RightChild);
Visit(t);
}
}

template<class T>
void LevelOrder(BinaryTreeNode<T> *t){
LinkedQueue<BinaryTreeNode<T>*> Q;
while(t){
Visit(t);
if(t->LeftChild)Q.Add(t->LeftChild);
if(t->RightChild)Q.Add(t->RightChild);
try{Q.Delete(t);}
catch(OutOfBounds){return;}
}
}

void main(void){
BinaryTreeNode<int> x,y,z;
x.data=1;
y.data=2;
z.data=3;
x.LeftChild=&y;
x.RightChild=&z;
y.LeftChild=y.RightChild=z.LeftChild=z.RightChild=0;
cout<<“Kunjungan In order : “;
InOrder(&x);
cout<<endl;
cout<<“Kunjungan Pre order : “;
PreOrder(&x);
cout<<endl;
cout<<“Kunjungan Post order : “;
PostOrder(&x);
cout<<endl;
cout<<“Kunjungan Level order : “;
LevelOrder(&x);
cout<<endl;

}
#endif

diatas sebenarnya adalah program pemberian dosen saya, program diatas tentang kunjungan tree, yaitu inorder, postorder, levelorder, preorder,  seperti yang kalian semua ketahui, bahwa urutan kunjungan nya berbeda-beda dan menghasilkan output yang berbeda.

1.jika preorder maka dia akan mencetak node yang dikunjungi, lalu akan mengunjungi anak kiri sampai habis dan mengunjungi anak kanan sampai habis.

2. jika inorder dia ankan mengunjungi anak kiri sampai habis, cetak isi node , dan kunjungi anak kanan.

3.jika post order, kunjungi anak kiri sampai habis, kunjungi anak kanan sampai habis, cetak isi node.

didalam program diatas , cara mengunjunginya dengan menggunaka rekursif, yaitu perulangan hingga node NULL, tapi untuk kunjungan secara level order program diatas menggunakan antrian, atau Queue.

terdapat tiga konstruktor , dan didalam program utamanya, dipanggil menggunakan parameter.

untuk output program diatas adlah

kunjungan inorder  : 2 1 3

kunjungan preorder  : 1 2 3

kunjungan postorder : 2 3 1

kunjungan level order : 1 2 3

selamat mencoba!!!!!

 

 

One thought on “praktikum

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s