Konsep Dasar Struktur data
Konsep Dasar Pointer
Struktuk
data adalah sebuah bagian dari ilmu pemrograman dasar yang mempuyai
karakteristik yang terkait dengan sifat dan cara penyimpanan sekaligus pengguna
atau pengakses data.
Struktuk
data bertujuan agar cara mereprentsikan data dalam membuat program dapat
dilakuian secara efesien dalam pengolahan di memori dan pengolahan penyimpanan
dari program ke storage juga lebih mudah dilakukan.
Array
adalah kumpulan elemen-elemen data. Kumpulan elemen tersebut mempunyai susunan
yang teratur. Jmlah elemen terbatas, dan semua elemen mempunyai tipe data yang
sama. Jenis-jenis array :
Array Satu Dimensi
Setruktur array suatu dimensi dapat
di deklarasikan dengan bentuk umum berupa: tipe_var nama_var [ukuran];
Dengan:
-
Tipe_var: untuk menyatakan jenis elemen array
(misalnya int,char,unsigned)
-
Nama_var: untuk menyatakan nama variable yang
dipakai
-
Ukuran: untuk menyatakan jumlah maksimal elemen
array.
Contoh
: float nilai_ujian [5];
Array
Dua Dimensi
Tipe
data array dua dimensi bisa digunakan ntuk menyimpan, mengolah maupun
menampilkan suatu data dalam bentuk
table atau matriks. Untuk mendeklarasikan array agar dapat menyimpan data
adalah :
Tipe_var_nama_var[ukuran1][ukuran2];
Dimana
:
-
Ukuran1 menunjukkan jumlah/nomor baris.8
-
Ukuran2 menunukan jumlah/nomor kolom.
Jumlah
elemen yang di milki array dua dimensi dapat ditentukan dari hasil perkalian :
Ukuran1
X ukuran2.
Seperti
halnya pada array satu dimensi, data array dua dimensi akan ditempatkan pada
memori secara berurutan.
Array
multidimensi/Dimensi Banyak
Array
berdimensi banyak atau multidimensi terdiri dari array yang tidak terbatas
hanya dua dimensi saja. Bentuk umum pendeklarasian array multi dimensi adalah :
tipe_var nama_var [ukuran1][ukuran2]…[ukuran];
Contoh
: int data_angka [3][6][6];
Yang
merupan array tiga dimensi
Pointer adalah sebuah variable yang berisi alamat
variable yang lain. Satu pointer dimksudkan untuk menunjuk kesuatu alamat
memori sehingga alamat dari suatu variable dapat diketahui dengan mudah
1. Program pangkat dengan array
dimensi satu
#include <stdio.h>
#include <iostream>
#include <conio.h>
using namespace std;
int main(){
int
square[100];
int i;
int k;
for (i=0;
i<10; i++){
k
= i+1;
square[i]
= k*k;
printf("\n
pangkat dari %d adalah %d ", k, square[i]);
}
getch();
}
Hasil Output:
2. Program array
dimensi dua
#include <stdio.h>
#include <iostream>
#include <conio.h>
using namespace std;
void printArray(int [][3]);
int main(){
int
matrik1[2][3] = {{1,2,3},{4,5,6}},matrik2[2][3]={1,2,3,4,5},matrik3[2][3]={{1,2},{4}};
printArray(matrik1);
printArray(matrik2);
printArray(matrik3);
getch();
}
void printArray(int a[][3]){
int i,j;
for(i=0;
i<=1; i++){
for
(j=0; j<=2; j++)
printf("%d
", a[i][j]);
printf("\n");
}
}
Hasil
Output:
Program
input ke variabel bilangan: menghitung akar
#include
<stdio.h>
#include
<stdlib.h>
#include
<iostream>
#include
<conio.h>
#include
<malloc.h>
using
namespace std;
void
p(void);
int
*a, *b;
void
main()
{
p();
}
void
p(void)
{
a = (int *)malloc(sizeof(int));
b = (int *)malloc(sizeof(int));
*a=19;
*b=5;
a=b;
*b=8;
printf("alamat a = %x\t isi a =
%d\n", a,*a);
printf("alamat b = %x\t isi b =
%d\n", b,*b);
getch();
}
Hasil Output:
LINKED LIST (SENARAI)
Linked
List
adalah sejumlah objek atau elemen yang dihubungkan satu dengan lainya sehingga
membentuk suatu list. Sedangkan objek atau elemen itu sendiri adalah merupakan
gabungan beberapa data(variable) yang dijadikan satu kelompok atau structure atau record yang dibentuk dengan perintah struct. Untuk menggabungkan objek satu dengan lainya, diperlukan
paling tidak sebuah variable yang bertipe pointer. Syarat linked list adalah harus dapat diketahui alamat simpul pertama atau
biasa dipakai variable First/Start/Header.
Contoh program sisip senarai (linked list)
#include <iostream>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
using namespace std;
typedef struct nod{
int data;
struct nod *next;
} NOD, *NODPTR;
void Ciptasenarai(NODPTR
*s)
{
*s = NULL;
}
NODPTR NodBaru(int m)
{
NODPTR n;
n = (NODPTR) malloc (sizeof(NOD));
if (n!=NULL)
{
n->data=m;
n->next=NULL;
}
return n;
}
void SisiSeranai(NODPTR
*s, NODPTR t, NODPTR p)
{
if(p==NULL)
{
t->next=*s;
*s=t;
}
else
{
t->next=p->next;
p->next=t;
}
}
void CetakSeranai(NODPTR
s)
{
NODPTR ps;
for(ps=s; ps!=NULL; ps=ps->next)
printf("%d --> ",ps ->data);
printf("NULL \n");
}
int main()
{
NODPTR pel;
NODPTR n;
Ciptasenarai(&pel);
n=NodBaru(55);
SisiSeranai(&pel, n, NULL);
n=NodBaru(75);
SisiSeranai(&pel, n, NULL);
CetakSeranai(pel);
getch();
}
Hasil
Output :
STACK (TUMPUKAN)
Stack adalah kumpulan
elemen-elemen yang tersimpan dalam suatu
tumpukan. Aturan penyisipan dan penghapusan elemennya tertentu:
-Penyisipan selalu
dilakukan ”di atas” TOP
-Penghapusan selalu
dilakukan pada TOP
Karena aturan penyisipan
dan penghapusan semacam itu, TOP adalah satu-satunya alamat tempat terjadi
operasi, elemen yang ditambahkan paling akhir akan menjadi elemen yang akan
dihapus. Dikatakan bahwa elemen Stack tersusun secara LIFO (Last In First Out).
Seperti halnya jika kita
mempunyai sebuah tumpukan buku, agar tumpukan buku itu tidak ambruk ketika kita
mengambil sebuah buku di dalam tumpukan itu maka harus diambil satu per satu
dari tumpukan yang paling atas dari tumpukan.
Program
Stack
#include <stdio.h>
#include <conio.h>
#include <iostream>
#define MAXSTACK 3
typedef int itemType;
typedef struct
{
int item [MAXSTACK];
int jml;
} Stack;
void init(Stack *s)
{
s->jml=0;
}
int kosong(Stack *s)
{
return (s->jml==0);
}
int penuh(Stack *s)
{
return (s->jml==MAXSTACK);
}
void isi(itemType x,
Stack *s)
{
if(penuh(s))
printf("\nMAAF!!! Data PENUH\n");
else{
s->item[s->jml]=x;
++(s->jml);
}
}
void ambil(Stack *s,
itemType *x)
{
if(kosong(s))
printf("\nMAAF Data Kosong\n");
else
{
--(s->jml);
*x=s->item[s->jml];
s->item[s->jml]=0;
printf("\Data %i Berhasil
Diambil\n",*x);
}
}
void tampil(Stack *s)
{
if(kosong(s))
printf("\Maaf Data Masih Kosong\n");
else
printf("\n");
for(int
i=s->jml-1;i>=0;i--)
{
printf("Data:
%d\n",s->item[i]);
}
}
void hapus(Stack *s)
{
s->jml=0;
printf("\nSemua Data Berhasil Dihapus\n");
}
int main()
{
int pil;
Stack tumpukan;
itemType data;
init(&tumpukan);
do{
printf("\nMENU: \n 1. Isi (Data Angka)\n
2. Ambil\n 3. Lihat\n 4. Hapus (Hapus Semua Data)\n 5. Keluar\n");
printf("\n");
printf("Masukkan Pilihan : "); scanf("%i",&pil);
switch(pil)
{
case 1:
printf("\nMasukkan
Data Angka : "); scanf("%i",&data);;
isi(data,&tumpukan);
break;
case 2:
ambil(&tumpukan,&data);
break;
case 3 :
tampil(&tumpukan);
break;
case 4 :
hapus(&tumpukan);
break;
}
}while(pil!=5);
getch();
}
Hasil Output :
QUEUE (ANTRIAN)
Antrian adalah
suatu kumpulan data yang penambahan elemennya hanya bisa dilakukan pada suatu
ujung (disebut sisi belakang atau REAR), dan penghapusan atau pengambilan
elemen dilakukan lewat ujung yang lain (disebut sisi depan atau FRONT). Prinsip
yang digunakan dalam antrian ini adalah FIFO (First In First Out) yaitu elemen
yang pertama kali masuk akan keluar pertama kalinya. Penggunaan antrian antara
lain simulasi antrian di dunia nyata (antrian pembelian tiket), sistem jaringan
komputer (pemrosesan banyak paket yang datang dari banyak koneksi pada suatu
host，bridge，gateway),
dan Iain-lain.
Elemen
Karakteristik penting antrian sebagai berikut:
a. Elemen antrian yaitu
item-item data yang terdapat dalam antrian.
b. Head/front (elemen terdepan
antrian).
c. Tail/rear (elemen terakhir
antrian).
d. Jumlah
antrian pada antrian {count).
e. Status/kondisi
antrian, ada dua yaitu :
-Penuh
Bila elemen di
antrian mencapai kapasitas maksimum antrian. Pada kondisi ini, tidak mungkin
dilakukan penambahan ke antrian. Penambahan di elemen menyebabkan kondisi
kesalahan Overflow.
-Kosong
Bila tidak ada
elemen antrian. Pada kondisi ini, tidak mungkin dilakukan pengambilan elemen
antrian. Pengambilan elemen menyebabkan kondisi kesalahan Underflow.
Program Queue Statis
#include <queue>
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
queue
<int> que;
que.push(10);
que.push(2);
que.push(30);
cout<<"Paling
depan : "<<que.front()<<endl;
cout<<"Paling
belakang : "<<que.back()<<endl;
que.pop();
cout<<"10
sudah dikeluarkan"<<endl;
cout<<"Paling
depan : "<<que.front()<<endl;
cout<<"Paling
belakang : "<<que.back()<<endl;
que.push(6);
cout<<"Angka
6 dimasukkan"<<endl;
cout<<"Paling
depan : "<<que.front()<<endl;
cout<<"Paling
belakang : "<<que.back()<<endl;
getch();
}
OUTPUT :
REKURSIF
PENYAJIAN (TUTORIAL)
Fungsi rekursif adalah suatu
fungsi yang memanggil dirinya sendiri，artinya fungsi tersebut dipanggil
di dalam tubuh fungsi itu sendiri. Contoh menghitung nilai factorial. Rekursif
sangat memudahkan untuk memecahkan permasalahan yang kompleks. Sifat-sifat
rekursif:
a)
Dapat digunakan ketika inti dari masalah terjadi berulang kali.
b)
Sedikit lebih efisien dari iterasi tapi lebih elegan.
c)
Method-methodnya dimungkinkan untuk memanggil dirinya sendiri.
Data yang
berada dalam method tersebut seperti argument disimpan sementara ke dalam stack
sampai method pemanggilnya diselesaikan.
Program Bilangan Genap dan Bilangan Ganjil
#include <iostream>
#include <conio.h>
using namespace std;
void odd (int a);
void even(int a);
int main(void)
{
int
i;
do
{
cout<<"Masukkan
Bilangan 1 - 9 (0 untuk keluar) : \n";
cin>>i;
odd(i);
cout<<endl;
}
while (i!=0);
getch();
}
void odd(int
a)
{
if ((a%2) !=0) cout <<
"Bilangan GANJIL \n";
else
even (a);
}
void even(int
a)
{
if ((a%2) ==0) cout <<
"Bilangan GENAP \n";
else
odd (a);
}
Hasil Output :
SORTING (PENGURUTAN)
Pengurutan data
(sorting) didefinisikan sebagai suatu proses untuk menyusun kembali himpunan
obyek menggunakan aturan tertentu. Ada dua macam urutan yang biasa digunakan
dalam proses pengurutan yaitu :
Urutan naik
{ascending) yaitu dari data yang mempunyai nilai paling kecil sampai paling
besar.
Urutan turun
(descending) yaitu dari data yang mempunyai nilai paling besar sampai paling
kecil.
Contoh : data
bilangan 5, 2, 6，dan
4 dapat diurutkan naik menjadi 2, 4, 5, 6 atau diurutkan turun menjadi 6, 5, 4,
2. Pada data yang bertipe char, nilai data dikatakan lebih kecil atau lebih
besar dari yang lain didasarkan pada urutan relatif (collating sequence)
seperti dinyatakan dalam tabel ASCII. Keuntungan dari data yang sudah dalam
keadaan terurut yaitu :
Data mudah
dicari, mudah untuk dibetulkan, dihapus，disisipi atau digabungkan. Dalam
keadaan terurutkan, kita mudah melakukan pengecekan apakah ada data yang
hilang. Misalnya kamus bahasa, buku telepon. Mempercepat proses pencarian data
yang harus dilakukan berulang kali. Beberapa faktor yang berpengaruh pada
efektifitas suatu algoritma pengurutan antara lain :
Banyak data yang
diurutkan.
Kapasitas
pengingat apakah mampu menyimpan semua data yng kita miliki. Tempat penyimpanan
data, misalnya piringan, pita atau kartu, dll.
Beberapa
algoritma metode pengurutan dan prosedurnya sebagai berikut:
Bubble Sort
Bubble Sort
adalah suatu metode pengurutan yang membandingkan elemen yang sekarang dengan
elemen berikutnya. Apabila elemen sekarang > elemen berikutnya, maka
posisinya ditukar. Kalau tidak, tidak perlu ditukar. Diberi nama “Bubble”
karena proses pengurutan secara berangsur-angsur bergerak/berpindah ke
posisinya yang tepat, seperti gelembung yang keluar dari sebuah gelas bersoda.
Proses Bubble Sort:
Data paling akhir dibandingkan
dengan data di depannya，jika ternyata lebih kecil atau besar maka tukar sesuai
dengan ketentuan (descending atau ascending). Dan pengecekan yang sama
dilakukan terhadap data yang selanjutnya sampai dengan data yang paling awal
Selection Sort
Metode seleksi
melakukan pengurutan dengan cara mencari data yang terkecil kemudian
menukarkannya dengan data yang digunakan sebagai acuan atau sering dinamakan
pivot. Selama proses, pembandingan dan pengubahan hanya dilakukan pada indeks
pembanding saja, pertukaran data secara fisik terjadi pada akhir proses. Proses
pengurutan dengan metode seleksi dapat dijelaskan sebagai berikut:
Langkah pertama
dicari data terkecil dari data pertama sampai data terakhir. Kemudian data
terkecil ditukar dengan data pertama. Dengan demikian, data pertama sekarang
mempunyai nilai paling kecil dibanding data yang lain.
Langkah kedua,
data terkecil kita cari mulai dari data kedua sampai terakhir. Data terkecil
yang kita peroleh ditukar dengan data kedua dan demikian seterusnya sampai
semua elemen dalam keadaan terurutkan.
Program Ascending dengan
menggunakan Buble Sort
#include <iostream>
#include <conio.h>
#include <iomanip>
using namespace std;
void main (void)
{
int
dataku[] = {5, 34, 32, 25, 75, 42, 2};
int
adaPertukaran;
int
n;
cout<<
"Data BELUM diurutkan : \n";
for
(int ctr = 0; ctr<7; ctr++)
{
cout
<< setw(3) << dataku[ctr];
}
cout
<< endl <<endl;
do
{
adaPertukaran
= 0;
for
(int i = 0; i < 7-1; i++)
{
if
(dataku[i+1] < dataku[i])
{
n
= dataku[i];
dataku[i]
= dataku[i+1];
dataku[i+1]
= n;
adaPertukaran
= 1;
}
}
}
while
(adaPertukaran == 1);
cout<<
"Data SETELAH diurutkan ; \n";
for
(int i = 0; i <7; i++)
{
cout
<< dataku[i];
cout
<< " ";
}
getch();
}
OUTPUT :
Program ascending dengan
menggunakan selection sort
#include <stdio.h>
#include <iostream>
#include <conio.h>
using namespace std;
int data[10], data2[10];
int n;
void Select(int a, int b)
{
int
t;
t
= data[b];
data[b]
= data[a];
data[a]
= t;
}
void selection_sort()
{
int
pos,i,j;
for(i=1;i<=n-1;i++)
{
pos
= i;
for(j
= i+1;j<=n;j++)
{
if(data[j]
< data[pos]) pos = j;
}
if(pos!=i)
Select(pos,i);
}
}
int main()
{
cout<<"===
PROGRAM SELECTION SORT==="<<endl; cout<<endl;
cout<<"Masukkan
Jumlah Data : ";
cin>>n;
for(int
i=1;i<=n;i++)
{
cout<<"Masukkan
Data Ke - "<<i<<" : ";
cin>>data[i];
data2[i]=data[i];
}
selection_sort();
cout<<"\n\n";
cout<<"Data
Setelah di Sort : ";
for(int
i=1;i<=n;i++)
{
cout<<"
"<<data[i];
}
cout<<"\n\n
Proses Selesai \n";
_getch();
}
OUTPUT :
Komentar
Posting Komentar