Selasa, 25 Februari 2020

Summary Data Struktur

Linked list merupakan suatu kumpulan data yang ditaruh dengan random acces memory. Linked list sama seperti array namun mempunyai perbedaan antara keduanya. kita dapat membuat dan mengakses linked list yang dimana data kita simpan itu adalah random. Kita dapat mencari data yang berada di linked list dengan cara menunjuk yang paling dekat dengannya. Dengan algoritma sebagai berikut :

Source : https://www.geeksforgeeks.org/linked-list-set-1-introduction/

Linked list mempunyai beberapa jenis nya yaitu :

1. Circular Single Linked List

 Circular Single Linked List adalah dimana linked list saling berhubungan untuk mengambil informasi yang dimana terdapat Null pada setiap data dan selalu ada di akhir data.



Source : https://www.geeksforgeeks.org/circular-linked-list/

Untuk Circular Single Linked List sendiri kita sudah mengetahui bahwa logika dari linked list ini adalah : 
- head yang merupakan suatu data random yang dipilih untuk mencari sebuah data.
- node yang merupakan suatu data null pada akhir data yang dapat mencari dan menunjuk sebuah       data yang ingin dicari.
- tail merupakan suatu akhiran data yang dimana kita telah menemukan suatu data yang ingin dicari.
- next merupakan data selanjutnya untuk dicari.
- Null merupakan suatu angka nilai kosong.


2. Doubly Linked List 

Doubly Linked List adalah dimana linked list sama seperti Cingular Single Linked List tetapi dengan Doubly Linked List ialah dapat menjalankan perintah secara berulang untuk mencari angka, apabila data pada tail adalah bukan data yang dcari maka kita akan mencari data benar dengan menjalankan looping. Algoritmanya seperti berikut : 


Source : https://www.geeksforgeeks.org/doubly-linked-list/

Seperti kita lihat seperti gambar diatas adalah implementasi dari Doubly linked list yang dapat mengakses data selanjutnya (next) dan looping apabila data tidak ditemukan (prev).
Untuk algoritma codingan dalam bahasa C : 

Kita menggunakan struct untuk menyimpan data Linked List

struct Node {
    int data;
    struct Node* next; // Pointer to next node in DLL
    struct Node* prev; // Pointer to previous node in DLL
}; Logika Algoritma dari gambar : Contoh lainnya adalah ketika kita menambahkan data baru namun data lama akan dihapus - Data baru akan terdeteksi apabila kita menambahkan sebuah data - kita menghapus data lama dengan cara free(data). - untuk itu kita menyambungkan data baru dengan data sebelumnya agar tidak terpisah *mohon maaf untuk source code lebih lengkap di https://www.geeksforgeeks.org/doubly-linked-list 3. Circular Doubly Linked List Circular Doubly Linked List hampir sama dengan kedua linked list di atas, tetapi dia bedanya hanya gabungan antara Circular Single Linked List yang mempunyai algoritma mencari saja dan dengan Doubly Linked List yang tidak hanya mencari dengan 1 jalur tetapi dengan banyak jalur untuk gambarnya seperti berikut :
Source : https://www.geeksforgeeks.org/doubly-circular-linked-list-set-1-introduction-and-insertion/


Ada beberapa penggunaan dalam Struktur data yaitu Stack dan Queue, namun kita disini bahas Stack terlebih dahulu 

STACK 

Stack pada dasarnya adalah daftar tertaut atau array di mana data hanya dapat disisipkan dari belakang atau atas dan data hanya dapat diambil dari belakang atau atas juga. Bayangkan Anda menumpuk koin, persis seperti itu. Ketika Anda menumpuk koin, Anda harus meletakkan koin dari atas dan mengambilnya satu per satu dari atas juga. 
Stack biasa digunakan untuk menumpuk data dan mengambilnya dengan data paling atas.

Berikut Codingan tentang Stack pada data :

// C program for array implementation of stack
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
  
// A structure to represent a stack
struct Stack {
    int top;
    unsigned capacity;
    int* array;
};
  
// function to create a stack of given capacity. It initializes size of
// stack as 0
struct Stack* createStack(unsigned capacity)
{
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}
  
// Stack is full when top is equal to the last index
int isFull(struct Stack* stack)
{
    return stack->top == stack->capacity - 1;
}
  
// Stack is empty when top is equal to -1
int isEmpty(struct Stack* stack)
{
    return stack->top == -1;
}
  
// Function to add an item to stack.  It increases top by 1
void push(struct Stack* stack, int item)
{
    if (isFull(stack))
        return;
    stack->array[++stack->top] = item;
    printf("%d pushed to stack\n", item);
}
  
// Function to remove an item from stack.  It decreases top by 1
int pop(struct Stack* stack)
{
    if (isEmpty(stack))
        return INT_MIN;
    return stack->array[stack->top--];
}
  
// Function to return the top from stack without removing it
int peek(struct Stack* stack)
{
    if (isEmpty(stack))
        return INT_MIN;
    return stack->array[stack->top];
}
  
// Driver program to test above functions
int main()
{
    struct Stack* stack = createStack(100);
  
    push(stack, 10);
    push(stack, 20);
    push(stack, 30);
  
    printf("%d popped from stack\n", pop(stack));
  
    return 0;
}

Source : https://www.geeksforgeeks.org/stack-data-structure-introduction-program/



QUEUE

Queue atau yang berarti data yang berurutan dan selalu tidak melupakan data yang pertama sehingga tidak adanya penumpukan data dan hal ini pun bisa terjadi logika yang sama seperti Stack namun umumnya secara singkat Queue ialah semacam perintah untuk menjalankan tanpa mendahulukan data yang ingin ditimpa.

HASHING TABLE

Hashing table merupakan suatu fungsi yang digunakan untuk menjalankan suatu perintah menurut ASCII, seperti contoh table dalam data hewan berurutan seperti dimulai dari huruf a dengan ASCII 65.

Berikut Codingan yang saya pelajari selama saya belajar

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

struct data{
char name[25];
int age;
};
const int tableSize = 29;
struct data hashTable[tableSize];

int generateKey(const char *name){
int result = name[0] - 'A';
return result;
}

void init(){
for(int i=0; i<tableSize; i++){
hashTable[i].age = -1;
strcpy(hashTable[i].name, "");
}
}

void insert(const char *name, int age){
int key = generateKey(name);
hashTable[key].age = age;
strcpy(hashTable[key].name, name); 
}

void viewHash(){
for(int i=0; i<tableSize; i++){
printf("%-15s %-2d\n", hashTable[i].name, hashTable[i].age);
}
}

int main(){
//print key dari huruf yang akan di sorting dari a - z
// printf("%d\n", generateKey("atan"));
// printf("%d\n", generateKey("char"));
// printf("%d\n", generateKey("define"));
// printf("%d\n", generateKey("exp"));
// printf("%d\n", generateKey("float"));
insert("Andi", 18);
insert("charlie", 8);
insert("Deni", 29);
insert("Eka", 25);
insert("Felix", 49);
//Catatan : apabila huruf awal a kecil maka akan error, karna pada saat generatekey itu adalah A besar
viewHash();
return 0;
}

BINARY TREE

Merupakan suatu data yang diurutkan berdasarkan infix atau postfix.Infix yang berarti fix dari String yang kita tahu seperti 6+2(4x6). yang kita tahu bahwa kita melihat operand(angka) dan operator pasti selalu terlibat di kedua sisi sedangkan operator di tengah, sedangkan infix-postfix menjadi 624*+ yang dimana diurutkan berdasarkan priority dan sebagai catatan Postfix yaitu 2 operand dengan 1 operator disebelah kanan. 

Contoh Singkat Binary Tree

#include<stdio.h>
#include<stdlib.h>

struct data{
int key;
struct data *left;
struct data *right;
};

struct data *newNode(int key){
struct data *curr = (struct data *) malloc(sizeof(struct data));
curr->key = key;
curr->left = NULL;
curr->right = NULL;
return curr;
}

void inOrder(struct data *root){
if(root){
inOrder(root->left);
printf("%d ", root->key);
inOrder(root->right);
}
}

void preOrder(struct data *root){
if(root){
printf("%d ",root->key);
preOrder(root->left);
preOrder(root->right);
}
}

void postOrder(struct data *root){
if(root){
postOrder(root->left);
postOrder(root->right);
printf("%d ",root->key);
}
}

struct data *freeAll(struct data *root){
if(root){
freeAll(root->left);
freeAll(root->right);
free(root);
root = NULL;
}
return root;
}

int main(){
struct data *root = newNode(5);
root->left = newNode(10);
root->right = newNode(19);
root->left->right = newNode(8);
root->left->left = newNode(98);
// inOrder(root);
// preOrder(root);
postOrder(root);
root = freeAll(root);
return 0;
}

TUGAS DREAMS MARKET MENGGUNAKAN DOUBLE LINKED LIST

*codingan ini belum selesai dan saya pun masih belajar mengenai hal ini

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

struct data{
int qty;
char namePro[255];
struct data *prev;
struct data *next;
}*head = NULL,*tail = NULL;

void insertData(data){
struct data *curr = (struct data *)malloc(sizeof(struct data));
curr->qty = qty;
strcpy(curr->namePro,name);
curr->next = NULL;
if(head == NULL){
head = tail = curr;
curr->prev = NULL;
}else{
tail->next = curr;
curr->prev = tail;
tail = curr;
}
}
void print(){
struct data *curr = head;
while(curr!=NULL){

printf("Qty : %d\nNama : %s\n",curr->qty,curr->namePro);
curr = curr->next;
}
printf("\n");
}a
void addItem(){
int a;
char namePro[254]="";
do{
printf("Please input qty[0-100]: ");
scanf("%d",&a);getchar();
}while(a < 0 || a >100);
printf("Please input name product[Min 3 Char]: ");
scanf("%[\n]",namePro);getchar();
insertData(a,namePro);
printf("Data Succesfully Added!!\n");
}
void editItem(){
}
void checkout(){
}

void menu(){
int select;
do{
printf("===============WELCOME===============\n");
printf("1. Add Item\n");
printf("2. Edit Item\n");
printf("3. Checkout\n");
printf("4. Check Item\n");
printf("5. Exit\n");
printf(">>");
scanf("%d",&select);getchar();
switch(select){
case 1 : 
addItem();
break;
case 2 : 
editItem();
break;
case 3 : 
checkout();
break;
case 4 :
print();
break;
}
}while(select!=5);
}

int main(){
menu();
return 0;
}


Diposting oleh di Tidak ada komentar:
Langganan: Postingan (Atom)