tag:blogger.com,1999:blog-47545892569622674002024-02-19T22:13:21.821-08:00STRUKTUR DATAapa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.comBlogger9125tag:blogger.com,1999:blog-4754589256962267400.post-45134279918505901152011-03-03T04:54:00.000-08:002011-03-03T04:55:07.858-08:00TREE (POHON)Struktur pada tree (pohon) tidak linear seperti pada struktur linked list, stack,<br />dan queue. Setiap node pada tree mempunyai tingkatan, yaitu orang tua<br />(parent) dan anak (child). Struktur ini sebenarnya merupakan bentuk khusus<br />dari struktur tree yang lebih umum, setiap orang tua hanya memiliki dua anak<br />sehingga disebut pohon biner (binary tree), yaitu anak kiri dan anak kanan.<br />ISTILAH DASAR<br />Tree merupakan salah satu bentuk struktur data tidak linear yang<br />menggambarkan hubungan yang bersifat hirarkis (hubungan one to many)<br />antara elemen-elemen. Tree dapat didefinisikan sebagai kumpulan simpul/node<br />dengan satu elemen khusus yang disebut root dan node, disebut sub tree/sub<br />pohon atau cabang.<br />Sehingga secara sederhana pohon bisa didefinisikan sebagai kumpulan elemen<br />yang salah satu elemennya disebut dengan akar (root) dan elemen yang lainnya<br />(simpul), terpecah menjadi sejumlah himpunan yang saling tidak berhubungan<br />satu dengan yang lainnya.<br />• Predecessor : node yang berada di atas node tertentu<br />• Successor : node yang dibawah node tertentu<br />• Ancestor : seluruh node yang terletak sebelum node tertentu dan<br />terletak sesudah pada jalur yang sama<br />• Descendant : seluruh node yang terletak sesudah node tertentu dan<br />terletak sesudah pada jalur yang sama<br />• Parent : predecessor satu level diatas suatu node<br />• Child : successor satu level dibawah suatu node<br />• Sibling : node-node yang memiliki parent yang sama dengan<br />suatu node<br />• Subtree : bagian dari tree yang berupa suatu node beserta<br />descendantnya dan memiliki semua karakteristik dari<br />tree tersebut<br />• Size : banyaknya node dalam suatu tree<br />• Height : banyaknya tingkatan/level dalam suatu tree<br />• Root : satu-satunya node khusus dalam tree yang tidak<br />mempunyai predecessor<br />• Leaf : node-node dalam tree yang tidak memiliki successor<br />• Degree : banyaknya child yang dimiliki suatu node<br />Contoh :<br />A<br />B C<br />D E F G<br />Modul 9 Struktur Data (Arie) - 2<br />Keterangan :<br />• Ancestor : C, A<br />• Descendant : C, G<br />• Parent : B<br />• Child : B, C<br />• Sibling : F, G<br />• Size : 7<br />• Height : 3<br />• Root : A<br />• Leaf : D, E, F, G<br />• Degree : 2<br />JENIS TREE<br />1. Binary Tree<br />adalah tree dengan syarat bahwa tiap node hanya boleh memiliki maksimal dua<br />subtree dan kedua subtree tersebut harus terpisah. Maka tiap node dalam<br />binary tree hanya boleh memiliki paling banyak dua child.<br />Leaf<br />Keterangan :<br />• Left Child : B, D, H, ...<br />• Right Child : C, G, J, ...<br />Jenis Binary Tree<br /> Full Binary Tree<br />Binary Tree yang tiap nodenya (kecuali leaf) memiliki dua child dan tiap sub<br />tree harus mempunyai panjang path yang sama.<br />A<br />B C<br />D E F G<br />H I J<br />Modul 9 Struktur Data (Arie) - 3<br /> Complete Binary Tree<br />Mirip dengan Full Binary Tree, namun tiap subtree boleh memiliki panjang<br />path yang berbeda. Node kecuali leaf memiliki 0 atau 2 child.<br /> Skewed Binary Tree<br />Binary Tree yang semua nodenya (kecuali leaf) hanya memiliki satu child.<br />Operasi Binary Tree<br />• Create : membentuk binary tree baru yang masih kosong<br />• Clear : mengosongkan binary tree yang sudah ada<br />• Empty : function untuk memeriksa apakah binary tree masih<br />kosong<br />• Insert : memasukkan sebuah node ke dalam tree. Ada 3 pilihan<br />insert, yaitu : root, left child, atau right child. Khusus<br />insert sebagai root, tree harus dalam keadaan kosong.<br />• Find : mencari root, parent, left child, atau right child dari<br />suatu node. Tree tidak boleh kosong.<br />• Update : mengubah isi dari node yang ditunjuk oleh pointer<br />current. Tree tidak boleh kosong.<br />A<br />B C<br />D E F G<br />A<br />B C<br />D E<br />A<br />B<br />D<br />Modul 9 Struktur Data (Arie) - 4<br />• Retrive : mengetahui isi dari node yang ditunjuk oleh pointer<br />current. Tree tidak boleh kosong.<br />• DeleteSub : menghapus sebuah subtree (node beserta seluruh<br />descedantnya) yang ditunjuk current. Tree tidak boleh<br />kosong. Setelah itu pointer current akan berpindah ke<br />parent dari node yang dihapus.<br />• Characteristic: mengetahui karakteristik dari suatu tree, yakni : size,<br />height, serta average lengthnya. Tree tidak boleh<br />kosong.<br />• Traverse : mengunjungi seluruh node pada tree, masing-masing<br />sekali. Hasilnya adalah urutan informasi secara linear<br />yang tersimpan dalam tree. Ada tiga cara traverse : Pre<br />Order, InOrder, dan PostOrder.<br />Langkah Traverse<br />• PreOrder : cetak isi node yang dikunjungi, kunjungi Left Child,<br />kunjungi Right Child.<br />• InOrder : kunjungi Left Child, cetak isi node yang dikunjungi,<br />kunjungi Right Child.<br />• PostOrder : kunjungi Left Child, kunjungi Right Child, cetak isi node<br />yang dikunjungi.<br />2. Binary Search Tree<br />Adalah binary tree dengan sifat bahwa semua left child harus lebih kecil<br />daripada right child dan parentnya. Semua right child harus lebih besar dari left<br />child serta parentnya. Binary Search Tree dibuat untuk mengatasi kelemahan<br />pada binary tree biasa, yaitu kesulitan dalam searching/pencarian node<br />tertentu dalam binary tree.<br />Contoh :<br />Operasi Binary Tree<br />Pada dasarnya sama dengan operasi pada binary tree, kecuali pada operasi<br />insert, update, dan delete.<br />• Insert : dilakukan setelah ditemukan lokasi yang tepat, lokasi<br />tidak ditentukan oleh user sendiri.<br />• Update : update akan berpengaruh pada posisi node tersebut<br />selanjutnya. Setelah diupdate mengakibatkan tree<br />tersebut bukan binary search tree lagi, maka harus<br />dilakukan perubahan pada tree dengan melakukan rotasi<br />supaya tetap menjadi binary search tree.<br />• Delete : akan mempengaruhi struktur dari tree.<br />18<br />10 23<br />5 14 21 25<br />Modul 9 Struktur Data (Arie) - 5<br />3. AVL Tree<br />Adalah binary search tree yang memiliki perbedaan tingkat tinggi/level antara<br />subtree kiri dan subtree kanan maksimal adalah 1. Dengan AVL Tree, waktu<br />pencarian dan bentuk tree dapat dipersingkat dan disederhanakan.<br />Selain AVL Tree terdapat juga Height Balanced n tree, yaitu binary search tree<br />yang memiliki perbedaan level antara subtree kiri dan subtree kanan maksimal<br />adalah n. Sehingga AVL Tree adalah Height Balanced 1 Tree.<br />Simbol Bantu<br />Untuk mempermudah menyeimbangkan tree, maka digunakan simbol-simbol<br />bantu.<br />• Minus ( - ) : digunakan apabila subtree kiri lebih panjang dari<br />subtree kanan.<br />• Plus ( + ) : digunakan apabila subtree kanan lebih panjang dari<br />subtree kiri.<br />• Nol ( 0 ) : digunakan apabila subtree kiri dan subtree kanan<br />mempunyai height yang sama.<br />CONTOH SOAL :<br />Soal 1<br />Buatlah program untuk menampilkan node baru ke dalam pohon dengan<br />menggunakan prosedur preorder, inorder, dan postorder.<br />//Program :tree.cpp<br />#include <stdio.h><br />#include <malloc.h><br />struct nod {<br />struct nod *left;<br />char data;<br />struct nod *right;<br />};<br />typedef struct nod NOD;<br />typedef NOD POKOK;<br />NOD *NodBaru(char item) {<br />NOD *n;<br />n = (NOD*) malloc(sizeof(NOD));<br />if(n != NULL) {<br />n->data = item;<br />n->left = NULL;<br />n->right = NULL;<br />}<br />return n;<br />}<br />void BinaPokok(POKOK **T) {<br />*T = NULL;<br />}<br />Modul 9 Struktur Data (Arie) - 6<br />typedef enum { FALSE = 0, TRUE = 1} BOOL;<br />BOOL PokokKosong(POKOK *T) {<br />return((BOOL)(T == NULL));<br />}<br />void TambahNod(NOD **p, char item) {<br />NOD *n;<br />n = NodBaru(item);<br />*p = n;<br />}<br />void preOrder(POKOK *T) {<br />if(!PokokKosong(T)) {<br />printf("%c ", T->data);<br />preOrder(T->left);<br />preOrder(T->right);<br />}<br />}<br />void inOrder(POKOK *T) {<br />if(!PokokKosong(T)) {<br />inOrder(T->left);<br />printf("%c ", T->data);<br />inOrder(T->right);<br />}<br />}<br />void postOrder(POKOK *T) {<br />if(!PokokKosong(T)) {<br />postOrder(T->left);<br />postOrder(T->right);<br />printf("%c ", T->data);<br />}<br />}<br />int main()<br />{<br />POKOK *kelapa;<br />char buah;<br />BinaPokok(&kelapa);<br />TambahNod(&kelapa, buah = 'M');<br />TambahNod(&kelapa->left, buah = 'E');<br />TambahNod(&kelapa->left->right, buah = 'I');<br />TambahNod(&kelapa->right, buah = 'L');<br />TambahNod(&kelapa->right->right, buah = 'O');<br />TambahNod(&kelapa->right->right->left, buah = 'D');<br />printf("Tampilan secara PreOrder: ");<br />preOrder(kelapa);<br />printf("\nTampilan secara InOrder: ");<br />inOrder(kelapa);<br />printf("\nTampilan secara PreOrder: ");<br />postOrder(kelapa);<br />printf("\n\n");<br />return 0;<br />}<br />Modul 9 Struktur Data (Arie) - 7<br />SOAL LATIHAN :<br />Buatlah program untuk menampilkan node baru ke dalam pohon dengan<br />menggunakan prosedur preorder, inorder, dan postorder.<br />Sehingga akan didapatkan hasil :<br />Tampilan secara PreOrder : R A S I T E<br />Tampilan secara InOrder : I S T A R E<br />Tampilan secara PostOrder : I T S A E R<br />Contoh ada di file : tree2.exe<br />Save dengan nama file : tre_nim (4 digit nim terakhir)apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com2tag:blogger.com,1999:blog-4754589256962267400.post-51708059202628526682011-03-03T04:53:00.000-08:002011-03-03T04:54:27.000-08:00QUEUE (ANTRIAN)Queue (Antrian) adalah suatu kumpulan data yang penambahan elemennya
<br />hanya bisa dilakukan pada suatu ujung (disebut dengan sisi belakang atau rear),
<br />dan penghapusan atau pengambilan elemen dilakukan lewat ujung yang lain
<br />(disebut dengan sisi depan atau front)
<br />Jika pada tumpukan dikenal dengan menggunakan prinsip LIFO (Last In First
<br />Out), maka pada antrian prinsip yang digunakan adalah FIFO (First In First Out).
<br />IMPLEMENTASI ANTRIAN DENGAN ARRAY
<br />Karena antrian merupakan suatu kumpulan data, maka tipe data yang sesuai
<br />untuk menyajikan antrian adalah menggunakan array atau list (senarai
<br />berantai).
<br />depan
<br />keluar A B C D E F masuk
<br />belakang
<br />Antrian tersebut berisi 6 elemen, yaitu A, B, C, D, E, dan F. Elemen A terletak
<br />dibagian depan antrian dan elemen F terletak di bagian belakang antrian.
<br />Jika terdapat elemen baru yang akan masuk, maka elemen tersebut akan
<br />diletakkan disebelah kanan F.
<br />Jika ada elemen yang akan dihapus, maka A akan dihapus terlebih dahulu.
<br />depan
<br />keluar A B C D E F G H masuk
<br />belakang
<br />Antrian dengan penambahan elemen baru, yaitu G dan H.
<br />depan
<br />keluar C D E F G H masuk
<br />belakang
<br />Antrian dengan penghapusan elemen antrian, yaitu A dan B.
<br />Modul 8 Struktur Data (Arie) - 2
<br />Seperti dalam tumpukan atau stack, maka di dalam antrian juga dikenal dua
<br />operasi dasar yaitu menambah elemen baru yang akan diletakkan di bagian
<br />belakang antrian dan menghapus elemen yang terletak di bagian depan antrian.
<br />Selain itu juga harus dilihat kondisi antrian mempunyai isi atau masih kosong.
<br />Contoh :
<br />#define MAXN 6
<br />typedef enum {NOT_OK, OK} Tboolean;
<br />typedef struct {
<br />Titem array[MAXN];
<br />int first;
<br />int last;
<br />int number_of_items;
<br />} Tqueue;
<br />Elemen antrian dinyatakan dalam tipe integer yang semuanya terdapat dalam
<br />struktur. Variabel first menunjukkan posisi elemen pertama dalam array, dan
<br />variabel last menunjukkan posisi elemen terakhir dalam array.
<br />Untuk menambah elemen baru dan mengambil elemen dari antrian diperlukan
<br />deklarasi.
<br />Contoh :
<br />void initialize_queue (Tqueue *Pqueue) {
<br />Pqueue->first=0;
<br />Pqueue->last=-1;
<br />Pqueue->number_of_items=0;
<br />}
<br />Tboolean enqueue (Tqueue *Pqueue, Titem item) {
<br />if (Pqueue->number_of_items >= MAXN)
<br />return (NOT_OK);
<br />else {
<br />Pqueue->last++;
<br />if (Pqueue->last > MAXN – 1)
<br />Pqueue->last=0;
<br />Pqueue->array[Pqueue->last]=item;
<br />Pqueue->number_of_items++;
<br />return (OK);
<br />}
<br />}
<br />Tboolean dequeue (Tqueue *Pqueue, Titem *Pitem) {
<br />if (Pqueue->number_of_items==0)
<br />return (NOT_OK);
<br />else {
<br />*Pitem=Pqueue->array[Pqueue->first++];
<br />if (Pqueue->first > MAXN – 1)
<br />Pqueue->first=0;
<br />Pqueue->number_of_items--;
<br />return (OK);
<br />}
<br />}
<br />Modul 8 Struktur Data (Arie) - 3
<br />Kondisi awal sebuah antrian dapat digambarkan sebagai berikut.
<br />Antrian
<br />6
<br />5
<br />4
<br />3
<br />2
<br />1 first = 1
<br />last = 0
<br />Pada kondisi awal ini antrian terdiri dari last dibuat = 0 dan first dibuat = 1.
<br />Antrian dikatakan kosong jika last < first. Banyaknya elemen yang terdapat
<br />dalam antrian dinyatakan sebagai last – first + 1.
<br />Antrian
<br />6
<br />5
<br />4 D last = 4
<br />3 C
<br />2 B
<br />1 A first = 1
<br />Dengan MAXN = 6 antrian telah terisi empat buah data yaitu A, B, C, dan D.
<br />Kondisi first = 1 dan last = 4.
<br />Antrian
<br />6
<br />5
<br />4 D last = 4
<br />3 C first = 3
<br />2
<br />1
<br />Pada antrian dilakukan penghapusan dua buah data yaitu A dan B. Sehingga
<br />kondisi first = 3 dan last = 4.
<br />Antrian
<br />6 F last = 6
<br />5 E
<br />4 D
<br />3 C first = 3
<br />2
<br />1
<br />Pada antrian dilakukan penambahan dua buah data yaitu E dan F. Elemen E
<br />akan diletakkan setelah D dan elemen F akan diletakkan setelah E. Sehingga
<br />kondisi first = 3 dan last = 6.
<br />Dapat diperoleh jumlah elemen yaitu 6 – 3 + 1 = 4. Dengan pembatasan data
<br />maksimal 6 elemen akan terdapat sisa 2 elemen. Jika pada antrian akan
<br />ditambahkan elemen yang baru, misal G, elemen G akan diletakkan setelah
<br />elemen F. Hal ini akan menyebabkan elemen yang baru tersebut tidak dapat
<br />masuk (MAXN = 6), meskipun masih tersisa 2 buah elemen yang kosong.
<br />Modul 8 Struktur Data (Arie) - 4
<br />IMPLEMENTASI ANTRIAN DENGAN POINTER
<br />Pada prinsipnya, antrian dengan pointer akan sama dengan antrian yang
<br />menggunakan array. Penambahan akan selalu dilakukan di belakang antrian dan
<br />penghapusan akan selalu dilakukan pada elemen dengan posisi paling depan.
<br />Antrian sebenarnya merupakan bentuk khusus dari suatu senarai berantai
<br />(linked list).
<br />Pada antrian bisa digunakan dua variabel yang menyimpan posisi elemen paling
<br />depan dan elemen paling belakang. Jika menggunakan senarai berantai maka
<br />dengan dua pointer yang menunjuk elemen kepala (paling depan) dan elemen
<br />ekor (paling belakang) dapat dibentuk antrian.
<br />Contoh :
<br />struct queueNode {
<br />char data;
<br />struct queueNode * nextPtr;
<br />};
<br />typedef struct queueNode QUEUENODE;
<br />typedef QUEUENODE *QUEUENODEPTR;
<br />QUEUENODEPTR headPtr = NULL, tailPtr = NULL;
<br />Contoh :
<br />Untuk menambah elemen baru yang selalu diletakkan di belakang senarai.
<br />void enqueue (QUEUENODEPTR *headPtr, QUEUENODEPTR *tailPtr, char
<br />value) {
<br />QUEUENODEPTR newPtr = malloc (sizeof(QUEUENODE));
<br />if (newPtr != NULL) {
<br />newPtr->data=value;
<br />newPtr->nextPtr=NULL;
<br />if (isEmpty(*headPtr))
<br />*headPtr=newPtr;
<br />else
<br />(*tailPtr)->nextPtr=newPtr;
<br />*tailPtr=newPtr;
<br />}
<br />else
<br />printf(“%c not inserted. No memory available. \n”, value);
<br />}
<br />Contoh :
<br />Untuk menghapus akan dilakukan pemeriksaan terlebih dahulu antrian dalam
<br />keadaan kosong atau tidak.
<br />int isEmpty (QUEUENODEPTR headPtr) {
<br />return headPtr==NULL;
<br />}
<br />Modul 8 Struktur Data (Arie) - 5
<br />CONTOH SOAL :
<br />Soal 1
<br />Buatlah program dalam bentuk menu untuk mengimplementasikan antrian.
<br />Menu tersebut berisi memasukkan data, menghapus data, menampilkan data,
<br />dan keluar
<br />//Program : queue1
<br /># include <iostream.h>
<br /># include <conio.h>
<br />class Linked_list_Queue
<br />{
<br />private:
<br />struct node {
<br />int data;
<br />node *next;
<br />};
<br />node *rear;
<br />node *entry;
<br />node *print;
<br />node *front;
<br />public:
<br />Linked_list_Queue( );
<br />void Delete( );
<br />void Insert( );
<br />void print_list( );
<br />void show_working( );
<br />};
<br />Linked_list_Queue::Linked_list_Queue ( )
<br />{
<br />rear=NULL;
<br />front=NULL;
<br />}
<br />void Linked_list_Queue::Insert( )
<br />{
<br />int num;
<br />cout<<"\n\n\n\n\n\t Masukkan angka dalam Queue : ";
<br />cin>>num;
<br />entry=new node;
<br />if(rear==NULL)
<br />{
<br />entry->data=num;
<br />entry->next=NULL;
<br />rear=entry;
<br />front=rear;
<br />}
<br />else
<br />{
<br />entry->data=num;
<br />entry->next=NULL;
<br />rear->next=entry;
<br />Modul 8 Struktur Data (Arie) - 6
<br />rear=entry;
<br />}
<br />cout<<"\n\n\t *** "<<num<<" sudah masuk dalam Queue."<<endl;
<br />cout<<"\n\n\n\t\t Pres any key to return to Menu. ";
<br />getch( );
<br />}
<br />void Linked_list_Queue::Delete( )
<br />{
<br />if(front==NULL)
<br />cout<<"\n\n\n\t *** Error : Queue is empty. \n"<<endl;
<br />else
<br />{
<br />int deleted_element=front->data;
<br />node *temp;
<br />temp=front;
<br />front=front->next;
<br />delete temp;
<br />cout<<"\n\n\n\t *** "<<deleted_element<<" dihapus dari Queue."<<endl;
<br />}
<br />cout<<"\n\n\n\t\t Pres any key to return to Menu. ";
<br />getch( );
<br />}
<br />void Linked_list_Queue::print_list( )
<br />{
<br />print=front;
<br />if(print!=NULL)
<br />cout<<"\n\n\n\n\n\t Angka-angka yang ada dalam Queue adalah :
<br />\n"<<endl;
<br />else
<br />cout<<"\n\n\n\n\n\t *** Tidak ada yang ditampilkan. "<<endl;
<br />while(print!=NULL)
<br />{
<br />cout<<"\t "<<print->data<<endl;
<br />print=print->next;
<br />}
<br />cout<<"\n\n\n\t\t Pres any key to return to Menu. ";
<br />getch( );
<br />}
<br />void Linked_list_Queue ::show_working( )
<br />{
<br />char Key=NULL;
<br />do
<br />{
<br />clrscr( );
<br />gotoxy(5,5);
<br />gotoxy(10,8);
<br />cout<<"Pilih salah satu menu :"<<endl;
<br />gotoxy(15,10);
<br />cout<<"- Press \'I\' to Masukkan data dalam Queue"<<endl;
<br />gotoxy(15,12);
<br />cout<<"- Press \'D\' to Hapus data dari Queue"<<endl;
<br />gotoxy(15,14);
<br />cout<<"- Press \'P\' to Tampilkan data dari Queue"<<endl;
<br />gotoxy(15,16);
<br />Modul 8 Struktur Data (Arie) - 7
<br />cout<<"- Press \'E\' to Exit"<<endl;
<br />Input:
<br />gotoxy(10,20);
<br />cout<<" ";
<br />gotoxy(10,20);
<br />cout<<"Masukkan Pilihan : ";
<br />Key=getche( );
<br />if(int(Key)==27 || Key=='e' || Key=='E')
<br />break;
<br />else if(Key=='i' || Key=='I')
<br />Insert( );
<br />else if(Key=='d' || Key=='D')
<br />Delete( );
<br />else if(Key=='p' || Key=='P')
<br />print_list( );
<br />else
<br />goto Input;
<br />}
<br />while(1);
<br />}
<br />int main( )
<br />{
<br />Linked_list_Queue obj;
<br />obj.show_working( );
<br />return 0;
<br />}
<br />SOAL LATIHAN :
<br />Buatlah program untuk memasukkan dan mengeluarkan data dalam antrian.
<br />Contoh ada di file : queue2.exe
<br />Save dengan nama file : qu1_nim (4 digit nim terakhir)apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com0tag:blogger.com,1999:blog-4754589256962267400.post-8760243295479920282011-03-03T04:52:00.001-08:002011-03-03T04:52:52.818-08:00STACK ( TUMPUKAN)Stack merupakan bentuk khusus dari suatu struktur data, dimana node yang<br />ditambahkan ke dalam list dan diambil dari list hanya pada kepalanya, atau<br />dengan prinsip pengolahannya adalah last-in first-out (LIFO). Pada struktur ini<br />hanya ada dua fungsi utama, yaitu push (memasukkan node ke dalam stack),<br />dan pop (mengambil node dari stack).<br />PENGERTIAN TUMPUKAN<br />Secara sederhana tumpukan bisa diartikan sebagai kumpulan data yang seolaholah<br />diletakkan di atas data yang lain. Dalam suatu tumpukan akan dapat<br />dilakukan operasi penambahan (penyisipan) dan pengambilan (penghapusan)<br />data melalui ujung yang sama, ujung ini merupakan ujung atas tumpukan.<br />Contoh Kasus :<br />Terdapat dua buah kotak yang ditumpuk, kotak yang satu akan ditumpuk diatas<br />kotak yang lainnya. Jika kemudian tumpukan 2 kotak tadi, ditambah kotak<br />ketiga, keempat, kelima, dan seterusnya, maka akan diperoleh sebuah<br />tumpukan kotak yang terdiri dari N kotak.<br />F ATAS<br />E<br />D<br />C<br />B<br />A BAWAH<br />Dapat dilihat bahwa kotak B terletak diatas kotak A dan ada dibawah kotak C.<br />Berdasarkan pada tumpukan tersebut dapat disimpulkan bahwa penambahan<br />dan pengambilan sebuah kotak hanya dapat dilakukan dengan melewati satu<br />ujung saja, yaitu bagian atas.<br />Kotak F adalah kotak paling atas sehingga jika ada kotak lain yang akan<br />disisipkan maka kotak tersebut akan diletakkan pada posisi paling atas (diatas<br />kotak F). Demikian juga pada saat pengambilan kotak, kotak F akan diambil<br />pertama kali.<br />menyisipkan menghapus<br />F ATAS<br />E<br />D<br />C<br />B<br />A BAWAH<br />Modul 7 Struktur Data (Arie) - 2<br />OPERASI PADA TUMPUKAN<br />Ada 2 operasi dasar yang bisa dilaksanakan pada sebuah tumpukan, yaitu :<br />• Menyisipkan data (push)<br />• Menghapus data (pop)<br />Operasi Push<br />Perintah push digunakan untuk memasukkan data ke dalam tumpukan.<br />Push (34)<br />34<br />9 9<br />25 25<br />3 3<br />Contoh :<br />void Push (NOD **T, char item)<br />{<br />NOD *n;<br />n=NodBaru (item);<br />n->next=*T;<br />*T=n;<br />}<br />Operasi Pop<br />Operasi pop adalah operasi untuk menghapus elemen yang terletak pada posisi<br />paling atas dari sebuah tumpukan.<br />Contoh :<br />char Pop (NOD **T)<br />{<br />NOD *n; char item;<br />if (!TumpukanKosong(*T)) {<br />P=*T;<br />*T=(*T)->next;<br />item=P->data;<br />free(P);<br />}<br />return item;<br />}<br />Untuk dapat mengetahui kosong tidaknya suatu tumpukan adalah dengan suatu<br />fungsi yang menghasilkan suatu data bertipe boolean.<br />Contoh :<br />BOOL TumpukanKosong (NOD *T)<br />{<br />return ((BOOL) (T==NULL));<br />}<br />Modul 7 Struktur Data (Arie) - 3<br />PEMANFAATAN TUMPUKAN<br />Pemanfaatan tumpukan antara lain untuk menulis ungkapan dengan<br />menggunakan notasi tertentu.<br />Contoh :<br />( A + B ) * ( C – D )<br />Tanda kurung selalu digunakan dalam penulisan ungkapan numeris untuk<br />mengelompokkan bagian mana yang akan dikerjakan terlebih dahulu.<br />Dari contoh ( A + B ) akan dikerjakan terlebih dahulu, kemudian baru ( C<br />– D ) dan terakhir hasilnya akan dikalikan.<br />A + B * C – D<br />B * C akan dikerjakan terlebih dahulu, hasil yang didapat akan berbeda<br />dengan hasil notasi dengan tanda kurung.<br />Notasi Infix Prefix<br />Cara penulisan ungkapan yaitu dengan menggunakan notasi infix, yang artinya<br />operator ditulis diantara 2 operator.<br />Seorang ahli matematika bernama Jan Lukasiewiccz mengembangkan suatu<br />cara penulisan ungkapan numeris yang disebut prefix, yang artinya operator<br />ditulis sebelum kedua operand yang akan disajikan.<br />Contoh :<br />Infix Prefix<br />A + B + A B<br />A + B – C - + A B C<br />( A + B ) * ( C – D ) * + A B – C D<br />Proses konversi dari infix ke prefix :<br />= ( A + B ) * ( C – D )<br />= [ + A B ] * [ - C D ]<br />= * [ + A B ] [ - C D ]<br />= * + A B - C D<br />Notasi Infix Postfix<br />Cara penulisan ungkapan yaitu dengan menggunakan notasi postfix, yang<br />artinya operator ditulis sesudah operand.<br />Contoh :<br />Infix Postfix<br />16 / 2 16 2 /<br />( 2 + 14 ) * 5 2 14 + 5 *<br />2 + 14 * 5 2 14 5 * +<br />( 6 – 2 ) * ( 5 + 4 ) 6 2 – 5 4 + *<br />Modul 7 Struktur Data (Arie) - 4<br />Proses konversi dari infix ke postfix :<br />= ( 6 - 2 ) * ( 5 + 4 )<br />= [ 6 2 - ] * [ 5 4 + ]<br />= [ 6 2 - ] [ 5 4 + ] *<br />= 6 2 - 5 4 + *<br />Contoh :<br />Penggunaan notasi postfix dalam tumpukan, misal : 2 14 + 5 * = 80<br />push 2 pop 14 push 5 pop 5 pop 80<br />push 14 pop 2 pop 16<br />push 2 + 14 push 16 * 5<br />14 5<br />2 16 16 80<br />CONTOH SOAL :<br />Soal 1<br />Buatlah program untuk memasukkan node baru ke dalam tumpukan.<br />//Program : stack1.cpp<br />#include <stdio.h><br />#include <malloc.h><br />#include <stdlib.h><br />typedef enum { FALSE = 0, TRUE = 1} BOOL;<br />struct nod {<br />char data;<br />struct nod *next;<br />};<br />typedef struct nod NOD;<br />BOOL TumpukanKosong(NOD *T) // Uji tumpukan kosong<br />{<br />return ((BOOL)(T == NULL));<br />}<br />NOD *NodBaru (char item) //Ciptakan Node Baru<br />{<br />NOD *n;<br />n = (NOD*) malloc(sizeof(NOD));<br />if(n != NULL) {<br />n->data = item;<br />n->next = NULL;<br />}<br />return n;<br />}<br />Modul 7 Struktur Data (Arie) - 5<br />void CiptaTumpukan (NOD **T)<br />{<br />*T = NULL; // Sediakan tumpukan Kosong<br />}<br />void Push(NOD **T, char item) // Push<br />{<br />NOD *n;<br />n = NodBaru(item);<br />n->next = *T;<br />*T = n;<br />}<br />char Pop(NOD **T) // Pop<br />{<br />NOD *P; char item;<br />if ( ! TumpukanKosong(*T)) {<br />P = *T;<br />*T = (*T)->next;<br />item = P->data;<br />free(P);<br />}<br />return item;<br />}<br />void CetakTumpukan (NOD *T)<br />{<br />NOD *p;<br />printf("T --> ");<br />for (p = T; p != NULL; p = p->next) {<br />printf("[%c] --> ", p->data); }<br />printf("NULL\n");<br />}<br />int main()<br />{<br />NOD *T;<br />CiptaTumpukan(&T);<br />Push(&T, 'I');<br />Push(&T, 'D');<br />Push(&T, 'E');<br />CetakTumpukan(T);<br />return 0;<br />}<br />Bila program tersebut dijalankan maka :<br />T -> [E] -> [D] -> [I] -> NULL<br />Soal 2<br />Buatlah program untuk menampilkan kode pos (zip code) dari suatu negara<br />bagian dan kota dan semua informasi tersebut dimasukkan ke dalam sebuah<br />tumpukan. Apabila tidak ada keterangan yang dimasukkan berarti tumpukan<br />kosong. Tekan q jika akan keluar.<br />Modul 7 Struktur Data (Arie) - 6<br />//Program:stack2.cpp<br />#include <stdlib.h><br />#include <stdio.h><br />#include <string.h><br />#include <io.h><br />#define MAX_CITY 30<br />#define MAX_STATE 30<br />#define MAX_ZIP 5<br />void main (void);<br />int is_empty (struct node *);<br />int push (struct node **);<br />int pop (struct node **);<br />void search (struct node **);<br />void free_nodes (struct node **pstack);<br />struct node {<br />char zip_code[MAX_ZIP+1];<br />char city[MAX_CITY];<br />char state[MAX_STATE];<br />struct node *link;<br />};<br />void main (void)<br />{<br />struct node *pstack = NULL;<br />int ok_so_far = 1, no_of_nodes = 0;<br />while (ok_so_far == 1) {<br />ok_so_far = push(&pstack);<br />if (ok_so_far == 1)<br />no_of_nodes ++;<br />else if(ok_so_far == 0) {<br />puts("\nAn unexpected error has occurred - terminating program");<br />exit(1); //Abort program<br />}<br />}<br />search (&pstack); //search linked list<br />free_nodes(&pstack); //release memory back to OS when done<br />}<br />int push(struct node **pstack)<br />{<br />struct node *new_ptr; //pointer for new struct<br />new_ptr = (struct node *) malloc(sizeof(struct node)); //memory for new node<br />if(new_ptr == (struct node *) NULL) //if malloc returns NULL<br />{<br />printf("ERROR! Unable to allocate memory - Abort\n");<br />free(new_ptr);<br />return (0); //return 0 so calling function knows an error occurred<br />}<br />else<br />{<br />printf("\n\nEnter %d digit zip code or 'q' to quit>>", MAX_ZIP);<br />gets(new_ptr->zip_code); //input zip code<br />new_ptr->zip_code[MAX_ZIP] = '\0'; //NULL to 6th char in zip_code<br />if (strcmp(new_ptr->zip_code, "q") != 0) {<br />printf("\nEnter a less than %d character state name>>\n",<br />MAX_STATE);<br />Modul 7 Struktur Data (Arie) - 7<br />gets(new_ptr->state); //input state<br />printf("\nEnter a less than %d character city name>>\n",<br />MAX_CITY);<br />gets(new_ptr->city); //input city<br />new_ptr->link = *pstack;<br />*pstack = new_ptr;<br />return (1); //return 1 so calling func will continue to loop<br />}<br />else return (2); //return 2 so calling func to stop looping<br />}<br />}<br />void search (struct node **pstack)<br />{<br />struct node *ptemp;<br />int test = 0;<br />char ch, find[6];<br />ptemp = *pstack;<br />printf("\n\nEnter %d digit zip code to search for \nor 'e' to print entire list>>",<br />MAX_ZIP);<br />gets(find); //input zip code<br />find[MAX_ZIP] = '\0'; //assign NULL to 6th char in find array<br />if (find[0] =='E' || find[0] =='e') //if user wants to view entire list<br />{<br />test = 1;<br />while (test != 0) //while stack is not empty print<br />test = pop (pstack); //info from stack and free nodes<br />}<br />else //otherwise search for zip code<br />{<br />while (test == 0 || ptemp != NULL) //while not found nor at the end of<br />list<br />{<br />if (strcmp(ptemp->zip_code, find) == 0)<br />{<br />test = 1;<br />printf("Zip Code: %s\n", ptemp->zip_code);<br />printf("State: %s\n", ptemp->state);<br />printf("City: %s\n\n", ptemp->city);<br />}<br />else if (ptemp == NULL)<br />{<br />printf("The zip code %s was not found.\n", find);<br />test = 1;<br />}<br />ptemp = ptemp->link;<br />}<br />puts ("\nType 'y' if you would you like to see the entire list");<br />puts ("or any other key to continue>>");<br />if (ch == 'y' || ch == 'Y')<br />{<br />test = 1;<br />while (test != 0)<br />test = pop (pstack);<br />}<br />}<br />}<br />Modul 7 Struktur Data (Arie) - 8<br />int pop (struct node **pstack)<br />{<br />struct node *temp;<br />if (is_empty(*pstack)== 1)<br />{<br />printf("\nStack is now empty");<br />return(0);<br />}<br />else<br />{<br />temp = *pstack;<br />printf("Zip Code: %s\n", temp->zip_code);<br />printf("State: %s\n", temp->state);<br />printf("City: %s\n\n", temp->city);<br />*pstack = (*pstack)->link;<br />free(temp);<br />return(1);<br />}<br />}<br />int is_empty (struct node *stack) //test if stack points to NULL<br />{<br />if (stack == NULL)<br />return(1); //if stack does point to NULL return 1 or true<br />return(0); //othrewise stack is not empty<br />}<br />void free_nodes (struct node **pstack)<br />{<br />struct node *temp; //temp pointer used for free()ing memory<br />while (*pstack != NULL)<br />{<br />temp = *pstack;<br />*pstack = (*pstack)->link;<br />free(temp); //release popped node's memory back to Operating System<br />}<br />}apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com1tag:blogger.com,1999:blog-4754589256962267400.post-30137700912282948542011-03-03T04:51:00.000-08:002011-03-03T04:52:27.598-08:00LINKED LISTKonsep dasar struktur data dinamis adalah alokasi memori yang dilakukan<br />secara dinamis. Pada konsep ini, terdapat suatu struktur yang disebut dengan<br />struktur referensi diri (self-referential structure), mempunyai anggota pointer<br />yang menunjuk ke struktur yang sama dengan dirinya sendiri.<br />Struktur data dinamis sederhana dapat dibagi menjadi empat jenis, yaitu :<br />1. Linked list<br />2. Stack<br />3. Queue<br />4. Binary tree<br />Definisi ini dapat dituliskan secara sederhana dengan struktur :<br />struct node {<br />int info;<br />struct node *nextPtr;<br />}<br />Struktur ini mempunyai dua anggota, yaitu bilangan bulat info dan pointer<br />nextPtr. Variabel pointer nextPtr ini menunjuk ke struktur bertipe struct node,<br />yang sama dengan deklarasi induknya.<br />Untuk membuat dan menangani struktur data dinamis dibutuhkan alokasi<br />memori dinamis agar tersedia ruang bagi node-node yang ada. Fungsi malloc,<br />free, dan operator sizeof banyak digunakan dalam alokasi memori dinamis ini.<br />Contoh :<br />typedef struct node NODE;<br />typedef NODE *NODEPTR;<br />NODEPTR newPtr = malloc (sizeof (NODE));<br />newPtr -> info = 15;<br />newPtr -> nextPtr = NULL;<br />Fungsi free digunakan untuk menghapus memori yang telah digunakan untuk<br />node yang ditunjuk oleh pointer tertentu. Jadi free (newPtr); akan menghapus<br />memori tempat node yang ditunjuk oleh newPtr.<br />DEFINISI LINKED LIST<br />Linked list adalah suatu cara untuk menyimpan data dengan struktur sehingga<br />dapat secara otomatis menciptakan suatu tempat baru untuk menyimpan data<br />yang diperlukan. Program akan berisi suatu struct atau definisi kelas yang berisi<br />variabel yang memegang informasi yang ada didalamnya, dan mempunyai suatu<br />pointer yang menunjuk ke suatu struct sesuai dengan tipe datanya.<br />Struktur dinamis ini mempunyai beberapa keuntungan dibanding struktur array<br />yang bersifat statis. Struktur ini lebih dinamis, karena banyaknya elemen<br />dengan mudah ditambah atau dikurangi, berbeda dengan array yang ukurannya<br />bersifat tetap.<br />Manipulasi setiap elemen seperti menyisipkan, menghapus, maupun menambah<br />dapat dilakukan dengan lebih mudah.<br />Modul 6 Struktur Data (Arie) - 2<br />Contoh :<br />//Program:link1.cpp<br />#include <stdio.h><br />#include <stdlib.h><br />#include <malloc.h><br />typedef struct nod {<br />int data;<br />struct nod *next;<br />} NOD, *NODPTR;<br />void CiptaSenarai(NODPTR *s)<br />{<br />*s = NULL;<br />}<br />NODPTR NodBaru(int m)<br />{<br />NODPTR n;<br />n = (NODPTR) malloc(sizeof(NOD));<br />if(n != NULL) {<br />n -> data = m;<br />n -> next = NULL;<br />}<br />return n;<br />}<br />void SisipSenarai (NODPTR *s, NODPTR t, NODPTR p)<br />{<br />if (p==NULL) {<br />t -> next = *s;<br />*s = t;<br />}<br />else {<br />t -> next = p -> next;<br />p ->next = t;<br />}<br />}<br />void CetakSenarai (NODPTR s)<br />{<br />NODPTR ps;<br />for (ps = s; ps != NULL; ps = ps -> next)<br />printf("%d -->", ps -> data);<br />printf("NULL\n");<br />}<br />int main ()<br />{<br />NODPTR pel;<br />NODPTR n;<br />CiptaSenarai(&pel);<br />n = NodBaru(55);<br />SisipSenarai(&pel, n, NULL);<br />Modul 6 Struktur Data (Arie) - 3<br />n= NodBaru(75);<br />SisipSenarai(&pel, n, NULL);<br />CetakSenarai(pel);<br />return 0;<br />}<br />Bila program dijalankan maka :<br />75->55->NULL<br />TEKNIK DALAM LINKED LIST<br />Pengulangan Linked List<br />Secara umum pengulangan ini dikenal sebagai while loop. Kepala pointer (head<br />pointer) dikopikan dalam variabel lokal current yang kemudian dilakukan<br />perulangan dalam linked list. Hasil akhir dalam linked list dengan<br />current!=NULL. Pointer lanjut dengan current=current->next.<br />Contoh :<br />// Return the number of nodes in a list (while-loop version)<br />int Length(struct node * head) {<br />int count = 0;<br />struct node* current = head;<br />while (current != NULL) {<br />count++;<br />current=current->next;<br />}<br />return (count);<br />}<br />Mengubah Pointer Dengan Referensi Pointer<br />Banyak fungsi pada linked list perlu untuk merubah pointer kepala. Pointer ke<br />pointer disebut dengan “reference pointer”.<br />Langkah utamanya dalam teknik ini adalah :<br />• Merancang fungsi untuk mengambil pointer ke pointer kepala. Untuk<br />melewati pointer ke “value of interest” yang dibutuhkan untuk diubah.<br />Untuk mengubah struct node*, lewati struct node**.<br />• Gunakan ‘&’ dalam panggilan untuk menghitung dan melewati pointer ke<br />value of interest.<br />• Gunakan ‘*’ pada parameter dalam fungsi pemanggil untuk mengakses<br />dan mengubah value of interest.<br />Contoh :<br />void ChangeToNull (struct node** headRef)<br />*headRef=NULL;<br />void ChangeCaller() {<br />struct node* head1;<br />struct node* head2;<br />ChangeToNull (&head1);<br />ChangeToNull (&head2);<br />}<br />Modul 6 Struktur Data (Arie) - 4<br />Fungsi sederhana tersebut akan membuat pointer kepala ke NULL dengan<br />menggunakan parameter reference. Gambar berikut menunjukkan bagaimana<br />pointer headRef dalam ChangeToNull menunjuk ke head1 pada Change Caller.<br />ChangeCaller()<br />head1<br />ChangeToNull(&head1)<br />headRef<br />Pointer headRef dalam ChangeToNull menunjuk ke head1<br />Membuat Kepala Senarai Dengan Perintah Push()<br />Cara termudah untuk membuat sebuah senarai dengan menambah node pada<br />“akhir kepala” adalah dengan push().<br />Contoh :<br />struct node* AddAtHead() {<br />struct node* head = NULL;<br />int i;<br />for ( i=1; i<6; i++) {<br />push (&head, i);<br />}<br />// head == { 5, 4, 3, 2, 1 };<br />return (head);<br />}<br />Dalam membuat tambahan node pada akhir senarai (list) dengan menggunakan<br />perintah Push(), jika terjadi kesalahan maka urutan akan terbalik.<br />Membuat Ekor Pada Akhir Senarai<br />Menambah ekor pada senarai akan melibatkan penempatan node terakhir, dan<br />kemudian merubahnya .next field dari NULL untuk menunjuk node baru seperti<br />variabel tail dalam contoh yaitu menambah node 3 ke akhir daftar {1,2}<br />Stack Heap<br />head<br />tail<br />newNode<br />Membuat ekor pada akhir senarai<br />Untuk memasukkan atau menghapus node di dalam senarai, pointer akan<br />dibutuhkan ke node sebelum posisi, sehingga akan dapat mengubah .next field.<br />Agar dapat menambahkan node di akhir ekor pada data senarai {1, 2, 3, 4, 5},<br />dengan kesulitan node pertama pasti akan ditambah pada pointer kepala,<br />tetapi semua node yang lain dimasukkan sesudah node terakhir dengan<br />1 2<br />3<br />Modul 6 Struktur Data (Arie) - 5<br />menggunakan pointer ekor. Untuk menghubungkan dua hal tersebut adalah<br />dengan menggunakan dua fungsi yang berbeda pada setiap permasalahan.<br />Fungsi pertama adalah menambah node kepala, kemudian melakukan<br />perulangan yang terpisah yang menggunakan pointer ekor untuk menambah<br />semua node yang lain. Pointer ekor akan digunakan untuk menunjuk pada node<br />terakhir, dan masing-masing node baru ditambah dengan tail->next.<br />Contoh:<br />struct node* BuildWithSpecialCase () {<br />struct node* head = NULL;<br />struct node* tail;<br />int i;<br />push (&head, 1);<br />tail = head;<br />for (i=2; i<6; i++) {<br />push (&(tail->next), i);<br />tail = tail->next;<br />}<br />return (head);<br />}<br />Membuat Referansi Lokal<br />Dengan menggunakan “reference pointer” lokal, pointer akan selalu menunjuk<br />ke pointer terakhir dalam senarai.<br />Semua tambahan pada senarai dibuat dengan reference pointer. Reference<br />pointer tidak menunjuk ke pointer kepala, tetapi menunjuk ke .next field<br />didalam node terakhir dalam senarai.<br />Contoh :<br />struct node* BuildWithLocalRef() {<br />struct node* head = NULL;<br />struct node** lastPtrRef=&head;<br />int i;<br />for (i=2; i<6; i++) {<br />Push (lastPtrRef, i);<br />lastPtrRef=&((*lastPtrRef)->next);<br />}<br />return (head);<br />}<br />Cara kerja teknik ini adalah :<br />• Pada puncak putaran, lastPtrRef menunjuk pointer terakhir dalam<br />senarai. Pada permulaannya menunjuk ke pointer kepala itu sendiri.<br />Berikutnya menunjuk ke .next field di dalam node terakhir dalam<br />senarai.<br />• Push(lastPtrRef); menambah node baru pada pointer akhir. Node baru<br />menjadi node terakhir dalam senarai.<br />• lastPtrRef=&((*lastPtrRef)->next; lastPtrRef lanjut ke .next field dan<br />.next field sekarang menjadi pointer terakhir dalam senarai.<br />Modul 6 Struktur Data (Arie) - 6<br />Stack Heap<br />head<br />lastPtrRef<br />Membuat ekor pada akhir senarai<br />OPERASI DALAM LINKED LIST<br />Menambah Node Baru<br />Untuk menambahkan sebuah node di dalam senarai, perlu didefinisikan sebuah<br />kepala (head) dan ekor (tail). Pada awal senarai, posisi kepala dan ekor masih<br />menjadi satu. Setelah ada tambahan node yang baru, maka posisinya berubah.<br />Posisi kepala tetap pada awal senarai dan posisi ekor pada akhir senarai atau<br />node yang baru. Bila ada tambahan node, maka posisi ekor akan bergeser<br />sampai ke belakang dan akhir senarai ditunjukkan dengan NULL.<br />Contoh :<br />void SLList::AddANode()<br />{<br />Tail->Next = new List;<br />Tail=Tail->Next;<br />}<br />Penambahan Node<br />Sebelum Head<br />Tail<br />Langkah 1 Head New Node<br />Tail Next<br />Langkah 2 Head NULL<br />Tail<br />Menghapus Node<br />Contoh :<br />void SLList::DeleteANode(ListPtr corpse)<br />{<br />ListPtr temp;<br />if (corpse==Head) {<br />temp=Head;<br />Head=Head->Next;<br />delete temp;<br />}<br />1 2<br />Modul 6 Struktur Data (Arie) - 7<br />else if (corpse==Tail) {<br />temp=Tail;<br />Tail=Previous(Tail);<br />Tail->Next=NULL;<br />delete temp;<br />}<br />else {<br />temp=Previous(corpse);<br />temp->Next=corpse->Next;<br />delete corpse;<br />}<br />CurrentPtr=Head;<br />}<br />CONTOH LATIHAN :<br />Buatlah program untuk memasukkan beberapa data dalam sebuah senarai<br />(linked list), jika akan mengakhiri tekan n maka akan muncul semua node yang<br />masuk ke dalam linked list tersebut.<br />//Program:link2<br />#include <stdio.h><br />#include <conio.h><br />#include <ctype.h><br />#include <stdlib.h><br />typedef struct node {<br />int lkey;<br />char name[10];<br />struct node* next;<br />} TNODE;<br />TNODE *first, *last;<br />int LoadNode(TNODE *p);<br />void FreeNode(TNODE *p);<br />void PrintNode(TNODE *p);<br />void CreateList()<br />{<br />TNODE *p;<br />int n=sizeof(TNODE);<br />first=last=0;<br />for(;;)<br />{<br />if( (p=(TNODE*)malloc(n))==0 )<br />{<br />printf("\nmemori tidak cukup");<br />break;<br />}<br />if(LoadNode(p)!=1)<br />{<br />FreeNode(p);<br />break;<br />}<br />Modul 6 Struktur Data (Arie) - 8<br />p->next=0;<br />if (first==0)<br />first=last=p;<br />else {<br />last->next=p;<br />last=p;<br />}<br />}<br />}<br />int LoadNode(TNODE *p)<br />{<br />char opt;<br />printf("\nMasukkan node baru?");<br />opt=getche();<br />opt=toupper(opt);<br />if(opt!='N') {<br />puts("\nMasukkan data untuk node:");<br />printf("\nlkey:\t");<br />if (scanf("%d",&(p->lkey))!=1) return 0;<br />printf("\nname:\t");if (scanf("%s",p->name)!=1) return 0;<br />return 1;<br />}<br />else<br />return -1;<br />}<br />void FreeNode(TNODE *p) {<br />free(p);<br />}<br />void ViewAllList()<br />{<br />TNODE *p;<br />p=first;<br />while(p) {<br />PrintNode(p);<br />p=p->next;<br />}<br />}<br />TNODE* FindNode(int key)<br />{<br />TNODE *p;<br />p=first;<br />while(p) {<br />if(p->lkey == key) return p;<br />p=p->next;<br />}<br />return 0;<br />}<br />void PrintNode(TNODE *p)<br />{<br />if(p) printf("\n%d\t%s",p->lkey,p->name);<br />}<br />Modul 6 Struktur Data (Arie) - 9<br />TNODE* InsertBeforeFirst()<br />{<br />TNODE *p;<br />int n=sizeof(TNODE);<br />if (((p=(TNODE*)malloc(n))!=0) && (LoadNode(p)==1))<br />{<br />if (first==0) {<br />p->next=0;<br />first=last=p;<br />}<br />else {<br />p->next=first;<br />first=p;<br />}<br />return p;<br />}<br />if(p==0)<br />printf("\nMemori tidak cukup");<br />else<br />FreeNode(p);<br />return 0;<br />}<br />TNODE* InsertBeforeKey(int key)<br />{<br />TNODE *p, *q, *q1;<br />int n=sizeof(TNODE);<br />q1=0;<br />q=first;<br />while(q) {<br />if(q->lkey == key) break;<br />q1=q;<br />q=q->next;<br />}<br />if(q==0) {<br />printf("\nTidak ada node yang mempunyai kunci atau senarai kosong");<br />return 0;<br />}<br />if (((p=(TNODE*)malloc(n))!=0) && (LoadNode(p)==1)) {<br />if(q==first) {<br />p->next=first;<br />first=p;<br />}<br />else {<br />p->next=q;<br />q1->next=p;<br />}<br />return p;<br />}<br />if(p==0)<br />printf("\nMemori tidak cukup");<br />else<br />FreeNode(p);<br />return 0;<br />}<br />Modul 6 Struktur Data (Arie) - 10<br />TNODE* InsertAfterKey(int key)<br />{<br />TNODE *p, *q;<br />int n=sizeof(TNODE);<br />q=first;<br />while(q) {<br />if(q->lkey == key) break;<br />q=q->next;<br />}<br />if(q==0) {<br />printf("\nTidak ada node yang mempunyai kunci atau senarai kosong");<br />return 0;<br />}<br />if (((p=(TNODE*)malloc(n))!=0) && (LoadNode(p)==1))<br />{<br />if(q==last) {<br />p->next=0;<br />last->next=p;<br />last=p;<br />}<br />else {<br />p->next=q->next;<br />q->next=p;<br />}<br />return p;<br />}<br />if(p==0)<br />printf("\nMemori tidak cukup");<br />else<br />FreeNode(p);<br />return 0;<br />}<br />TNODE* InsertAfterLast()<br />{<br />TNODE *p;<br />int n=sizeof(TNODE);<br />if (((p=(TNODE*)malloc(n))!=0) && (LoadNode(p)==1))<br />{<br />p->next=0;<br />if (first==0)<br />first=last=p;<br />else {<br />last->next=p;<br />last=p;<br />}<br />return p;<br />}<br />if(p==0)<br />printf("\nMemori tidak cukup");<br />else<br />FreeNode(p);<br />return 0;<br />}<br />Modul 6 Struktur Data (Arie) - 11<br />void RemoveFirst()<br />{<br />TNODE *p;<br />if(first==0)<br />return;<br />if(first==last) {<br />FreeNode(first);<br />first=last=0;<br />return;<br />}<br />p=first;<br />first=first->next;<br />FreeNode(p);<br />}<br />void RemoveLast()<br />{<br />TNODE *p, *q;<br />if(first==0)<br />return;<br />if(first==last) {<br />FreeNode(first);<br />first=last=0;<br />return;<br />}<br />q=0;<br />p=first;<br />while(p!=last) {<br />q=p;<br />p=p->next;<br />}<br />p=last;<br />FreeNode(p);<br />q->next=0;<br />last=q;<br />}<br />void RemoveByKey(int key)<br />{<br />TNODE *p, *q;<br />if(first==0)<br />return;<br />q=0;<br />p=first;<br />while(p) {<br />if(p->lkey == key) break;<br />q=p;<br />p=p->next;<br />}<br />if(!p) {<br />printf("\nTidak ada node yang mempunyai kunci");<br />return;<br />}<br />Modul 6 Struktur Data (Arie) - 12<br />if(first==last) {<br />FreeNode(first);<br />first=last=0;<br />return;<br />}<br />if(p==first) {<br />first=first->next;<br />FreeNode(p);<br />return;<br />}<br />if(p==last) {<br />q->next=0;<br />last=q;<br />FreeNode(p);<br />return;<br />}<br />q->next=p->next;<br />FreeNode(p);<br />}<br />void DeleteList()<br />{<br />TNODE *p;<br />p=first;<br />while(p) {<br />first=first->next;<br />FreeNode(p);<br />p=first;<br />}<br />last=0;<br />}<br />void main()<br />{<br />CreateList();<br />ViewAllList();<br />InsertAfterLast();<br />ViewAllList();<br />RemoveFirst();<br />ViewAllList();<br />InsertAfterKey(1);<br />ViewAllList();<br />RemoveByKey(1);<br />ViewAllList();<br />DeleteList();<br />ViewAllList();<br />}apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com1tag:blogger.com,1999:blog-4754589256962267400.post-77901576035537865752011-03-03T04:49:00.000-08:002011-03-03T04:50:52.632-08:00SORTSort adalah suatu proses pengurutan data yang sebelumnya disusun secara acak
<br />atau tidak teratur menjadi urut dan teratur menurut suatu aturan tertentu.
<br />Biasanya pengurutan terbagi menjadi 2 yaitu :
<br />�� Ascending (pengurutan dari karakter / angka kecil ke karakter / angka
<br />besar)
<br />�� Descending (pengurutan dari karakter / angka besar ke karakter / angka
<br />kecil)
<br />Ada banyak cara yang dapat dilakukan untuk melakukan proses pengurutan dari
<br />paling tinggi ke paling rendah atau sebaliknya. Untuk masalah pengurutan pada
<br />array kita tidak dapat langsung menukar isi dari variabel yang ada, tetapi
<br />menggunakan metode penukaran (swap).
<br />Contoh :
<br />Data yang terdiri dari nilai dengan array, nilai[1] = 10 dan nilai[2] = 8 akan
<br />ditukar isi nilainya sehingga akan menghasilkan nilai[1] = 8 dan nilai[2] = 10.
<br />Proses penukaran tidak dapat langsung dilakukan dengan cara :
<br />nilai[1] = nilai[2];
<br />nilai[2] = nilai[1];
<br />Cara yang tepat adalah :
<br />temp = nilai[1];
<br />nilai[1] = nilai[2];
<br />nilai[2] = temp;
<br />Untuk melakukan proses pengurutan dapat menggunakan beberapa metode
<br />antara lain :
<br />1. Bubble Sort
<br />2. Selection Sort
<br />3. Quick Sort
<br />METODE SORTING
<br />1. Bubble Sort
<br />Bubble sort adalah suatu metode pengurutan yang membandingkan elemen
<br />yang sekarang dengan elemen berikutnya. Apabila elemen yang sekarang
<br />lebih besar dari elemen yang berikutnya, maka posisinya akan ditukar, bila
<br />tidak maka posisi akan tetap.
<br />Misalkan data sebagai berikut :
<br />5, 34, 32, 25, 75, 42, 22, 2
<br />Pengurutan akan dilakukan dengan mengurutkan 8 data dari yang terkecil
<br />sampai yang terbesar.
<br />Modul 5 Struktur Data (Arie) - 2
<br />• Dimulai dengan dua angka pertama yaitu angka 5 dan 34, untuk
<br />pengurutan dari kecil ke besar maka akan diperoleh posisi tidak berubah
<br />karena angka 5 < angka 34.
<br />• Langkah berikutnya akan membandingkan angka 34 dan 32. Karena angka
<br />34 > 32 maka akan terjadi pertukaran posisi, sehingga hasil urutan
<br />datanya menjadi 5, 32, 34, 25, 75, 42, 22, 2.
<br />• 34 > 25 = 25, 34 (berubah)
<br />• 34 < 75 = 34, 75 (tetap)
<br />• 75 > 42 = 42, 75 (berubah)
<br />• 75 > 22 = 22, 75 (berubah)
<br />• 75 > 2 = 2, 75 (berubah)
<br />Hasil sementara menjadi 5, 32, 25, 34, 42, 22, 2, 75
<br />Langkah kedua :
<br />• 5 < 32 = 5, 32 (tetap)
<br />• 32 > 25 = 25, 32 (berubah)
<br />• 32 < 34 = 32, 34 (tetap)
<br />• 34 < 42 = 34, 42 (tetap)
<br />• 42 > 22 = 22, 42 (berubah)
<br />• 42 > 2 = 2, 42 (berubah)
<br />• 42 < 75 = 42, 75 (tetap)
<br />Hasil sementara menjadi 5, 25, 32, 34, 22, 2, 42, 75
<br />Langkah ketiga :
<br />• 5 < 25 = 5, 25 (tetap)
<br />• 25 < 32 = 25, 32 (tetap)
<br />• 32 < 34 = 32, 34 (tetap)
<br />• 34 > 22 = 22, 34 (berubah)
<br />• 34 > 2 = 2, 34 (berubah)
<br />• 34 < 42 = 34, 42 (tetap)
<br />• 42 < 75 = 42, 75 (tetap)
<br />Hasil sementara menjadi 5, 25, 32, 22, 2, 34, 42, 75
<br />Sampai langkah terakhir yaitu langkah ketujuh :
<br />• 5 > 2 = 2, 5 (berubah)
<br />• 5 < 22 = 5, 22 (tetap)
<br />• 22 < 25 = 22, 25 (tetap)
<br />• 25 < 32 = 25, 32 (tetap)
<br />• 32 < 34 = 32, 34 (tetap)
<br />• 34 < 42 = 34, 42 (tetap)
<br />• 42 < 75 = 42, 75 (tetap)
<br />Hasil sementara menjadi 2, 5, 22, 25, 32, 34, 42, 75
<br />Proses pengurutan data tersebut membutuhkan tujuh langkah atau tujuh
<br />kali perulangan.
<br />Contoh :
<br />//Program:buble.cpp
<br />#include <iostream.h>
<br />#include <iomanip.h>
<br />void main()
<br />{
<br />int NumList[8] = {5, 34, 32, 25, 75, 42, 22, 2};
<br />Modul 5 Struktur Data (Arie) - 3
<br />int Swap;
<br />cout<<"Data sebelum diurutkan: \n";
<br />for(int ctr=0; ctr<8; ctr++)
<br />{
<br />cout<< setw( 3 ) <<NumList[ctr];
<br />}
<br />cout<<"\n\n";
<br />for(int i=0; i<7; i++)
<br />for(int ii=0; ii<7; ii++)
<br />if (NumList[ii] > NumList[ii + 1])
<br />{
<br />Swap = NumList[ii];
<br />NumList[ii] = NumList[ii + 1];
<br />NumList[ii + 1] = Swap;
<br />}
<br />cout<<"Data setelah diurutkan: \n";
<br />for (int iii=0; iii<8; iii++)
<br />cout<< setw( 3 ) << NumList[iii];
<br />cout<< endl <<endl;
<br />}
<br />Bila program tersebut dijalankan maka :
<br />Data sebelum diurutkan :
<br />5, 34, 32, 25, 75, 42, 22, 2
<br />Data setelah diurutkan :
<br />2, 5, 22, 25, 32, 34, 42, 75
<br />Data pada program diatas akan diurutkan menurut ascending atau dari kecil ke
<br />besar.
<br />2. Selection Sort
<br />Selection sort adalah suatu metode pengurutan yang membandingkan
<br />elemen yang sekarang dengan elemen berikutnya sampai ke elemen yang
<br />terakhir. Jika ditemukan elemen lain yang lebih kecil dari elemen sekarang
<br />maka dicatat posisinya dan langsung ditukar.
<br />Misalkan data sebagai berikut :
<br />5, 34, 32, 25, 75, 42, 22, 2
<br />Data tersebut akan diurutkan dengan ascending atau dari kecil ke besar.
<br />Langkah pertama :
<br />Posisi : 1 2 3 4 5 6 7 8
<br />Data : 5 34 32 25 75 42 22 2
<br />Pembanding Posisi
<br />• 5 < 34 1
<br />• 5 < 32 1
<br />• 5 < 25 1
<br />• 5 < 75 1
<br />• 5 < 42 1
<br />• 5 < 22 1
<br />• 5 > 2 8
<br />Tukar data pada posisi 1 dengan data posisi 8.
<br />Hasil sementara menjadi 2, 34, 32, 25, 75, 42, 22, 5
<br />Modul 5 Struktur Data (Arie) - 4
<br />Langkah kedua :
<br />Posisi : 1 2 3 4 5 6 7 8
<br />Data : 2 34 32 25 75 42 22 5
<br />Pembanding Posisi
<br />• 34 > 32 3
<br />• 32 > 25 4
<br />• 25 < 75 4
<br />• 25 < 42 4
<br />• 25 > 22 7
<br />• 22 > 2 8
<br />Tukar data pada posisi 2 dengan data posisi 8.
<br />Hasil sementara menjadi 2, 5, 32, 25, 75, 42, 22, 34
<br />Langkah ketiga :
<br />Posisi : 1 2 3 4 5 6 7 8
<br />Data : 2 5 32 25 75 42 22 34
<br />Pembanding Posisi
<br />• 32 > 25 4
<br />• 25 > 75 4
<br />• 25 < 42 4
<br />• 25 > 22 7
<br />• 22 < 34 7
<br />Tukar data pada posisi 3 dengan data posisi 7.
<br />Hasil sementara menjadi 2, 5, 22, 25, 75, 42, 32, 34
<br />Langkah keenam (langkah terakhir) :
<br />Posisi : 1 2 3 4 5 6 7 8
<br />Data : 2 5 22 25 32 34 75 42
<br />Pembanding Posisi
<br />• 75 > 42 8
<br />Tukar data pada posisi 7 dengan data posisi 8.
<br />Hasil sementara menjadi 2, 5, 22, 25, 32, 34, 42, 75
<br />Proses pengurutan data tersebut membutuhkan enam langkah atau enam
<br />kali perulangan.
<br />Contoh :
<br />void SelectionSort (int Array[ ], const int Size)
<br />{
<br />int i, j, smallest, temp;
<br />for (i=0; i<Size; i++)
<br />{
<br />smallest=i;
<br />for (j=i; j<Size; j++)
<br />{
<br />if (array[smallest]>array[j])
<br />{
<br />smallest=j;
<br />}
<br />}
<br />temp=array[i];
<br />array[i]=array[smallest];
<br />array[smallest]=temp;
<br />}
<br />}
<br />Modul 5 Struktur Data (Arie) - 5
<br />3. Quick Sort
<br />Quick sort adalah suatu metode pengurutan yang membandingkan suatu
<br />elemen (pivot) dengan elemen yang lain dan menyusunnya sedemikian rupa
<br />sehingga elemen yang lain yang lebih kecil daripada pivot terletak disebelah
<br />kiri pivot sedangkan elemen yang lebih besar dari pivot diletakkan di
<br />sebelah kanan pivot.
<br />Sehingga akan terbentuk dua sub list yaitu yang teletak disebelah kiri pivot
<br />dan sebelah kanan pivot.
<br />List yang sebelah kiri pivot juga diterapkan aturan seperti pivot, yaitu
<br />membandingkan dengan elemen yang lain. Jika lebih kecil akan diletakkan
<br />di sebelah kiri, jika lebih besar akan diletakkan di sebelah kanan.
<br />Contoh :
<br />void QuickSort (array A, int L, int N)
<br />{
<br />if L<N
<br />M:=Partition (A, L, N)
<br />QuickSort (A, L, M-1)
<br />QuickSort (A, M+1, N)
<br />endif
<br />}
<br />void Partition (array A, int L, int N)
<br />{
<br />select M, where L <= M <=N
<br />reorder A(L) ... A(N) so that I<M implies A(I) <= A(M), and I>M
<br />implies A(I) >= A(M)
<br />return M
<br />}
<br />Contoh :
<br />Data yang akan diurutkan adalah : 20, 10, 15, 5, 8, 3
<br />Bilangan yang terletak diantara kurung buka dan kurung tutup adalah pivot
<br />i bergerak dari kiri ke kanan sampai mendapat nilai >= pivot
<br />j bergerak dari kanan ke kiri sampai mendapat nilai < pivot
<br />Langkah 1
<br />posisi 1 2 3 4 5 6
<br />data 20 10 (15) 5 8 3
<br />i j
<br />i berhenti pada posisi 1 karena langsung mendapatkan nilai yang lebih
<br />besar dari pivot (15) yaitu 20
<br />j berhenti pada posisi 6 karena langsung mendapatkan nilai yang lebih
<br />kecil dari pivot (15) yaitu 3
<br />karena i<j maka data yang ditunjuk oleh i ditukar dengan data yang
<br />ditunjuk j, sehingga data berubah menjadi :
<br />3 10 15 5 8 20
<br />Langkah 2
<br />posisi 1 2 3 4 5 6
<br />data 3 10 (15) 5 8 20
<br />i j
<br />Modul 5 Struktur Data (Arie) - 6
<br />i berhenti pada posisi 3 karena tidak dapat menemukan nilai yang lebih
<br />besar dari pivot (15)
<br />j berhenti pada posisi 5 karena langsung mendapatkan nilai yang lebih
<br />kecil dari pivot (15) yaitu 8
<br />karena i<j maka data yang ditunjuk oleh i ditukar dengan data yang
<br />ditunjuk j, sehingga data berubah menjadi :
<br />3 10 8 5 15 20
<br />Langkah 3
<br />posisi 1 2 3 4 5 6
<br />data 3 10 (8) 5 15 20
<br />i j
<br />i berhenti pada posisi 2 karena langsung mendapatkan nilai yang lebih
<br />besar dari pivot (8) yaitu 10
<br />j berhenti pada posisi 4 karena langsung mendapatkan nilai yang lebih
<br />kecil dari pivot (8) yaitu 5
<br />karena i<j maka data yang ditunjuk oleh i ditukar dengan data yang
<br />ditunjuk j, sehingga data berubah menjadi :
<br />3 5 8 10 15 20
<br />Hasil akhirnya adalah : 3 5 8 10 15 20
<br />CONTOH SOAL :
<br />Soal 1
<br />Buatlah program untuk melakukan pengurutan data secara menurun (dari besar
<br />ke kecil) dengan menukar data berikut menggunakan bubble sort.
<br />Data : 21, 83, 42, 11, 10, 9, 3, 20, 102, 27, 15, 92, 2
<br />Bila program dijalankan maka :
<br />102, 92, 83, 42, 27, 21, 20, 15, 11, 10, 9, 3, 2apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com0tag:blogger.com,1999:blog-4754589256962267400.post-4947928751502515862011-03-03T04:43:00.001-08:002011-03-03T04:45:10.033-08:00STRUKTURStruktur adalah sekumpulan variabel yang masing-masing dapat berbeda tipe,
<br />dan dikelompokkan ke dalam satu nama (menurut Pascal, struktur juga dikenal
<br />sebagai record). Struktur membantu mengatur data-data yang rumit, khususnya
<br />dalam program yang besar, karena struktur membiarkan sekelompok variabel
<br />diperlakukan sebagai satu unit daripada sebagai entity yang terpisah.
<br />Salah satu contoh struktur tradisional adalah record daftar gaji karyawan,
<br />dimana karyawan digambarkan dengan susunan lambang seperti nama, alamat,
<br />nomor jaminan sosial, gaji dan sebagainya. Beberapa dari lambang tersebut
<br />biasanya berupa struktur, nama mempunyai komponen begitu juga alamat dan
<br />gaji.
<br />Struktur ini sering digunakan untuk mendefinisikan suatu record data yang
<br />disimpan di dalam file. Struktur termasuk ke dalam tipe data yang dibangkitkan
<br />(derived data type), yang disusun dengan menggunakan obyek tipe lain.
<br />Contoh :
<br />struct mhs
<br />{
<br />char *nama;
<br />char *nim;
<br />int tts, tas;
<br />float akhir;
<br />char aksara;
<br />}
<br />Kata kunci struct menunjukkan definisi struktur, dan identitas mhs
<br />menunjukkan structure tag. Dengan demikian terdapat tipe data baru bernama
<br />struct mhs, yang terdiri dari nama mahasiswa, nilai tes tengah semester, tes
<br />akhir semester, nilai akhir, dan huruf aksara, yang masing-masing disebut
<br />dengan field.
<br />Dapat dituliskan dengan :
<br />struct mhs x, y[100], *z;
<br />Variabel x adalah variabel tunggal, y adalah variabel array dengan 100 lokasi
<br />memori, dan z adalah variabel pointer, yang kesemuanya masing-masing berisi
<br />field di atas. Jadi, variabel y adalah daftar nama, nilai tts, tas, akhir, dan huruf
<br />aksara dari 100 mahasiswa.
<br />Sehingga dapat ditulis :
<br />struct mhs
<br />{
<br />char *nama;
<br />char *nim;
<br />int tts, tas;
<br />float akhir;
<br />char aksara;
<br />} x, y[100], *z;
<br />Modul 4 Struktur Data (Arie) - 2
<br />Inisialisasi juga dapat dilakukan dengan :
<br />struct mhs x = { “Garfield”, 80, 60, 76.8, ‘A’ };
<br />Untuk mengakses anggota dari struktur digunakan salah satu dari dua operator,
<br />yaitu operator titik (.), atau operator panah (->) tergantung tipe variabel yang
<br />dideklarasikan. Jika variabel tunggal (misal x) maka digunakan operator titik,
<br />sedangkan jika variabel pointer (misal z) digunakan operator panah.
<br />Contoh :
<br />printf (“%s”, x.nama);
<br />printf (“%s”, z->nama);
<br />DASAR STRUKTUR
<br />Misal ada permasalahan grafis yang melibatkan koordinat x dan y. Objek dasar
<br />yang akan dibuat struktur adalah titik koordinatnya, yang diasumsikan sebagai
<br />koordinat x dan y dan keduanya bilangan bulat.
<br />Deklarasi dari koordinat x dan y adalah :
<br />struct point
<br />{
<br />int x;
<br />int y;
<br />};
<br />kata kunci struct mengenalkan deklarasi struktur yang mana deklarasi list
<br />terlampir di kurung kurawal { }. Nama pilihan yang disebut structure tag
<br />mengikuti kata struct.
<br />Deklarasi struktur yang tidak diikuti oleh variabel list tidak menyediakan
<br />tempat penyimpanan; deklarasi struktur hanya menjelaskan template atau
<br />bentuk struktur. Kalau deklarasi di tag, tag dapat digunakan dalam definisi
<br />contoh struktur. Sebagai contoh, memberikan deklarasi point diatas.
<br />struct point pt;
<br />Variabel pt yang berupa struktur tipe struct poin. Sebuah struktur dapat
<br />diletakan di depan dengan mengikuti difinisinya dengan daftar inisialisasi,
<br />masing-masing adalah lambang konstanta.
<br />STRUKTUR DAN FUNGSI
<br />Operasi yang sering diterapkan pada struktur adalah proses menyalin atau
<br />menunjukkan struktur sebagai unit, menggunakan alamatnya dan mengakses
<br />anggotanya. Copy dan assignment mencakup memberi argumen ke fungsi dan
<br />menghasilkan nilai dari fungsinya juga. Struktur tidak bisa dibandingkan.
<br />Struktur dapat diletakkan di awal oleh daftar value konstanta dan otomatis
<br />juga dapat ditempatkan di awal oleh operasi assignment. Sebuah struktur
<br />otomatis mungkin juga diletakkan di depan oleh tugas atau oleh panggilan
<br />fungsi yang menghasilkan struktur jenis yang tepat.
<br />Untuk menghubungkan nama struktur dan nama anggota digunakan simbol “.”
<br />Modul 4 Struktur Data (Arie) - 3
<br />Contoh :
<br />/*Program : struct1.cpp*/
<br />#include <stdio.h>
<br />struct time
<br />{
<br />int jam;
<br />int min;
<br />};
<br />struct rencana {
<br />struct time awal;
<br />struct time akhir;
<br />int y;
<br />int z;
<br />};
<br />struct rencana kerja = { 11,22,33,44,5,6 };
<br />funct(struct rencana oo);
<br />main()
<br />{
<br />kerja.akhir.min = 40;
<br />kerja.z = 66;
<br />printf("proses main sebelum ke fungsi\n%d %d %d %d %d %d\n",
<br />kerja.awal.jam, kerja.awal.min, kerja.akhir.jam, kerja.akhir.min, kerja.y,kerja.z);
<br />funct(kerja); /* pengiriman struktur kerja ke fungsi */
<br />printf("proses main sesudah ke fungsi\n%d %d %d %d %d %d\n", kerja.awal.jam,
<br />kerja.awal.min, kerja.akhir.jam, kerja.akhir.min, kerja.y,kerja.z);
<br />}
<br />funct(struct rencana oo)
<br />/* nilai struktur kerja disalinkan ke oo */
<br />{
<br />printf("dalam fungsi (a)\n%d %d %d %d %d %d\n", oo.awal.jam, oo.awal.min,
<br />oo.akhir.jam,oo.akhir.min, oo.y, oo.z);
<br />oo.awal.jam = 111;
<br />oo.y = 555; /* ubah nilai dalam fungsi */
<br />printf("dalam fungsi (a)\n%d %d %d %d %d %d\n", oo.awal.jam, oo.awal.min,
<br />oo.akhir.jam,oo.akhir.min, oo.y, oo.z);
<br />}
<br />Bila program dijalankan maka :
<br />proses main sebelum ke fungsi
<br />11 22 33 40 5 66
<br />dalam fungsi (a)
<br />11 22 33 40 5 66
<br />dalam fungsi (a)
<br />111 22 33 40 555 66
<br />proses main sesudah ke fungsi
<br />11 22 33 40 5 66
<br />Modul 4 Struktur Data (Arie) - 4
<br />ARRAY DALAM STRUKTUR
<br />Array disini berfungsi untuk menyimpan nama dan bilangan bulat yang akan
<br />digunakan dalam proses perhitungan.
<br />Contoh :
<br />// Program : struct2.cpp
<br />#include <iostream.h>
<br />#include <string.h>
<br />#include <stdlib.h>
<br />struct movies_t {
<br />char title [50];
<br />int year;
<br />} mine, yours;
<br />void printmovie (movies_t movie);
<br />int main ()
<br />{
<br />char buffer [50];
<br />strcpy (mine.title, "Finding Nemo");
<br />mine.year = 2003;
<br />cout << "Masukkan judul film favorit: ";
<br />cin.getline (yours.title,50);
<br />cout << "Masukkan tahun: ";
<br />cin.getline (buffer,50);
<br />yours.year = atoi (buffer);
<br />cout << "Judul film favorit yang ada:\n ";
<br />printmovie (mine);
<br />cout << "Judul film favorit kamu adalah:\n ";
<br />printmovie (yours);
<br />return 0;
<br />}
<br />void printmovie (movies_t movie)
<br />{
<br />cout << movie.title;
<br />cout << " (" << movie.year << ")\n";
<br />}
<br />Bila program diatas dijalankan maka hasilnya adalah :
<br />Masukkan judul file favorit : Avp
<br />Masukkan tahun : 2004
<br />Judul film favorit yang ada :
<br />Finding Nemo (2003)
<br />Judul film favorit kamu adalah :
<br />Avp (2004)
<br />Dapat dilihat deklarasi array dalam struktur terletak pada char title[50];
<br />dimana dalam title dapat menyimpan judul film sebanyak 50 tempat dan title
<br />ini terletak pada :
<br />Modul 4 Struktur Data (Arie) - 5
<br />struct movies_t {
<br />char title [50];
<br />int year;
<br />} mine, yours;
<br />Contoh :
<br />// Program : struct3.cpp
<br />// array of structures
<br />#include <iostream.h>
<br />#include <stdlib.h>
<br />#define N_MOVIES 5
<br />struct movies_t {
<br />char title [50];
<br />int year;
<br />} films [N_MOVIES];
<br />void printmovie (movies_t movie);
<br />int main ()
<br />{
<br />char buffer [50];
<br />int n;
<br />for (n=0; n<N_MOVIES; n++)
<br />{
<br />cout << "Masukkan judul film: ";
<br />cin.getline (films[n].title,50);
<br />cout << "Masukkan tahun : ";
<br />cin.getline (buffer,50);
<br />films[n].year = atoi (buffer);
<br />}
<br />cout << "\nFilm yang menjadi favorit kamu:\n";
<br />for (n=0; n<N_MOVIES; n++)
<br />printmovie (films[n]);
<br />return 0;
<br />}
<br />void printmovie (movies_t movie)
<br />{
<br />cout << movie.title;
<br />cout << " (" << movie.year << ")\n";
<br />}
<br />Bila program diatas dijalankan maka hasilnya adalah :
<br />Masukkan judul file favorit : Matrix
<br />Masukkan tahun : 2002
<br />Masukkan judul file favorit : Alien Vs Predator
<br />Masukkan tahun : 2004
<br />...
<br />Film yang menjadi favorit kamu :
<br />Matrix (2002)
<br />Alien Vs Predator (2004)
<br />Modul 4 Struktur Data (Arie) - 6
<br />Deklarasi array dalam struktur terletak pada char title [50]; dan #define
<br />N_Movies 5, sehingga 5 buah data film harus dimasukkan.
<br />POINTER DALAM STRUKTUR
<br />Misalkan sebuah pointer yaitu ptpelajar, yang menunjuk kepada sebuah data
<br />yang mempunyai struktur PELAJAR seperti berikut :
<br />struct PELAJAR *ptpelajar;
<br />Seperti pada pointer yang lain, deklarasi tersebut tidak menyediakan sebarang
<br />tempat untuk record PELAJAR. Perlu dibuat record baru yang fungsinya
<br />menggantikan pointer. Misalnya pelajar_baru.
<br />ptpelajar = &pelajar_baru;
<br />Dengan kondisi tersebut, pointer ptpelajar boleh digunakan untuk
<br />menggantikan tempat alamat pelajar_baru, dan pointer ptpelajar ini
<br />ditunjukkan dengan menggunakan simbol ->.
<br />Contoh :
<br />ptpelajar->nama = Jill Valentine;
<br />ptpelajar->nim = 672009001;
<br />ptpelajar->fakultas = Teknologi Informasi;
<br />ptpelajar->tahun = 2009;
<br />ptpelajar->alamat = Salatiga;
<br />Sama dengan :
<br />*ptpelajar.nama = Jill Valentine;
<br />*ptpelajar.nim = 672009001;
<br />*ptpelajar.fakultas = Teknologi Informasi;
<br />*ptpelajar.tahun = 2009;
<br />*ptpelajar.alamat = Salatiga;
<br />Contoh :
<br />// Program : struct4.cpp
<br />#include <iostream.h>
<br />struct time {
<br />int jam;
<br />int min;
<br />};
<br />struct rencana {
<br />struct time *awal; /* penunjuk bagi struktur */
<br />struct time *akhir;
<br />};
<br />struct time jk = { 1,2 };
<br />struct time kl = { 3,4 };
<br />struct rencana kerja = { &jk,&kl };
<br />main()
<br />{
<br />kerja.akhir->min = 37;
<br />cout << kerja.awal->jam << " " << kerja.awal->min << " "
<br /><< kerja.akhir->jam << " " << kerja.akhir->min << endl;
<br />}
<br />Bila program diatas dijalankan maka hasilnya adalah :
<br />1 2 3 37
<br />Modul 4 Struktur Data (Arie) - 7
<br />STRUKTUR YANG MENUNJUK DIRINYA SENDIRI
<br />Struktur yang mempunyai sifat menunjuk dirinya sendiri dapat dilihat pada
<br />contoh deklarasi berikut ini :
<br />struct tnode {
<br />char *perkataan;
<br />int *perkiraan;
<br />struct tnode *kiri;
<br />struct tnode *kanan;
<br />};
<br />TYPEDEF
<br />Kata kunci typedef merupakan mekanisme untuk membuat sinonim atau alias
<br />dari tipe data yang telah didefinisikan sebelumnya.
<br />Contoh :
<br />typedef struct mhs MHS;
<br />Dari deklarasi tersebut dapat didefinisikan sebuah tipe data baru bernama MHS
<br />sebagai sinonim untuk struct mhs. Pernyataan struct mhs dapat diganti dengan
<br />MHS saja.
<br />Contoh :
<br />typedef int PANJANG;
<br />Jenis PANJANG boleh digunakan untuk deklarasi variabel yang lain.
<br />Contoh :
<br />PANJANG len, maxlen;
<br />PANJANG *lengths[];
<br />Sama dengan :
<br />int len, maxlen;
<br />int *lengths[];
<br />Contoh :
<br />// Program : struct5.cpp
<br />#include <stdio.h>
<br />main()
<br />{
<br />static struct s1 {
<br />char c[4], *s;
<br />} s1 = { "abcd", "fghi" };
<br />static struct s2 {
<br />char *cp;
<br />struct S1 ss1;
<br />} s2 = { "klmn", { "pqrs", "uvwxy" } };
<br />printf("s1.c[2] = %c, *s1.s = %c\n", s1.c[2], *s1.s);
<br />printf("s1.c = %s s1.s = %s\n", s1.c, s1.s);
<br />printf(" s2.cp = %s s2.ss1.s = %s\n", s2.cp, s2.ss1.s);
<br />printf("++s2.cp = %s ++s2.ss1.s = %s\n",++s2.cp, ++s2.ss1.s);
<br />}
<br />Modul 4 Struktur Data (Arie) - 8
<br />Bila program tersebut dijalankan maka :
<br />s1.c[2] = c, *s1.s = f
<br />s1.c = abcd s1.s = fghi
<br />s2.cp = klmn s2.ss1.s = uvwxy
<br />++s2.cp = lmn ++s2.ss1.s = vwxy
<br />Penggunaan typedef terletak pada variabel s1 dan s2 yang mempunyai panjang
<br />karakter yang berbeda dan nantinya pada waktu dicetak akan menghasilkan
<br />output sesuai kondisi pada program.
<br />UNION
<br />Sama seperti struct, union juga merupakan tipe data yang dibangkitkan,
<br />dimana anggotanya menggunakan secara bersama ruang penyimpanan memori
<br />yang sama, berbeda dengan struktur yang masing-masing variabel menempati
<br />lokasi memori yang berbeda.
<br />Jumlah bytes yang digunakan untuk menyimpan union adalah sedikitnya cukup
<br />untuk menyimpan data terbesar yang ditangani. Tipe union umumnya
<br />digunakan untuk menangani satu, dua, atau tiga variabel dengan tipe yang
<br />mirip.
<br />Contoh :
<br />//Program:struct6.cpp
<br />#include <iostream.h>
<br />typedef union int_or_float {
<br />int n;
<br />float x;
<br />} number;
<br />main()
<br />{
<br />number temp;
<br />temp.n = 4444;
<br />cout << "(a) temp.n = " << temp.n << " temp.x = " << temp.x << endl;
<br />temp.x = 4444.0;
<br />cout << "(b) temp.n = " << temp.n << " temp.x = " << temp.x << endl;
<br />temp.n = 4444;
<br />cout << "(c) temp.n = " << temp.n << " temp.x = " << temp.x << endl;
<br />}
<br />Bila program dijalankan, maka :
<br />(a) temp.n = 4444 temp.x = 0.574484
<br />(b) temp.n = -8192 temp.x = 4444
<br />(c) temp.n = 4444 temp.x = 4418.169922
<br />Output pada baris (b), nilai temp.n berubah karena tempatnya telah digunakan
<br />untuk menempatkan temp.x. Hal sebaliknya terjadi kepada nilai temp.x pada
<br />baris (c).
<br />Modul 4 Struktur Data (Arie) - 9
<br />Output program akan berbeda jika deklarasi union tadi diganti dengan deklarasi
<br />struktur berikut :
<br />typedef struct int_or_float {
<br />int n;
<br />float x;
<br />} number;
<br />Hasilnya :
<br />(a) temp.n = 4444 temp.x = -0.00000
<br />(b) temp.n = 4444 temp.x = 4444.00000
<br />(c) temp.n = 4444 temp.x = 4444.00000
<br />ENUMERASI
<br />C++ menyediakan tipe data yang dapat didefinisikan oleh pemrogram disebut
<br />dengan enumerasi. Enumerasi, didefinisikan dengan menggunakan kata kunci
<br />enum, adalah sekumpulan konstanta integer yang direpresentasikan dengan
<br />identikasi tertentu.
<br />Nilai dalam enum dimulai dari 0, dapat diubah dengan nilai lainnya, dan menaik
<br />dengan penambahan 1 untuk nilai selanjutnya.
<br />Contoh :
<br />enum bulan {JAN, PEB, MAR, APR, MEI, JUN, JUL, AGU, SEP, OKT, NOP,
<br />DES};
<br />Deklarasi tersebut akan menciptakan tipe baru yaitu enum bulan, yang secara
<br />otomatis menunjukkan deret nilai 0 untuk JAN hingga 11 untuk DES.
<br />Nilai bulan ini dapat diubah menjadi 1 hingga 12 dengan cara :
<br />enum bulan {JAN = 1, PEB, MAR, APR, MEI, JUN, JUL, AGU, SEP, OKT,
<br />NOP, DES};
<br />Contoh :
<br />/* Program : struct7.cpp*/
<br />#include <stdio.h>
<br />enum bulan {JAN = 1, PEB, MAR, APR, MEI, JUN, JUL, AGU, SEP, OKT, NOP,
<br />DES};
<br />main() {
<br />enum bulan Bulan;
<br />char *namaBulan[] = {"", "Januari", "Pebruari", "Maret", "April", "Mei", "Juni",
<br />"Juli", "Agustus", "September", "Oktober", "Nopember", "Desember" };
<br />for ( Bulan = JAN ; Bulan <= 12 ; Bulan++ )
<br />printf( "%2d%11s\n", Bulan, namaBulan[Bulan] );
<br />return 0;
<br />}
<br />Modul 4 Struktur Data (Arie) - 10
<br />Bila program tersebut dijalankan maka :
<br />1 Januari
<br />2 Februari
<br />3 Maret
<br />4 April
<br />5 Mei
<br />6 Juni
<br />7 Juli
<br />8 Agustus
<br />9 September
<br />10 Oktober
<br />11 November
<br />12 Desember
<br />CONTOH SOAL :
<br />Soal 1
<br />Buatlah program dengan struktur untuk menampilkan data karyawan yang
<br />berjumlah 5 orang lengkap dengan nama dan no Id-nya.
<br />Contoh ada di file : dataid.exe
<br />Save dengan nama file : st1_nim (4 digit nim terakhir)apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com0tag:blogger.com,1999:blog-4754589256962267400.post-15853428759633995742011-02-28T07:50:00.000-08:002011-02-28T07:54:18.714-08:00POINTERPointer adalah variable yang berisi alamat memory sebagai nilainya dan berbeda dengan variable biasa yang berisi nilai tertentu. Dengan kata lain, pointer berisi alamat dari variable yang mempunyai nilai tertentu. Dengan demikian, ada variabel yang secara langsung menunjuk ke suatu nilai tertentu, dan variabel yang secara tidak langsung menunjuk ke nilai. Adapun bentuk umum dari pernyataan variabel pointer dalam C++ adalah :<br />Type *variabel-name Dengan :<br />• Type adalah tipe dasar pointer<br />• Variabel name adalah nama variabel pointer<br />• * adalah variabel pada alamatnya yang ditentukan oleh operand.<br />Contoh :<br />Int *int_pointer; // pointer to integer<br />Float *float_pointer; // pointer to float<br />Contoh :<br />//Program : pointer.cpp<br />#include <stdio.h><br />main()<br />{<br />int a, *b;<br />a=20;<br />b=&a;<br />printf (" Pointer b menunjukkan alamat =%p\n",b);<br />printf (" Alamat tersebut berisi nilai :%d\n",*b);<br />}<br />//Program : pointer1.cpp<br />#include <iostream .h><br />// cetak p dan *p<br />void main(void)<br />{<br />int v = 7, *p;<br />p = &v;<br />cout << " Nilai v = " << v << " dan *p = " << *p<br /><< "\nAlamatnya = " << p << '\n';<br />}<br />Bila program diatas dijalankan, maka hasilnya adalah sebagai berikut :<br />Nilai v = 7 dan *p = 7<br />Alamatnya = efffb24<br />Modul 3 Struktur Data (Arie) - 2<br />//Program:pointer2.cpp<br />#include <iostream.h><br />int main ()<br />{<br />int value1 = 5, value2 = 15;<br />int * mypointer;<br />mypointer = &value1;<br />*mypointer = 10;<br />mypointer = &value2;<br />*mypointer = 20;<br />cout << "value1==" << value1 << "/ value2==" << value2;<br />return 0;<br />}<br />Bila program diatas dijalankan, maka hasilnya adalah sebagai berikut :<br />“value1==” 10 << “/ value2==20<br />OPERATOR POINTER<br />Ada beberapa operator yang bisa digunakan dalam pointer. Operator tersebut<br />adalah operator alamat (yang dilambangkan dengan simbol &) dan operator<br />unary yang mengembalikan alamat dari operandnya.<br />Sebagai contoh, diasumsikan deklarasi sebagai berikut :<br />Int y = 5;<br />Int *yPtr;<br />Maka pernyataan :<br />YPtr = &y;<br />Pernyataan ini mengandung arti bahwa alamat dari variabel y ditujukan kepada<br />variabel pointer yPtr.<br />Contoh lain :<br />Int balance, value;<br />Int *balptr;<br />Balance = 3200; // step 1<br />Balptr=&balance; // step 2<br />Value=*balptr; // step 3<br />Contoh diagram :<br />Step 1 Step 2 Step 3<br />12 Balptr 12 100 Balptr 12 100 Balptr<br />100 3200 Balance 100 3200 Balance 100 3200 Balance<br />130 value 130 value 130 3200 value<br />Modul 3 Struktur Data (Arie) - 3<br />Contoh :<br />//Program:pointer3.cpp<br />#include <iostream.h><br />int main()<br />{<br />int *ptr, num; // Step 1<br />ptr = # // Step 2<br />*ptr = 100; // Step 3<br />cout << num << " ";<br />(*ptr)++; // Step 4<br />cout << num << " ";<br />(*ptr)*=2; // Step 5<br />cout << num << "\n";<br />return 0;<br />}<br />Bila program dijalankan :<br />100 101 202<br />Contoh diagram :<br />Step<br />1<br />Step<br />2<br />Step<br />3<br />Step<br />4<br />Step<br />5<br />12 *int Ptr 12 50 Ptr 12 50 Ptr 12 50 Ptr 12 50 Ptr<br />50 int num 50 int num 50 100 num 50 101 num 50 202 num<br /><br />... ... ... ... ...<br /><br />EKSPRESI POINTER<br />Pointer Aritmatika<br />Hanya 4 operator aritmatik dapat digunakan pada pointer ++, = =, +, dan -.<br />Asumsi integer 32 bit.<br />Contoh :<br />Int *p1;<br />p1++;<br />p1--;<br />Contoh :<br />//Program:pointer4.cpp<br />#include <iostream.h><br />int main()<br />{<br />int i[10], *i_ptr;<br />double f[10], *f_ptr;<br />int x;<br />i_ptr = i; // i_ptr points to first element of i<br />Modul 3 Struktur Data (Arie) - 4<br />f_ptr = f; // f_ptr points to first element of f<br />for(x=0; x<10; x++)<br />cout << i_ptr+x << " " << f_ptr+x << "\n";<br />return 0;<br />}<br />Bila program dijalankan :<br />0xeffffd9c 0xeffffd48<br />0xeffffda0 0xeffffd50<br />0xeffffda4 0xeffffd58<br />0xeffffda8 0xeffffd60<br />... ...<br />Pointer Perbandingan<br />Pointer dapat dibandingkan dengan menggunakan operator hubungan, seperti<br />!=, ==, <, dan >.<br />Contoh :<br />//Program:pointer5.cpp<br />#include <iostream.h><br />int main()<br />{<br />int num[10];<br />int *start, *end;<br />start = num;<br />end = &num[9];<br />while(start != end) {<br />cout << "Masukkan bilangan sebanyak 9 data : ";<br />cin >> *start;<br />start++;<br />}<br />return 0;<br />}<br />Data yang akan dimasukkan sebanyak 9 buah data dan program tidak akan<br />berhenti apabila belum sampai 9 buah data.<br />POINTER VERSUS ARRAY<br />Array dan pointer adalah dua struktur data yang saling berkaitan satu dengan<br />yang lain dalam C, dan dapat saling dipertukarkan penggunaannya. Karena<br />array dapat didefinisikan sebagai pointer.<br />Contoh :<br />int *bPtr, b[5];<br />Dapat dibuat menjadi :<br />bPtr = b;<br />bPtr = &b[0];<br />Berarti bPtr ditugaskan untuk menunjukkan ke alamat elemen pertama dari<br />array b atau b[0].<br />Elemen array b[3] dapat ditulis :<br />* (bPtr + 3)<br />Modul 3 Struktur Data (Arie) - 5<br />Alamat &b[3] dapat ditulis :<br />bPtr +3<br />Deklarasi suatu variabel array x[] yang berisi nilai int dapat ditulis :<br />int *x;<br />Variabel array ganda dapat ditulis :<br />int y [ ] [ ];<br />int *y [ ];<br />int *( *y);<br />Penggunaan pointer dan array untuk deklarasi variabel array ganda untuk<br />menyimpan empat buah elemen yang masing-masing bertipe string (array dari<br />karakter).<br />char *suit [4] = { “Hearts”, “Diamonds”, “Clubs”, “Spades” };<br />Contoh :<br />//Program:pointer6.cpp<br />#include <iostream.h><br />#include <stdio.h><br />int main()<br />{<br />char str[80];<br />char token[80];<br />char *str_ptr, *tk_ptr;<br />cout << "Masukkan sebuah kalimat : ";<br />gets(str);<br />str_ptr = str;<br />while(*str_ptr) {<br />tk_ptr = token;<br />while( *str_ptr != ' ' && *str_ptr ) {<br />*tk_ptr = *str_ptr;<br />tk_ptr++;<br />str_ptr++;<br />}<br />if(*str_ptr) str_ptr++;<br />*tk_ptr = '\0';<br />cout << token << endl;<br />}<br />return 0; }<br />//Program:pointer7.cpp<br />#include <iostream.h><br />#include <stdio.h><br />int main()<br />{<br />char str[80];<br />char token[80];<br />int i, j;<br />cout << "Masukkan sebuah kalimat: ";<br />gets(str);<br />for(i=0; ; i++) {<br />for(j=0; str[i] != ' ' && str[i]; j++, i++)<br />token[j] = str[i];<br />Modul 3 Struktur Data (Arie) - 6<br />token[j] = '\0';<br />cout << token << '\n';<br />if(!str[i]) break;<br />}<br />return 0;<br />}<br />Pada contoh program pointer 6 adalah program dengan pointer, sedangkan<br />contoh program pointer 7 dengan menggunakan array. Hasil dari kedua program<br />tersebut sama.<br />POINTER INDEX<br />Pointer tidak hanya dapat digunakan untuk mengakses elemen array, tetapi<br />pointer juga dapat diindex seperti pada array.<br />Contoh :<br />//Program:pointer8.cpp<br />#include <iostream.h><br />#include <ctype.h><br />int main()<br />{<br />char str[20] = "hello tom";<br />char *p;<br />int i;<br />p = str;<br />for(i=0; p[i]; i++)<br />p[i] = toupper(p[i]);<br />cout << p;<br />return 0;<br />}<br />Bila program diatas dijalankan, maka hasilnya adalah sebagai berikut :<br />HELLO TOM<br />Proses pengindexan pointer dapat dilihat pada variabel p yang menunjuk pada<br />variabel str yang berisi data nama dengan panjang 20. Fungsi toupper<br />memperjelas proses pengindexan.<br />KONSTANTA STRING DAN POINTER<br />Konstanta string terlihat dalam program teks dan disimpan dalam tabel string<br />serta setiap entry dalam tabel string, pointer string dibangkitkan.<br />Contoh :<br />//Program:pointer9.cpp<br />#include <iostream.h><br />int main()<br />{<br />char *s;<br />s = "Pointers are fun to use.\n";<br />cout << s;<br />return 0;<br />}<br />Modul 3 Struktur Data (Arie) - 7<br />Bila program diatas dijalankan, maka hasilnya adalah sebagai berikut :<br />Pointers are fun to use.<br />ARRAY POINTER<br />Pointer dapat diarraykan seperti tipe data yang lain dalam C++. Untuk<br />menyatakan sebuah array pi dari pointer sebanyak 10 buah data yang bertipe<br />10 integer, dapat ditulis :<br />int *pi [10];<br />Untuk menentukan alamat dari variabel integer disebut var ke elemen ketiga<br />dari pointer array, dapat ditulis :<br />int var;<br />pi [2] = &var<br />Contoh :<br />//Program:point10.cpp<br />#include <iostream.h><br />int main ()<br />{<br />int numbers[5];<br />int *p;<br />p = numbers; *p = 10;<br />p++; *p = 20;<br />p = &numbers[2]; *p = 30;<br />p = numbers + 3; *p = 40;<br />p = numbers; *(p+4) = 50;<br />for (int n=0; n<5; n++)<br />cout << numbers[n] << ", ";<br />return 0;<br />}<br />Bila program diatas dijalankan, maka hasilnya adalah sebagai berikut :<br />10, 20, 30, 40, 50,<br />POINTER DALAM POINTER<br />C++ memperbolehkan penggunaan pointer dalam pointer yang berisi data yang<br />sama atau berbeda. Dalam kondisi pointer biasa atau pointer tunggal,<br />diagramnya adalah :<br />Pointer Variabel<br />Untuk pointer dalam pointer, diagramnya adalah :<br />Pointer Pointer Variabel<br />Contoh :<br />char a;<br />char *b;<br />char **c;<br />address value<br />address address value<br />Modul 3 Struktur Data (Arie) - 8<br />a = ‘z’;<br />b = &a;<br />c = &b;<br />Dengan misal data acak pada memori 7230, 8092, dan 10502, maka diagramnya<br />adalah :<br />a b c<br />7230 8092 10502<br />Dari diagram dapat disimpulkan :<br />• c adalah sebuah variabel dengan tipe (char**) yang berisi 8092<br />• *c adalah sebuah variabel dengan tipe (char*) yang berisi 7230<br />• **c adalah sebuah variabel dengan tipe (char) yang berisi ‘z’<br />Contoh :<br />//Program:point12.cpp<br />#include <iostream.h><br />#include <stdio.h><br />#include <string.h><br />int main()<br />{<br />int x, *p, **q;<br />x = 10;<br />p = &x;<br />q = &p;<br />cout << **q; // prints the value of x<br />return 0;<br />}<br />Bila program diatas dijalankan, maka hasilnya adalah sebagai berikut :<br />10apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com3tag:blogger.com,1999:blog-4754589256962267400.post-17924910068269503532011-02-28T07:10:00.000-08:002011-02-28T07:13:39.344-08:00DASAR STRINGPengantar String
<br /><div style="text-align: justify;">String sangat memudahkan tugas pemogram. Dengan menggunakan string, pemogram dapat menampilkan pesan kesalahan, menampilkan prompt bagi masukan keyboard ataupun memberikan informasi pada layar dengan mudah. Seperti halnya tipe data yang lain, string dapat berupa konstanta atau variabel. Konstanta string sudah biasa anda sertakan pada program.
<br /></div>
<br />Misalnya pada pernyataan :
<br />cout << “C++”<<endl; tetapi="" sejauh="" belum="" ditulis="" awalan="" dan="" akhiran="" petik="" konstanta="" diatas="" disimpan="" dalam="" memori="" secara="" setiap="" menempati="" memory="" 1="" terakhir="" terdapat="" null="" nilai="" ascii="" sama="" nol="" atau="" disimbolkan="" yaitu="" tanda="" dikuti="" bila="" berisi="" disebut="" sebagai="" dipakai="" menyimpan="" char="" merupakan="" dengan="" panjang="" maksimal="" 9="" sudah="" termasuk="" diketahui="" pernyataan="" atas="" lain="" untuk="" mendefinisikan="" array="" bertipe="" memasukan="" setelah="" suatu="" string="" anda="" bisa="" mengisikan="" ke="" variabel="" pemasukan="" ditangani="" oleh="" data="" seperti="" contoh="" program="" di="" bawah="" ini="" perlu="" diperhatikan="" adalah="" bahwa="" cin="" hanya="" dapat="" membaca="" sebuah="" artinya="" karakter="" yang="" terletak="" sesudah="" spasi="" tidak="" include=""><iostream.h>
<br />#include<conio.h>
<br />void main()
<br />{
<br />char teks[13]; //string dengan panjang maksimal 12 karakter
<br />clrscr(); //hapus layar
<br />cout<<”Masukan sebuah kata :”<<endl; cin="">> teks;
<br />cout<< “Kata yang tercetak :”<<teks; modul="" struktur="" data="" 2="" bisa="" ditampung="" pada="" ini="" disebabkan="" operator=""><<>Suatu masalah akan timbul kalau cin.get() digunakan 2 kali seperti
<br />>contoh program dibawah ini
<br />>Pada contoh di atas cin.get() pertama digunakan untuk membaca nama
<br />yang kedua untuk membaca alamat. Ternyata program tidak memberikan
<br />>kesempatan untuk mengisi alamat. Hal ini terjadi karena get() yang
<br />>pertama tidak membuang kode newline(\n). Oleh karena get() tidak
<br />>mengabaikan spasi putih( spasi, tab , atau newline) maka get() kedua
<br />#include<iostream.h>
<br />#include<conio.h>
<br />void main()
<br />{
<br />char teks[13]; //string dengan panjang maksimal 12 karakter
<br />>clrscr(); //hapus layar
<br />>cout<<”Masukan sebuah kata :”<<;endl; >cin.get(teks, 13);
<br />>cout<< “Kata yang tercetak :”<<;teks; } #include<iostream.h>
<br />#include<conio.h>
<br />void main()
<br />{
<br />char nama[25];
<br />char alamat[35];
<br />>clrscr(); //hapus layar
<br />>cout<<”Masukan Nama :”<<;endl; >cin.get(nama, sizeof(nama));
<br />>cout<< “Masukan Alamat :”<<;endl; >cin.get(alamat,sizeof(alamat));
<br />>cout<<”Nama:”<<;nama<<;endl; >cout<<”Alamat:”<<;alamat<<;endl; } >Modul 2 Struktur Data (Arie) - 3
<br />3
<br />>menjadi tidak berfungsi sebagaimana mestinya. Cara untuk
<br />>menyelesaikan masalah di atas dengan menggunakan fungsi getline(),
<br />>karena fungsi ini dapat membuang sisa data yang tidak dibaca, termasuk
<br />newline itu sendiri. Pada contoh berikut, get() diganti dengan getline().
<br />>Tampak bahwa dengan menggunakan getline(), data alamat dapat diisi.
<br />Fungsi strcpy<b>r>Bentuk dari dari strcpy() :<b>r>strcpy(string_target,string_awal)<b>r>Prototipe fungsi di atas ada pada file header string.h<b>r>Contoh program yang menggunakan strcpy():
<br />Fungsi toupper dan tolower
<br />Fungsi toupper() berguna untuk memperoleh huruf kapital dari
<br />suatu huruf kecil. Nilai balik dari fungsi ini akan berupa seperti
<br />argumennya kalau argumen tidak berisi huruf kecil.
<br />Adapun fungsi tolower() adalah kebalikan dari toupper(). Fungsi
<br />ini memberikan nilai balik :
<br />> Berupa huruf kecil kalau argumen berisi huruf kapital<b>r>�� Berupa nilai seperti argumen kalau argumen tidak berupa huruf
<br />kecil
<br />Kedua fungsi di atas memberikan nilai balik bertipe int dan memiliki
<br />protipe pada file ctype.h
<br />#include<iostream.h>
<br />#include<conio.h>
<br />void main()
<br />{
<br />char nama[25];
<br />char alamat[35];
<br />clrscr(); //hapus layar
<br />>cout<<”Masukan Nama :”<;<;endl;<b></b><b>r>cin.getline(nama, sizeof(nama));
<br />>cout<< “Masukan Alamat :”<;<;endl;<b></b><b>r>cin.getline(alamat,sizeof(alamat));
<br />>cout<<”Nama:”<;<;nama<;<;endl; >cout<<”Alamat:”<;<alamat><;<;endl; } #include<iostream.h>
<br />#include<conio.h>
<br />#include<string.h>
<br />void main()
<br />{
<br />char teks[]=”C++ Oke”;
<br />char data [25];
<br />clrscr(); //hapus layar
<br />strcpy(data,teks); // mengcopy isi teks ke data
<br />>cout<<;”Isi data :”<<data><;<;endl; } Modul 2 Struktur Data (Arie) - 4 4 Contoh program : >Pada contoh di atas,
<br />st[i]= toupper(st[i]);
<br />menyebabkan setiap huruf kecil pada variabel st akan diganti dengan
<br />huruf kapital.
<br />�� Fungsi strlen()
<br />Panjang suatu string dapat diketahui dengan mudah menggunakan
<br />fungsi strlen(). Misalnya saja, didefinisikan :
<br />>char bunga[15]= “mawar”;<b>r>int panjang;<b></b><b>r>Maka pernyataan yang menggunakan strlen :
<br />panjang = strlen(bunga);<b></b><b>r>akan memberikan panjang string yang tersimpan pada variabel bunga ke
<br />panjang.
<br />
<br />Fungsi strlwr() dan strupr
<br />Jika isi semua huruf kapital pada suatu string dinginkan untuk
<br />>diubah menjadi huruf kapital, hal ini dapat dilakukan melalui fungsi
<br />>strlwr(). Misalnya, didefinisikan :
<br />char st[]=”AbCdEfGeHjKl”;
<br />Maka st akan berisi : “abcdefgehjki”;
<br />Sedangkan fungsi strupr() kebalikan dari fungsi strlwr(). Kedua fungsi di
<br />atas sama seperti tolower dan toupper.
<br />>Contoh program untuk memperlihatkan efek strlwr() dan strupr() :
<br />#include<iostream.h>
<br />#include<conio.h>
<br />#include<ctype.h>
<br />void main()
<br />{
<br />char st[]=”saya suka C++”;
<br />>clrscr(); //hapus layar
<br />for(int i=0; st[i];i++)
<br />st[i]= toupper(st[i]);
<br />cout<<st&~~special_remove!#~~lt;&~~special_remove!#~~lt;endl; include=""><iostream.h>
<br />#include<conio.h>
<br />#include<string.h>
<br />void main()
<br />{<b>r>char bunga[15]=”mawar”;<b>r>char kosong[23]=””
<br />>clrscr(); //hapus layar
<br />cout<<;strlen(bunga)<<endl; cout<<;strlen(kosong)<<endl;<b>r>}<b></b><b>r>Modul 2 Struktur Data (Arie) - 5
<br />5
<br />
<br /> Konversi String ke Angka dan sebaliknya
<br />Untuk melakukan konversi dari suatu string ke bilangan, dapat
<br />menggunakan sejumlah fungsi bawahan. Fungsi-fungsi yang tersedia
<br />dapat dilihat pada tabel.
<br />Beberapa contoh hasil pengonversian string ke bilangan :<b></b><b>r>�� atof(“+2.1E+02”) = 210
<br /> atof(“+2.”) = 2
<br /> atof(“2abc”) = 2
<br />atof(“ 20.1”) = 20
<br />atoi(“+2.1E+02”) = 2
<br />atoi(“+2.”) = 2<b>r>�� atoi(“2abc”) = 2
<br />atoi(“ 20.1”) = 20
<br />atol(“+2.1E+02”) = 2
<br />atol(“+2.”) = 2
<br /> atol(“2abc”) = 2
<br />atol(“ 2000000000”) = 2000000000
<br />>Adapun fungsi yang berguna untuk mengubah suatu nilai bilangan
<br />menjadi suatu string diantaranya ditunjukan pada tabel di bawah
<br />Fungsi Prototipe Keterangan
<br />atoi Stdlib.h Mengkonversi string argumen menjadi nilai
<br />>bertipe int
<br />atof Stdlib.h Mengkonversi string argumen menjadi nilai
<br />bertipe float
<br />atol Stdlib.h Mengkonversi string argumen menjadi nilai
<br />bertipe long int
<br />atold Stdlib.h Mengkonversi string argumen menjadi nilai
<br />>bertipe long doubel
<br />Fungsi Prototipe Keterangan
<br />itoa Stdlib.h Mengkonversi int argumen menjadi nilai bertipe
<br />string
<br />ltoa Stdlib.h Mengkonversi long int argumen menjadi nilai<b>r>bertipe string
<br />ultoa Stdlib.h Mengkonversi unsigned long argumen menjadi
<br />nilai bertipe string
<br />#include<iostream.h>
<br />#include<conio.h>
<br />#include<string.h>
<br />void main()
<br />{
<br />char st[]=”AbCdEfGhIjKl”;
<br />clrscr(); //hapus layar
<br />cout<<”Isi St mula-mula:”<<;st<;<endl;>strlwr(st);
<br />cout<<”Isi setelah dikonversi strlwr: “<<endl;><;st<;<endl;>strupr(st);
<br />cout<<”Isi setelah dikonversi strupr: “<<endl;><st&~~special_remove!#~~lt;><;endl; } Modul 2 Struktur Data (Arie) - 6<b></b><b>r>6
<br />>Ketiga fungsi yang tercantum pada tabel di atas mempunyai tiga buah
<br />argumen.
<br />Argumen pertama berupa nilai yang akan dikonversi ke string
<br />Agumen kedua berupa variabel penerima string hasil konversi
<br />Argumen ketiga berupa basis bilangan yang digunakan. Bisa diisi
<br />>dengan nilai antara 2 sampai dengan 36.
<br />Misalnya, apabila hasil didefinisikan sebagai berikut :
<br />char hasil[24];
<br />int nilai= 2345;
<br />Pernyataan :
<br />itoa(nilai,hasil,10);
<br />membuat hasil berisi “2345”;</b></st&~~special_remove!#~~lt;></endl;></endl;></endl;></endl;></string.h></conio.h></iostream.h></b></b></b></b></b></b></b></string.h></iostream.h></st&~~special_remove!#~~lt;&~~special_remove!#~~lt;endl;></iostream.h></b></b></b></data></string.h></conio.h></iostream.h></alamat></b></b></conio.h></iostream.h></b></b></b></b></b></conio.h></iostream.h></conio.h></iostream.h></teks;></endl;></conio.h></iostream.h></endl;>apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com1tag:blogger.com,1999:blog-4754589256962267400.post-5197329209629323492011-02-28T06:34:00.000-08:002011-02-28T06:50:16.650-08:00ARRAYArray adalah kumpulan data bertipe sama yang menggunakan nama sama.
<br /><div style="text-align: justify;">Dengan menggunakan array, sejumlah variabel dapat memakai nama yang sama. Antara satu variabel dengan variabel lain di dalam array dibedakan berdasarkan subscript. Sebuah subscript berupa bilangan di dalam kurung siku.
<br />
<br /></div>Array dapat dibedakan menjadi :
<br />1. Array berdimensi satu
<br />2. Array berdimensi dua
<br />3. Array berdimensi tiga
<br />
<br /><span style="font-weight: bold;">Array Berdimensi Satu</span>
<br /><div style="text-align: justify;">Contoh array berdimensi satu, misalnya menginputkan 5 buah data temperatur. Dan kelima data tersebut disimpan pada array bernama suhu.
<br /></div>Contoh 1 :
<br />#include<iostream.h>
<br />#include<conio.h>
<br />void main()
<br />{
<br />float suhu[5]; // array dengan 5 elemen bertipe float
<br />// Membaca data dari keyboard dan meletakkan ke array
<br />cout << "Masukkan 5 buah data suhu" << endl;
<br />for (int i=0; i<5; i++)
<br />{
<br />cout << i + 1 << " : ";
<br />cin >> suhu[i];
<br />}
<br />// Menampilkan isi array ke layar
<br />cout << "Data suhu yang dimasukkan : " << endl;
<br />for (i=0; i<5; i++)
<br />cout << suhu[i] << endl;
<br />}
<br />
<br />Mendefinisikan array
<br />Float suhu[5];
<br />float : Tipe elemen array
<br />suhu : Nama array
<br />[5] : Jumlah elemen array
<br />Maka array suhu dapat menyimpan data sebanyak 5 buah.
<br />Subscript dari array selalu dimulai dari nol. Misal, jika jumlah elemen
<br />array [5], maka index dari array tersebut yaitu 0, 1, 2, 3, 4.
<br />
<br />Mengakses elemen array
<br />Setelah suatu array didefinisikan, elemen array dapat diakses dengan
<br />bentuk :
<br />suhu[i] menyatakan “elemen suhu dengan subscript sama dengan i”
<br />Nama_array[subscript]
<br />
<br />Perintah seperti cin >> suhu[i]; berarti “membaca data dari keyboard dan
<br />meletakkan ke elemen nomor i pada array suhu”.
<br />Perintah seperti cout >> suhu[i]; berarti “menampilkan elemen bernomor
<br />i pada array suhu”.
<br />Contoh 2 :
<br />#include<iostream.h>
<br />#include<conio.h>
<br />const int jum_data = 5;
<br />void main()
<br />{
<br />float suhu[jum_data]; // array suhu
<br />float total; // untuk menampung total suhu
<br />// Membaca data dari keyboard dan meletakkan ke array
<br />cout << "Masukkan 5 buah data suhu" << endl;
<br />for (int i=0; i<5; i++)
<br />{
<br />cout << i + 1 << " : ";
<br />cin >> suhu[i];
<br />}
<br />// Menghitung nilai rata-rata
<br />total = 0; // Mula-mula diisi dengan nol
<br />for(i=0; i<jum_data; i++)
<br />total += suhu[i]; // Tambahkan isi suhu[i] ke total
<br />cout << "Suhu rata-rata= " << total/jum_data << endl;
<br />}
<br />
<br />Memberikan nilai awal terhadap array
<br />Seperti halnya variabel biasa, array juga dapat diberi nilai awal
<br />(diinisialisasikan) pada saat didefinisikan. Misalnya:
<br />int jum_hari[12]={ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
<br />Catatan:
<br />C++ secara otomatis akan memberikan nilai awal nol terhadap array yang
<br />bersifat global. Jika bersifat lokal, maka harus diatur terlebih dahulu.
<br />Contoh 3 :
<br />#include<iostream.h>
<br />#include<conio.h>
<br />#include<iomanip.h>
<br />void main()
<br />{
<br />// Pendefinisian array jum_hari dan pemberian nilai awal
<br />int jum_hari[12]={ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
<br />// Tampilkan isi jum_hari
<br />cout << "Masukkan 5 buah data suhu" << endl;
<br />for (int i=0; i<12; i++)
<br />{
<br />cout << "jum_hari[" << i << "] ="
<br /><< jum_hari[i] << endl;
<br />}
<br />}
<br />
<br /><span style="font-weight: bold;">Array Berdimensi Dua</span>
<br />Sebagai gambaran, data kelulusan dari jurusan Teknik Informatika, Manajemen
<br />Informatika, dan Teknik Komputer dari tahun 1992 hingga 1995.
<br />Nama 1992 1993 1994 1995
<br />Teknik Informatika 35 45 80 120
<br />Manajemen Informatika 100 110 70 101
<br />Teknik Komputer 10 15 20 17
<br />Mendefinisikan array berdimensi dua
<br />Bentuk diatas dapat dibentuk dalam array berdimensi dua,
<br />pendefinisiannya :
<br />int nilai[3][4];
<br />Pada pendefinisian di atas :
<br />− 3 menyatakan jumlah baris (mewakili nama)
<br />− 4 menyatakan jumlah kolom (mewakili nilai)
<br />Mengakses array berdimensi dua
<br />Masing-masing elemen di dalam array berdimensi dua dapat diakses
<br />dengan bentuk :
<br />Baris dan kolom dimulai dari 0.
<br />Contoh pengaksesan elemen array berdimensi dua :
<br />1. data_lulus[1][2] = 5;
<br />Merupakan instruksi untuk memberikan nilai 5 ke baris 1 kolom 2.
<br />2. cout << data_lulus[1][2];
<br />Merupakan perintah untuk menampilkan elemen data_lulus dengan
<br />subscript pertama (baris) berupa 1 dan subscript kedua (kolom)
<br />bernilai 2.
<br />Contoh 4 :
<br />#include<iostream.h>
<br />#include<conio.h>
<br />void main()
<br />{
<br />int data_lulus[3][4]; // Array berdimensi dua
<br />int tahun, jurusan;
<br />// Memberikan data ke elemen array data_lulus
<br />data_lulus[0][0] = 35; // TI - 1992
<br />data_lulus[0][1] = 45; // TI - 1993
<br />data_lulus[0][2] = 90; // TI - 1994
<br />data_lulus[0][3] = 120; // TI - 1995
<br />data_lulus[1][0] = 100; // MI - 1992
<br />data_lulus[1][1] = 110; // MI - 1993
<br />data_lulus[1][2] = 70; // MI - 1994
<br />data_lulus[1][3] = 101; // MI - 1995
<br />data_lulus[2][0] = 10; // TK - 1992
<br />data_lulus[2][1] = 15; // TK - 1993
<br />data_lulus[2][2] = 20; // TK - 1994
<br />data_lulus[2][3] = 17; // TK - 1995
<br />// Proses untuk memperoleh informasi kelulusan
<br />while(1)
<br />nama_array[subscript_baris, subscript_kolom]
<br />Modul 1 Struktur Data (Arie) - 4
<br />{
<br />cout << "Jurusan (0 = TI, 1 = MI, 2 = TK): ";
<br />cin >> jurusan;
<br />if ((jurusan==0) || (jurusan==1) || (jurusan==2))
<br />break; // keluar dari while
<br />}
<br />while(1)
<br />{
<br />cout << "Tahun (1992 - 1995): ";
<br />cin >> tahun;
<br />if ((tahun >= 1992) && (tahun <= 1995))
<br />{
<br />tahun -= 1992; // konversi ke 0, 1, 2 atau 3
<br />break; // keluar dari while
<br />}
<br />}
<br />cout << "Jumlah yang lulus = "
<br /><< data_lulus[jurusan][tahun] << endl;
<br />}
<br />
<br />Melewatkan Array Sebagai Argumen Fungsi
<br />
<br />Array juga dapat berkedudukan sebagai parameter di dalam fungsi.
<br />Misalnya :
<br />const int MAKS = 5
<br />int data[MAKS];
<br />Dari data di atas, fungsi yang menerima array di atas dapat dibuat
<br />prototipe-nya sebagai berikut :
<br />void inisialisasi_data(data[MAKS]);
<br />Dan deklarasi fungsi sebagai berikut :
<br />void inisialisasi_data(data[], int & jumlah);
<br />Pada contoh kedua, tanda di dalam tanda [ ] tidak terdapat apa-apa dan
<br />parameter kedua digunakan untuk menyatakan jumlah elemen array serta
<br />berkedudukan sebagai referensi (bisa diubah dari dalam fungsi
<br />inisialisasi_data()).
<br />Contoh 5 :
<br />#include<iostream.h>
<br />#include<conio.h>
<br />#include<stdlib.h>
<br />#include<time.h>
<br />const int MAKS = 100;
<br />void inisialisasi_data(int data[], int &jumlah);
<br />void main()
<br />{
<br />int data_acak[MAKS]; // array berdimensi satu
<br />int jumlah;
<br />inisialisasi_data(data_acak, jumlah);
<br />// Tampilkan elemen-elemen array
<br />cout << "Isi array : " << endl;
<br />for(int i=0; i<jumlah; i++)
<br />cout << data_acak[i] << endl;
<br />}
<br />
<br />
<br />// Definisi fungsi
<br />void inisialisasi_data(int data[], int &jumlah)
<br />{
<br />while(1)
<br />{
<br />cout << "Berapa jumlah data yang ingin" << endl;
<br />cout << "dibangkitkan secara acak (5 - 100) ? ";
<br />cin >> jumlah;
<br />if ((jumlah >= 5) && (jumlah<=100))
<br />break;
<br />}
<br />randomize(); // Menyetel pembangkit bilangan acak
<br />for(int i=0; i<jumlah; i++)
<br />data[i] = random(100);
<br />}
<br />
<br /> Apabila array berdimensi dua hendak dilewatkan sebagai argumen fungsi,
<br />pendeklarasiannya dapat berupa semacam beriku t:
<br />void isi_matriks(float mat[BARIS][KOLOM], int &brs, int &kol);
<br />Atau cukup mengisikan pada bagian kolom saja, seperti contoh dibawah
<br />ini :
<br />void isi_matriks(float mat[][KOLOM], int &brs, int &kol);
<br />Contoh 6 :
<br />#include<iostream.h>
<br />#include<conio.h>
<br />#include<iomanip.h>
<br />const int BARIS = 5;
<br />const int KOLOM = 5;
<br />void isi_matriks(float mat[][KOLOM], int &brs, int &kol);
<br />void main()
<br />{
<br />float matriks[BARIS][KOLOM];
<br />int jum_baris, jum_kolom;
<br />int i,j;
<br />isi_matriks(matriks, jum_baris, jum_kolom);
<br />cout << "\nMatriks yang terbentuk: " << endl;
<br />cout << setiosflags(ios::fixed);
<br />// ios::fixed --> mengatur angka yg dimasukkan dalam bentuk angka biasa
<br />// bukan dalam bentuk eksponen
<br />for (i=0; i<jum_baris; i++)
<br />{
<br />for (j=0; j<jum_kolom; j++)
<br />cout << setw(12) << setprecision(5) << matriks[i][j];
<br />// setprecision(5) --> mengatur banyak angka dibelakang koma
<br />cout << endl;
<br />}
<br />}
<br />// Definisi Fungsi
<br />void isi_matriks(float mat[][KOLOM], int &brs, int &kol)
<br />{
<br />Modul 1 Struktur Data (Arie) - 6
<br />int i,j;
<br />cout << "Pastikan jumlah baris dan kolom" << endl;
<br />cout << "tidak melebihi 5" << endl;
<br />cout << "Jumlah baris = ";
<br />cin >> brs;
<br />cout << "Jumlah kolom = ";
<br />cin >> kol;
<br />for (i=0; i< brs; i++)
<br />for (j=0; j<kol; j++)
<br />{
<br />cout << "Elemen " << i << ", " << j << " = ";
<br />cin >> mat[i][j];
<br />}
<br />}
<br />
<br />Mengurutkan Data
<br />Salah satu mengurutkan data adalah dengan menggunakan bubble sort.
<br />Pengurutan dilakukan dengan membandingkan setiap elemen dengan
<br />seluruh elemen yang terletak sesudah posisinya.
<br />Contoh 7 :
<br />#include<iostream.h>
<br />#include<conio.h>
<br />#include<iomanip.h>
<br />void main()
<br />{
<br />int i, j, tmp, jumdata;
<br />int data[] = {5, 100, 20, 31, 77, 88, 99, 20, 55, 1};
<br />jumdata = sizeof(data)/sizeof(int);
<br />// Menampilkan data
<br />cout << "Data semula: " << endl;
<br />for(i=0; i<jumdata; i++)
<br />cout << setw(4) << data[i];
<br />cout << endl; // Pindah baris
<br />// Mengurutkan data
<br />for(i=0; i<jumdata-1; i++)
<br />for(j=i+1; j<jumdata; j++)
<br />if (data[i] > data[j])
<br />{
<br />tmp = data[i];
<br />data[i] = data[j];
<br />data[j] = tmp;
<br />}
<br />// Menampilkan data
<br />cout << "Data setelah diurutkan: " << endl;
<br />for (i=0; i<jumdata; i++)
<br />cout << setw(4) << data[i];
<br />cout << endl; // Pindah baris
<br />}apa aja boleeehhttp://www.blogger.com/profile/18285557206760455506noreply@blogger.com0