class Titik{
/*kelas yang digunakan untuk mengimplementasikan sebuah tipe titik*/
private:
int x; /*koordinat x*/
int y; /*koordinat y*/
public:
Titik(){
/*konstruktor*/
x = 0;
y = 0;
}
Titik(int xp, int yp){
/*konstruktor*/
x = xp;
y = yp;
}
void setX(int xp){
/*mengeset nilai koordinat x*/
x = xp;
}
int getX(){
/*mengembalikan nilai koordinat x*/
return x;
}
void setY(int yp){
/*mengeset nilai koordinat y*/
y = yp;
}
int getY(){
/*mengembalikan nilai koordinat y*/
return y;
}
~Titik(){
/*destruktor*/
}
};
/*fungsi main untuk mengetes kelas Titik*/
int main(){
Titik t1;
Titik t2(11, 9);
t1.setX(18);
t1.setY(28);
printf("t1 : nilai X : %d\n", t1.getX());
printf("t1 : nilai Y : %d\n", t1.getY());
printf("t2 : nilai X : %d\n", t2.getX());
printf("t2 : nilai Y : %d\n", t2.getY());
return 0;
}
Cpp graphdinamik
#include
#include
//----------------------
struct simpul{
char info;
struct simpul *next;
struct jalur *arc;
};
struct jalur{
int info;
struct jalur *next;
struct simpul *node;
};
struct graph{
struct simpul *first;
};
//----------------------
void createEmpty(graph *G){
(*G).first = NULL;
}
//----------------------
void addSimpul(char c, graph *G){
simpul *node;
node = (simpul *) malloc (sizeof (simpul));
node->info = c;
node->next = NULL;
node->arc = NULL;
if((*G).first == NULL){
/*jika graph kosong*/
(*G).first = node;
}
else{
/*menambahkan simpul baru pada akhir graph*/
simpul *last = (*G).first;
while(last->next != NULL){
last = last->next;
}
last->next = node;
}
}
//----------------------
void addJalur(simpul *tujuan, int beban, simpul **awal){
jalur *arc;
arc = (jalur *) malloc (sizeof (jalur));
arc->info = beban;
arc->next = NULL;
arc->node = tujuan;
if((*awal)->arc == NULL){
/*jika list jalur kosong*/
(*awal)->arc = arc;
}
else{
/*menambahkan jalur baru pada akhir list jalur*/
jalur *last = (*awal)->arc;
while(last->next != NULL){
last = last->next;
}
last->next = arc;
}
}
//----------------------
void delSimpul(char c, graph *G){
simpul *elmt = (*G).first;
if(elmt != NULL){
simpul *prec = NULL;
/*mencari simpul yang akan dihapus*/
bool ketemu = false;
while((elmt != NULL) && (ketemu == false)){
if(elmt->info == c){
ketemu = true;
}
else{
prec = elmt;
elmt = elmt->next;
}
}
if(ketemu == true){
if(prec == NULL){
/*hapus simpul pertama*/
(*G).first = elmt->next;
}
else{
if(elmt->next == NULL){
/*hapus simpul terakhir*/
prec->next = NULL;
}
else{
/*hapus simpul di tengah*/
prec->next = elmt->next;
elmt->next = NULL;
}
}
free(elmt);
}
else{
printf("tidak ada simpul dengan info karakter masukan\n");
}
}
else{
printf("tidak ada simpul dengan info karakter masukan\n");
}
}
//----------------------
simpul* findSimpul(char c, graph G){
simpul *hasil = NULL;
simpul *node = G.first;
int ketemu = 0;
while((node != NULL) && (ketemu == 0)){
if(node->info == c){
hasil = node;
ketemu = 1;
}
else{
node = node->next;
}
}
return hasil;
}
//----------------------
void delJalur(char ctujuan, simpul **awal){
jalur *arc = (*awal)->arc;
if(arc != NULL){
jalur *prec = NULL;
/*mencari jalur yang akan dihapus*/
int ketemu = 0;
while((arc != NULL) && (ketemu == 0)){
if(arc->node->info == ctujuan){
ketemu = 1;
}
else{
prec = arc;
arc = arc->next;
}
}
if(ketemu == 1){
if(prec == NULL){
/*hapus jalur pertama*/
(*awal)->arc = arc->next;
}
else{
if(arc->next == NULL){
/*hapus jalur terakhir*/
prec->next = NULL;
}
else{
/*hapus jalur di tengah*/
prec->next = arc->next;
arc->next = NULL;
}
}
free(arc);
}
else{
printf("tidak ada jalur dengan simpul tujuan\n");
}
}
else{
printf("tidak ada jalur dengan simpul tujuan\n");
}
}
//----------------------
void printGraph(graph G){
simpul *node = G.first;
if(node != NULL){
while(node != NULL){
printf("simpul : %c\n", node->info);
jalur *arc = node->arc;
while(arc != NULL){
printf(" - ada jalur ke simpul : %c dengan beban : %d\n", arc->node->info, arc->info);
arc = arc->next;
}
node = node->next;
}
}
else{
printf("graph kosong\n");
}
}
//----------------------
int main(){
struct graph G;
createEmpty(&G);
addSimpul('A', &G);
addSimpul('B', &G);
addSimpul('C', &G);
addSimpul('D', &G);
addSimpul('E', &G);
addSimpul('F', &G);
simpul *begin = findSimpul('A', G);
simpul *end = findSimpul('B', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 3, &begin);
}
begin = findSimpul('B', G);
end = findSimpul('D', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 3, &begin);
}
end = findSimpul('E', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 7, &begin);
}
begin = findSimpul('C', G);
end = findSimpul('A', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 3, &begin);
}
begin = findSimpul('D', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 8, &begin);
}
end = findSimpul('C', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 3, &begin);
}
begin = findSimpul('E', G);
end = findSimpul('D', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 4, &begin);
}
end = findSimpul('F', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 4, &begin);
}
begin = findSimpul('F', G);
end = findSimpul('D', G);
if((begin != NULL) && (end != NULL)){
addJalur(end, 2, &begin);
}
printf("=================\n");
printGraph(G);
printf("\n=================\n");
begin = findSimpul('A', G);
if(begin != NULL){
delJalur('B', &begin);
}
printf("=================\n");
printf("setelah dihapus\n");
printGraph(G);
printf("\n=================\n");
return 0;
}
Cpp pohonbiner
#include
#include
//----------------------
struct simpul{
char info;
struct simpul *sibling;
struct simpul *child;
};
struct tree{
struct simpul *root;
};
//----------------------
void makeTree(char c, tree *T){
simpul *node;
node = (simpul *) malloc (sizeof (simpul));
node->info = c;
node->sibling = NULL;
node->child = NULL;
(*T).root = node;
}
//----------------------
void addChild(char c, simpul **root){
if((*root) != NULL){
/*jika root tidak kosong*/
simpul *node;
node = (simpul *) malloc (sizeof (simpul));
node->info = c;
node->child = NULL;
if((*root)->child == NULL){
/*simpul baru menjadi anak pertama*/
node->sibling = NULL;
(*root)->child = node;
}
else{
if((*root)->child->sibling == NULL){
/*jika simpul baru menjadi anak kedua*/
node->sibling = (*root)->child;
(*root)->child->sibling = node;
}
else{
simpul *last = (*root)->child;
/*mencari simpul anak terakhir*/
while(last->sibling != (*root)->child){
last = last->sibling;
}
node->sibling = (*root)->child;
last->sibling = node;
}
}
}
}
//----------------------
void delChild(char c, simpul **root){
simpul *node = (*root)->child;
if(node != NULL){
if(node->sibling == NULL){
/*jika hanya mempunyai satu anak*/
if((*root)->child->info == c){
(*root)->child = NULL;
free(node);
}
else{
printf("tidak ada simpul anak dengan info karakter masukan\n");
}
}
else{
/*jika memiliki banyak anak*/
simpul *prec = NULL;
/*mencari simpul yang akan dihapus*/
bool ketemu = false;
while((node->sibling != (*root)->child)&&(ketemu == false)){
if(node->info == c){
ketemu = true;
}
else{
prec = node;
node = node->sibling;
}
}
/*memproses simpul anak terakhir karena belum terproses dalam perulangan*/
if((ketemu == false)&&(node->info == c)){
ketemu = true;
}
if(ketemu == true){
simpul *last = (*root)->child;
/*mencari simpul anak terakhir*/
while(last->sibling != (*root)->child){
last = last->sibling;
}
if(prec == NULL){
/*jika simpul yang dihapus anak pertama*/
if((node->sibling == last)&&(last->sibling == (*root)->child)){
/*jika hanya ada 2 anak*/
(*root)->child = last;
last->sibling = NULL;
}
else{
(*root)->child = node->sibling;
last->sibling = (*root)->child;
}
}
else{
if((prec == (*root)->child)&&(last->sibling == (*root)->child)){
/*jika hanya ada 2 simpul anak, yang dihapus anak kedua*/
(*root)->child->sibling = NULL;
}
else{
prec->sibling = node->sibling;
node->sibling = NULL;
}
}
free(node);
}
else{
printf("tidak ada simpul anak dengan info karakter masukan\n");
}
}
}
}
//----------------------
simpul* findSimpul(char c, simpul *root){
simpul *hasil = NULL;
if(root != NULL){
if(root->info == c){
hasil = root;
}
else{
simpul *node = root->child;
if(node != NULL){
if(node->sibling == NULL){
/*jika memiliki satu anak*/
if(node->info == c){
hasil = node;
}
else{
hasil = findSimpul(c, node);
}
}
else{
/*jika memiliki banyak anak*/
int ketemu = 0;
while((node->sibling != root->child)&&(ketemu == 0)){
if(node->info == c){
hasil = node;
ketemu = 1;
}
else{
hasil = findSimpul(c, node);
node = node->sibling;
}
}
/*memproses simpul anak terakhir karena belum terproses dalam perulangan*/
if(ketemu == 0){
if(node->info == c){
hasil = node;
}
else{
hasil = findSimpul(c, node);
}
}
}
}
}
}
return hasil;
}
//----------------------
void printTreePreOrder(simpul *root){
if(root != NULL){
printf(" %c ", root->info);
simpul *node = root->child;
if(node != NULL){
if(node->sibling == NULL){
/*jika memiliki satu anak*/
printTreePreOrder(node);
}
else{
/*jika memiliki banyak anak*/
/*mencetak simpul anak*/
while(node->sibling != root->child){
printTreePreOrder(node);
node = node->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam perulangan*/
printTreePreOrder(node);
}
}
}
}
//----------------------
void printTreePostOrder(simpul *root){
if(root != NULL){
simpul *node = root->child;
if(node != NULL){
if(node->sibling == NULL){
/*jika memiliki satu anak*/
printTreePostOrder(node);
}
else{
/*jika memiliki banyak anak*/
/*mencetak simpul anak*/
while(node->sibling != root->child){
printTreePostOrder(node);
node = node->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam perulangan*/
printTreePostOrder(node);
}
}
printf(" %c ", root->info);
}
}
//----------------------
void printTreeLevelOrderNext(simpul *root){
if(root != NULL){
simpul *node = root->child;
if(node != NULL){
if(node->sibling == NULL){
/*jika memiliki satu anak*/
printf(" %c ", node->info);
printTreeLevelOrderNext(node);
}
else{
while(node->sibling != root->child){
printf(" %c ", node->info);
node = node->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam perulangan*/
printf(" %c ", node->info);
node = root->child;
while(node->sibling != root->child){
printTreeLevelOrderNext(node);
node = node->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam perulangan*/
printTreeLevelOrderNext(node);
}
}
}
}
void printTreeLevelOrder(simpul *root){
if(root != NULL){
printf(" %c ", root->info);
printTreeLevelOrderNext(root);
}
}
//----------------------
void copyTree(simpul *root1, simpul **root2){
if(root1 != NULL){
(*root2) = (simpul *) malloc (sizeof (simpul));
(*root2)->info = root1->info;
(*root2)->sibling = NULL;
(*root2)->child = NULL;
if(root1->child != NULL){
if(root1->child->sibling == NULL){
/*jika memiliki satu anak*/
copyTree(root1->child, &(*root2)->child);
}
else{
/*jika memiliki banyak anak*/
simpul *node1 = root1->child;
simpul *node2 = (*root2)->child;
while(node1->sibling != root1->child){
copyTree(node1, &node2);
node1 = node1->sibling;
node2 = node2->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam perulangan*/
copyTree(node1, &node2);
}
}
}
}
//----------------------
int isEqual(simpul *root1, simpul *root2){
int hasil = 1;
if((root1 != NULL)&&(root2 != NULL)){
if(root1->info != root2->info){
hasil = 0;
}
else{
if((root1->child != NULL)&&(root2->child != NULL)){
if(root1->child->sibling == NULL){
/*jika memiliki satu anak*/
hasil = isEqual(root1->child, root2->child);
}
else{
/*jika memiliki banyak anak*/
simpul *node1 = root1->child;
simpul *node2 = root2->child;
while(node1->sibling != root1->child){
if((node1 != NULL)&&(node2 != NULL)){
hasil = isEqual(node1, node2);
node1 = node1->sibling;
node2 = node2->sibling;
}
else{
hasil = 0;
break;
}
}
/*memproses simpul anak terakhir karena belum terproses dalam perulangan*/
hasil = isEqual(node1, node2);
}
}
}
}
else{
if((root1 != NULL)||(root2 != NULL)){
hasil = 0;
}
}
return hasil;
}
//----------------------
int main(){
struct tree T;
makeTree('A', &T);
addChild('B', &T.root);
addChild('C', &T.root);
addChild('D', &T.root);
simpul *node = findSimpul('B', T.root);
if(node != NULL){
addChild('E', &node);
addChild('F', &node);
}
node = findSimpul('C', T.root);
if(node != NULL){
addChild('G', &node);
}
node = findSimpul('D', T.root);
if(node != NULL){
addChild('H', &node);
addChild('I', &node);
addChild('J', &node);
}
node = findSimpul('J', T.root);
if(node != NULL){
addChild('K', &node);
addChild('L', &node);
addChild('M', &node);
}
printf("=================\n");
printf("preOrder\n");
printTreePreOrder(T.root);
printf("\n=================\n");
printf("postOrder\n");
printTreePostOrder(T.root);
printf("\n=================\n");
printf("levelOrder\n");
printTreeLevelOrder(T.root);
printf("\n=================\n");
tree T2;
copyTree(T.root, &T2.root);
if(isEqual(T.root, T2.root) == true){
printf("pohon sama\n");
}
else{
printf("pohon tidak sama\n");
}
node = findSimpul('J', T.root);
if(node != NULL){
delChild('K', &node);
delChild('L', &node);
delChild('M', &node);
}
printf("=================\n");
printf("preOrder setelah dihapus\n");
printTreePreOrder(T.root);
printf("\n=================\n");
return 0;
}
