Kamus Misuh Surabaya - Inggris (Repost, ngambil dari kaskus.us)

... (Klik untuk selengkapnya)

Queue dengan C++

Queue, kebalikan dari stack yang memiliki metode LIFO (Last in First Out). Dalam queue, metode yang digunakan adalah First In First Out (FIFO), dimana data yang masuk duluan maka akan terlebih dulu keluar. Contohnya seperti antrian nasabah bank, dimana nasabah yang pertama datang yang akan terlebih dahulu dilayani oleh teller. Di bawah ini adalah source code dari class queue.

Dalam source code di bawah ini data-data akan tersimpan dalam suatu circular array.
Circular array adalah array yang peng-index-annya seperti siklus yang berputar-putar. Ketika sudah mencapai index terakhir, pada increment selanjutnya akan kembali ke index awal.

Dalam penerapannya pada queue, terdapat variabel penyimpan index bernama front dan rear, yang menandakan data terdepan dan terbelakang dari suatu queue. Karena queue ini menggunakan circular, maka tidak selamanya front lebih kecil dari rear.

//--------------------------------------------------------//

#include "warga.h"

#define max 10

class queue
{
private:
int data[max];
int front, rear, count;
public:
queue();
bool isempty(); //penanda queue kosong
bool isfull(); //penanda queue penuh
int getfront(); //melihat index data terdepan
int getrear(); //melihat index data terbelakang
void enqueue(int data); //fungsi untuk memasukkan data ke dalam queue
warga dequeue(); fungsi untuk mengambil data dari queue
int getcount(); //melihat jumlah data yang ada dalam queue
~queue();
};

//Implementasi fungsi-fungsi dari class:

queue::queue()
{
front = -1;
rear = -1;
count = 0;
}

bool queue::isempty()
{
return (count == 0);
}

bool queue::isfull()
{
return (count >= max);
}

int queue::getfront()
{
return front;
}

int queue::getrear()
{
return rear;
}

void queue::enqueue(int data)
{
count++;
rear = (rear + 1) % max;
this->data[rear] = data;
}

int queue::dequeue()
{
count--;
front = (front + 1) % max;
return data[front];
}

int queue::getcount()
{
return count;
}

queue::~queue()
{
}

//--------------------------------------------------------// ... (Klik untuk selengkapnya)

Doubly Linked List dengan C++

Bedanya doubly linked list dengan singly linked list yaitu setiap node pada doubly linked memiliki pointer yang menunjuk ke node sebelumnya. Berbeda dengan singly linked list yang hanya punya pointer yang menuju ke node setelahnya. Berikut source code class doubly linked list.

//--------------------------------------------------------//


#include "iostream"

using namespace std;

class linkedlist
{
private:
struct node
{
int data;
node *next, *prev;
} *head, *tail;
public:
linkedlist();
bool isempty();
void addfirst(int data);
void addlast(int data);
void addafter(int data, int index);
void delfirst();
void dellast();
void del(int index);
int get(int index);
~linkedlist();
};

//Implementasi fungsi-fungsi dalam class:

#include "linkedlist.h"

linkedlist::linkedlist()
{
head = tail = NULL;
}

bool linkedlist::isempty()
{
return head == NULL;
}

void linkedlist::addfirst(int data)
{
node *baru = new node;
baru->data = data;
if(isempty())
{
head = tail = baru;
baru->next = baru->prev = NULL;
}
else
{
baru->next = head;
baru->prev = NULL;
head->prev = baru;
head = baru;
}
}

void linkedlist::addlast(int data)
{
node *baru = new node;
baru->data = data;
if(isempty())
{
head = tail = baru;
baru->next = baru->prev = NULL;
}
else
{
baru->prev = tail;
baru->next = NULL;
tail->next = baru;
tail = baru;
}
}

void linkedlist::addafter(int data, int index)
{
node *baru = new node, *temp = head;
baru->data = data;
for(int i = 0; i < index - 1 && temp->next != NULL; i++)
temp = temp->next;
baru->next = temp->next;
baru->prev = temp;
temp->next->prev = baru;
temp->next = baru;
}

void linkedlist::delfirst()
{
if(isempty()) return;
else if(head == tail)
{
head = NULL;
delete head;
return;
}
else
{
node *temp = head;
head = temp->next;
head->prev = NULL;
delete temp;
}
}

void linkedlist::dellast()
{
if(isempty()) return;
else if(head == tail)
{
delete head;
return;
}
else
{
node *temp = tail;
tail = temp->prev;
tail->next = NULL;
delete temp;
}
}

void linkedlist::del(int index)
{
if(isempty()) return;
node *temp = head;
for(int i = 0; i < index - 1 && temp->next != NULL; i++)
temp = temp->next;
node *temp2 = temp->prev;
temp2->next = temp->next;
temp->next->prev = temp2;
temp = NULL;
delete temp;
}

int linkedlist::get(int index)
{
if(isempty()) return -1;
node *temp = head;
for(int i = 0; i < index - 1 && temp->next != NULL; i++)
temp = temp->next;
return temp->data;
}

linkedlist::~linkedlist()
{
node *q;
q = head;
if(head == NULL) return;
while(q != NULL)
{
q = head->next;
delete head;
head = q;
}
}

//--------------------------------------------------------//

... (Klik untuk selengkapnya)

Stack dengan C++

Stack adalah struktur data yang menggunakan metode first in first out, yaitu data yang terakhir masuk yang keluar duluan. Contoh kasus stack misalnya dalam sebuah tumpukan piring. Ketika kita menumpukkan piring satu per satu hingga beberapa tumpukan, kemudian kita ingin mengambil piring dari tumpukan tersebut. Maka piring yang terambil pertama adalah piring yang terakhir kita letakkan dalam tumpukan. Berikut ini adalah source code stack menggunakan bahasa C++.

//--------------------------------------------------------//

#include "iostream"

#define max 10
using namespace std;

class stack
{
private:
int top;
int data[max];

public:
stack();
int gettop(); //untuk mengambil index data teratas/terakhir dari class stack
bool isfull(); //fungsi yang menandakan bahwa stack penuh
bool isempty(); //fungsi yang menandakan bahwa stack kosong
void push(int data); //perintah yang digunakan untuk memasukkan data ke dalam stack
int pop(); //perintah yang digunakan untuk mengambil data teratas dari stack
~stack();
};

//Implementasi fungsi-fungsi dalam class:

stack::stack()
{
top = -1;
}

int stack::gettop()
{
return top;
}

bool stack::isfull()
{
return (top >= max);
}

bool stack::isempty()
{
return (top == -1);
}

void stack::push(int data)
{
if(!(this->full()))
this->data[++top] = data;
}

int stack::pop()
{
return data[top--];
}

stack::~stack()
{
}

//--------------------------------------------------------//

Mudah bukan? hehe.. ... (Klik untuk selengkapnya)

Singly Linked List dengan C++

Berikut ini source code class linked list buatan saya.. B-)
Di sini tipe data yang digunakan adalah integer. Tipe data bisa diganti sesuai kebutuhan.

//--------------------------------------------------------//

#include "iostream"

using namespace std;

class linkedlist
{
private:
struct node
{
int data;
node *next;
} *head, *tail;
public:
linkedlist(); //constructor
bool isempty(); //cek kosongnya list
void addfirst(int data); //menambah data pada list dari awal
void addlast(int data); //menambah data pada list dari belakang
void addafter(int data, int index); //menambah data pada list setelah indeks yang ditentukan
void delfirst(); //menghapus data awal dari list
void dellast(); //menghapus data akhir dari list
void deletion(int index); //menghapus data indeks ke-n dari list
int get(int index); //mengambil data index ke-n tanpa menghapusnya
~linkedlist(); //destructor
};

//Implementasi fungsi-fungsi dalam class:

linkedlist::linkedlist()
{
head = tail = NULL;
}

bool linkedlist::isempty()
{
return head == NULL;
}

void linkedlist::addfirst(int data)
{
node *baru = new node;
baru->data = data;
if(isempty())
{
head = tail = baru;
baru->next = NULL;
}
else
{
baru->next = head;
head = baru;
}
}

void linkedlist::addlast(int data)
{
node *baru = new node;
baru->data = data;
if(isempty())
{
head = tail = baru;
baru->next = NULL;
}
else
{
tail->next = baru;
tail = baru;
tail->next = NULL;
}
}

void linkedlist::addafter(int data, int index)
{
node *baru = new node, *temp = head;
baru->data = data;
for(int i = 0; i <>next != NULL; i++)
temp = temp->next;
baru->next = temp->next;
temp->next = baru;
}

void linkedlist::delfirst()
{
node *temp = head;
if(isempty()) return;
else
{
head = temp->next;
temp = NULL;
delete temp;
}
}

void linkedlist::dellast()
{
node *temp = head;
if(isempty()) return;
else if(head == tail)
{
delete head;
return;
}
for(int i = 0; temp->next->next != NULL; i++)
temp = temp->next;
tail = temp;
temp->next = NULL;
delete temp->next;
}

void linkedlist::deletion(int index)
{
node *temp = head, *temp2;
if(isempty()) return;
for(int i = 0; i <>next != NULL; i++)
temp = temp->next;
temp2 = temp->next;
temp->next = temp->next->next;
temp2 = NULL;
delete temp2;
}

int linkedlist::get(int index)
{
node *temp = head;
if(isempty()) return -1;
for(int i = 0; i <>next != NULL; i++)
temp = temp->next;
return temp->data;
}

linkedlist::~linkedlist()
{
node *q;
q = head;
if(head == NULL) return;
while(q != NULL)
{
q = head->next;
delete head;
head = q;
}
}

//--------------------------------------------------------//

... (Klik untuk selengkapnya)