TUGAS

STRUKTUR DATA

NAMA : MURNIATI

KELAS : PTIK F

NIM : 210209500017

UNIVERSITAS NEGERI MAKASSAR

PENDIDIKAN TEKNIK INFORMATIKA DAN KOMPUTER
FAKULTAS TEKNIK
2022/2023
3 Metode sorting beserta souece code dan analisisnya

1. Shell short
Shell sort merupakan salah satu algoritma pengurutan yang lebih handal dibandingkan
Selection Sort dan Bubble Sort. Kehandalannya yaitu: “Membagi deret data menjadi dua
bagian. Masing-masing bagian diurutkan menggunakan Bubble Sort. Tidak menggunakan
iterasi melainkan increment
 Contoh source code shell sort

#include "stdio.h"

int main()
{
int L[20],temp,i,j,n=6,m;
printf("pengurutan berdasarkan Shell sort \nmasukkan %d elements: \n",n);
for(i=0;i<n;i++){
scanf("%d",&L[i]);}

printf("\nsebelum sorting: ");

for(i=0;i<n;i++){printf("%d ",L[i]);}

for(m = n/2;m>0;m/=2){
/*6 7 2 1 ===> 2 7 6 1, 2 1 6 7 // 1 2 6 7, 1 2 6 7, 1 2 6 7*/
for(j=m;j<n;j++){
for(i=j-m;i>=0;i-=m){
if(L[i+m]>=L[i]) break;
else{
temp = L[i];
L[i] = L[i+m];
L[i+m] = temp;
}
}
}
}

printf("\nsetelah sorting: ");

for(i=0;i<n;i++){printf("%d ",L[i]);}
printf("\n");
}
 Cara pengurutan algoritma

Pertama menentukan jarak mula-mula dari data yang akan dibandingkan, yaitu N/2.
Data pertama dibandingkan dengan data dengan jarak N/2. Apabila data pertama
lebih besar dari data ke N/2 tersebut maka kedua data tersebut ditukar. Kemudian
data kedua dibandingkan dengan jarak yang sama yaitu N/2. Demikian seterusnya
sampai seluruh data dibandingkan sehingga semua data ke-j selalu lebih kecil
daripada data ke-(j + N/2).

Pada proses berikutnya, digunakan jarak (N/2) / 2 atau N/4. Data pertama
dibandingkan dengan data dengan jarak N/4. Apabila data pertama lebih besar dari
data ke N/4 tersebut maka kedua data tersebut ditukar. Kemudian data kedua
dibandingkan dengan jarak yang sama yaitu N/4. Demikianlah seterusnya hingga
seluruh data dibandingkan sehingga semua data ke-j lebih kecil dari data ke-(j + N/4).

Pada proses berikutnya, digunakan jarak (N/4) / 2 atau N/8. Demikian seterusnya
sampai jarak yang digunakan adalah 1.

 Jarak = Z
 Selama (Jarak > 1) kerjakan baris 3 sampai dengan 9
 Jarak = Jarak / 2. Sudah = false
 Kerjakan baris 4 sampai dengan 8 selama Sudah = false
 Sudah = true
 j=0
 Selama (j < N – Jarak) kerjakan baris 8 dan 9
 Jika (Data[j] > Data[j + Jarak] maka tukar Data[j], Data[j + Jarak], Sudah =
true
 j=j+1
 analisis pengurutan algoritma

Pada program di atas menggunakan header file #include <iostream> yang berfungsi
untuk memanggil fungsi dari cin dan cout. Fungsi int main() di gunakan untuk
menampilkan fungsi dari void selectionSort. Program diatas menggunakan metode
sheel short yang cara kerjanya membandingkan elemen pertama dengan elemen lain
yang berada dalam jarak yang sama namun yang lingkupnya paling jauh, begitu
seterusnya sampai membandingkan elemen pada jarak yang berdekatan satu sama
lain. Proses yang dikerjakan antara lain tmp=array[i+d]; array[i+d]=array[i];
array[i]=tmp; flag=1; yang memenuhi syarat (array[i+d]>array[i]) dengan perulangan
(i=0;i<(length-d);i++). Data yang telah diurutkan disimpan dan dikeluarkan dengan
array[i] dengan perulangan (i=0;i<6;i++). Misalnya ingin menginputkan 6 data maka
akan ada 6 data , misalnya 5 7 10 12 60 100 maka sistematika kerjanya adalah 5 akan
dibandingkan dengan 7 , 10, 12 dari jarak terjauh-terdekat. Kemudian tentukan jika
ascending atau descending pernyataan bilangannya seperti apa contoh 6<4 dan lain
sebagainya
  Hasil run

2. Metode Merge Sort (Penggabungan)

Merge Sort adalah algoritma pengurutan menggunakan divide conquer yaitu dengan cara
memecah kemudian menyelesaikan setiap bagian- bagian pecahanya tadi kemudian
digabungkan Kembali.
 Contoh source code

#include <iostream>
using namespace std;

void merge(int arr[], int p, int q, int r) {

// Create L ? A[p..q] and M ? A[q+1..r]

int n1 = q - p + 1;
int n2 = r - q;

int L[n1], M[n2];

for (int i = 0; i < n1; i++)

L[i] = arr[p + i];
 for (int j = 0; j < n2; j++)
M[j] = arr[q + 1 + j];

int i, j, k;
i = 0;
j = 0;
k = p;

while (i < n1 && j < n2) {

if (L[i] <= M[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = M[j];
j++;
}
k++;
}

while (i < n1) {

arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = M[j];
j++;
k++;
}
}

void mergeSort(int arr[], int l, int r) {

if (l < r) {
int m = l + (r - l) / 2;

mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);

merge(arr, l, m, r);
}
}

void printArray(int arr[], int size) {

for (int i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
 int main() {
int arr[] = {6, 5, 12, 10, 9, 1};
int size = sizeof(arr) / sizeof(arr[0]);

mergeSort(arr, 0, size - 1);

cout << "Hasil Merge Sort: \n";

printArray(arr, size);
return 0;
}
 Cara pengurutan algoritma

1) Hal pertama yang dilakukan adalah data dipecah menjadi 2 bagian, pertama
bagian ini merupakan setengah genap(jika datanya adalah genap) atau
setengah minus satu (jika datanya adalah ganjil) dari seluruh data yang ada.
2) Dipecah kembali untuk masing-masing blok tadi sampai terdiri dari satu data
tiap blok.
1) Kemudian digabungkan kembali dengan cara membandingkan pada bagian
blok yang sama, apakah data pertama itu lebih besar dari pada data ke-
tengah+1, jika iya maka data yang ke-tengah+1 dipindah sebagai data yang
pertama, kemudian data pertama sampai tengah digeser menjadi data kedua
sampai ketengah+1.
2) Demikian seterusnya sampai selesai menjadi suatu blok sedia kala. Sehingga
didalam sebuah metode merge sort itu merupakan metode yang menggunakan
fungsi rekursi untuk melakukan suatu penyelesaiannya.
Algoritma:
1) Divide: Memilih/memilah elemen dari data menjadi dua bagian.
2) Conquer: setiap bagian dengan memanggil prosedur merge sort secara rekursif
3) Kombinasi: Mengkombinasi/Menggabungkan setiap bagian dari rangkaian
data tersebut
3)

 Analisis pengurutan algoritma

Memecah data meenjadi beberapa blok dan setiap blok terdiri dari satu data.
Kemudian digabungkan Kembali dengan cara membandingkan pada bagian blok
yang sama. Jika data lebih besar dari data tengah maka pindahkan sebagai data
pertama, kemudian geser data pertama sampai tengah menjadi data kedua sampai
ketengah. Lakukan hal tersebut sampai data berurut
  Hasil run source code

3. Metode Quick Sort

 Source code

#include <iostream>
using namespace std;

void swap(int arr[] , int pos1, int pos2){

int temp;
temp = arr[pos1];
arr[pos1] = arr[pos2];
arr[pos2] = temp;
}

int partition(int arr[], int low, int high, int pivot){

int i = low;
int j = low;
while( i <= high){
if(arr[i] > pivot){
i++;
}
else{
swap(arr,i,j);
i++;
j++;
}
}
return j-1;
}
void quickSort(int arr[], int low, int high){
if(low < high){
int pivot = arr[high];
 int pos = partition(arr, low, high, pivot);

quickSort(arr, low, pos-1);

quickSort(arr, pos+1, high);
}
}

int main()
{
int n ;
cout << " Masukkan ukuran Array";
cin>>n;
int arr[n];
for( int i = 0 ; i < n; i++){
cin>> arr[i];
}
quickSort(arr, 0 , n-1);
cout<<"Hasil Quick sorted: ";
for( int i = 0 ; i < n; i++){
cout<< arr[i]<<"\t";
}

 Cara pengurutan algoritma

 Temukan item "pivot" dalam larik. Item ini menjadi dasar perbandingan
untuk satu babak.
 Mulai penunjuk (penunjuk kiri) di item pertama dalam larik.
 Mulai penunjuk (penunjuk kanan) di item terakhir dalam larik.
 Jika nilai di penunjuk kiri dalam larik lebih kecil dari nilai pivot, pindahkan
penunjuk kiri ke kanan (tambahkan 1). Lanjutkan hingga nilai di penunjuk
kiri lebih besar dari atau sama dengan nilai pivot.
 Jika nilai di penunjuk kanan dalam larik lebih besar dari nilai pivot,
pindahkan penunjuk kanan ke kiri (kurangi 1). Lanjutkan hingga nilai di
penunjuk kanan kurang dari atau sama dengan nilai pivot.
 Jika penunjuk kiri kurang dari atau sama dengan penunjuk kanan, maka tukar
nilai di lokasi ini dalam larik.
 Pindahkan penunjuk kiri ke kanan satu per satu dan penunjuk kanan ke kiri
satu per satu.
 Jika penunjuk kiri dan penunjuk kanan tidak bertemu, lanjutkan ke langkah
 Analisis pengurutan algoritma

Pada program di atas menggunakan header file #include <iostream> yang berfungsi
untuk memanggil fungsi dari cin dan cout. Proses yang terjadi antara lain void q_sort
(int numbers[],int left,int right) yaitu proses data di urutkan. Data akan dipanggil
q_sort(numbers,left,pivot-1); dengan syarat (left<pivot).Dan data di panggil
q_sort(numbers,pivot+1,right); dengan syarat (right>pivot). Pivot dalam program
tersebut adalah data titik tengah dari list besar. Dan void q_sort (int[],int,int);. Int
main() menampilkan data dengan cout<<setw(3)<<NumList[d]; yang dilakukan
dengan perulangan berketentuan d=0; d<10; d++ hasil sortingnya ditampilkan dengan
perulangan cout<<setw(3)<<NumList[iii]<<endl; dimana data hasil sorting diwakili
NumList[iii] dengan ketentuan iii=0; iii<10; iii++.Cara kerja quicksort adalah jika
struktur data terdiri dari 1/0 maka kembalikan struktur data apa adanya, jangan
diubah. Kemudian ambil sebuah elemen yang akan digunakan sebagai pivot. Bagi
struktur data menjadi 2 bagian, satu dengan elemen yang lebih besar daripada pivot,
dan lainnya dengan elemen yang lebih kecil dengan pivot.

 Hasil run