LAPORAN RESMI ALGORITMA DAN

STRUKTUR DATA (SORT)

Yuliarta Rizki Nusantoko (2103181008)
2.TUJUAN
1. Memahami step by step algoritma pengurutan sort.

2. Mampu mengimplementasikan algoritma pengurutan sort dengan berbagai

macam parameter berupa tipe data primitif atau tipe Generic.

3. Mampu mengimplementasikan algoritma pengurutan sort secara ascending

dan descending
3.PERCOBAAN
1. Listing Program :

public class InsertionDemo {

public static void insertionSort(int[] A) {
for (int i = 1; i < A.length; i++) {
int key = A[i];
int j = i - 1;
while ((j >= 0) && (A[j] > key)) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = key;
}
}
public static void tampil(int data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}

public class Main {

public static void main(String[] args) {
int A[] = {10,6,8,3,1};
InsertionDemo.tampil(A);
InsertionDemo.insertionSort(A);
InsertionDemo.tampil(A);
}
}

Outputnya :

2. Listing Program :

public class InsertionDemo2 {

public static void insertionSort(double[] A) {
for (int i = 1; i < A.length; i++) {
double key = A[i];
int j = i - 1;
while ((j >= 0) && (A[j] > key)) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = key;
}
}

public static void tampil(double data[]) {

for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
 System.out.println();
}
}
public class Main {
public static void main(String[] args) {
int A[] = {10,6,8,3,1};
InsertionDemo.tampil(A);
InsertionDemo.insertionSort(A);
InsertionDemo.tampil(A);
}
}

Outputnya :

3. Listing Program :

public class InsertionDemo {

public static void insertionSort(double[] A) {
for (int i = 1; i < A.length; i++) {
double key = A[i];
int j = i - 1;
while ((j >= 0) && (A[j] > key)) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = key;
}
}
public static void tampil(double data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class Main {
public static void main(String[] args) {
int A[] = {10,6,8,3,1};
InsertionDemo.tampil(A);
InsertionDemo.insertionSort(A);
InsertionDemo.tampil(A);
}
}

Outputnya :
4.LATIHAN
1. Listing Program :

public class Latihan1 {

public static void insertionSort(Integer[] A) {
for(int i = 1; i<A.length; i++) {
Integer key = A[i];
int j = i-1;
while((j>=0) && (A[j]>key)) {
A[j+1]=A[j];
j--;
}
A[j+1]=key;
}
}
public static void tampil(Integer data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class Main1 {
public static void main(String[] args) {
Integer A[] = {10,6,8,3,1};
Latihan1.tampil(A);
Latihan1.insertionSort(A);
Latihan1.tampil(A);
}
}

Outputnya :

2. Listing Program :

public class Latihan2 {

public static void insertionSort(Double[] A) {
for(int i = 1; i<A.length; i++) {
Double key = A[i];
int j = i-1;
while((j>=0) && (A[j]>key)) {
A[j+1]=A[j];
j--;
}
A[j+1]=key;
}
}
public static void tampil(Double data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
 }
public class Main2 {
public static void main(String[] args) {
Double A[] = {10.0,6.0,8.5,3.1,1.2};
Latihan2.tampil(A);
Latihan2.insertionSort(A);
Latihan2.tampil(A);
}
}

Outputnya :

3. Listing Program :

public class Latihan3 {

public static void insertionSort(Integer[] A) {
for(int i = 1; i<A.length; i++) {
Integer key = A[i];
int j = i-1;
while((j>=0) && (A[j]>key)) {
A[j+1]=A[j];
j--;
}
A[j+1]=key;
}
}
public static <T>void tampil(T data[]) {
for (T objek : data) {
System.out.print(objek + " ");
}
System.out.println();
}
}
public class Main3 {
public static void main(String[] args) {
Integer A[] = {10,6,8,3,1};
Latihan3.tampil(A);
Latihan3.insertionSort(A);
Latihan3.tampil(A);
}
}

Outputnya :

4. Listing Program :

public class Latihan3<T> {

 public static void insertionSort(Integer[] A) {
for(int i = 1; i<A.length; i++) {
Integer key = A[i];
int j = i-1;
while((j>=0) && (A[j]>key)) {
A[j+1]=A[j];
j--;
}
A[j+1]=key;
}
}

public static void insertionSort(Double[] A) {

for(int i = 1; i<A.length; i++) {
Double key = A[i];
int j = i-1;
while((j>=0) && (A[j]>key)) {
A[j+1]=A[j];
j--;
}
A[j+1]=key;
}
}

public static <T>void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek + " ");
}
System.out.println();
}
}
public class Demo1 {
public static void main(String[] args) {
//Data Integer
Integer arr3[] = {1,5,6,2,8,9};
Latihan3.insertionSort(arr3);
Latihan3.tampil(arr3);
//data Double
Double arr4[] = {1.3,5.2,6.6,2.7,8.8,9.1};
Latihan3.insertionSort(arr4);
Latihan3.tampil(arr4);
}
}
public class InsertionDemo {
public static <T extends Number>void insertionSort(T[] A) {
for (int i = 1; i < A.length; i++) {
T key = A[i];
int j = i - 1;
while ((j >= 0) && (A[j] > key)) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = key;
}
}
public static <T extends Number>void tampil(T data[]) {
for (T objek : data) {
System.out.print(objek + " ");
}
System.out.println();
}
 }

Outputnya :

5. Listing Program :

public class Demo2 {

public static void main(String[] args) {
Float arr5[] = {1.3f,5.2f,6.6f,2.7f,8.8f,9.1f};
Latihan5.insertionSort(arr5);
Latihan5.tampil(arr5);
Byte arr6[] = {6,7,11,1,3,2};
Latihan5.insertionSort(arr6);
Latihan5.tampil(arr6);
}
}
public class Latihan5 {
public static <T extends Number> void insertionSort(T[] A) {
for(int i = 1; i<A.length; i++) {
T key = A[i];
int j = i-1;
while((j>=0) && (A[j].doubleValue()>key.doubleValue())) {
A[j+1]=A[j];
j--;
}
A[j+1]=key;
}
}
public static <T>void tampil(T data[]) {
for (T objek : data) {
System.out.print(objek + " ");
}
System.out.println();
}
}

Outputnya :

6. Listing Program :

public class Latihan7 {

public static <T extends Comparable> void insertionSort2(T[] arr) {
for(int i = 1; i<arr.length; i++) {
T key = arr[i];
int j = i-1;
while((j>=0) && (arr[j].compareTo(key)>0)) {
 arr[j+1]=arr[j];
j--;
}
arr[j+1]=key;
}
}
public static <T>void tampil(T data[]) {
for (T objek : data) {
System.out.print(objek + " ");
}
System.out.println();
}
}
public class Demo3 {
public static void main(String[] args) {
//data String
String arr7[]=
{"jeruk","anggur","belimbing","jambu","kelengkeng"};
Latihan7.insertionSort2(arr7);
Latihan7.tampil(arr7);
}
}

Outputnya :

7. Listing Program :

public class Latihan10 {

public static void main(String[] args) {
Mahasiswa arr8[] = {new Mahasiswa("02", "Budi"), new Mahasiswa("01", "Andi"), new
Mahasiswa("04", "Udin"), new Mahasiswa("03", "Candra")};
Latihan7.insertionSort2(arr8);
Latihan7.tampil(arr8);
}
}
public class Latihan7 {
public static <T extends Comparable> void insertionSort2(T[] arr) {
for(int i = 1; i<arr.length; i++) {
T key = arr[i];
int j = i-1;
while((j>=0) && (arr[j].compareTo(key)>0)) {
arr[j+1]=arr[j];
j--;
}
arr[j+1]=key;
}
}
public static <T>void tampil(T data[]) {
for (T objek : data) {
System.out.print(objek + " ");
}
System.out.println();
}
}
 public class Mahasiswa implements Comparable <Mahasiswa> {
private String nrp ;
private String nama ;
Mahasiswa(String nrp, String nama){
this.nrp=nrp;
this.nama=nama;
}
@Override
public int compareTo(Mahasiswa o){
Mahasiswa mhs = (Mahasiswa)o;
return nrp.compareTo(mhs.nrp);
}
@Override
public String toString() {
return " Nrp : "+nrp+" Nama : "+nama+"\n";
}
}

Outputnya :

5.KESIMPULAN
Insertion Sort adalah algoritma sorting yang sederhana dan mudah diterapkan
LAPORAN RESMI ALGORITMA DAN
STRUKTUR DATA (SELECTION SORT)
Yuliarta Rizki Nusantoko (2103181008)
2.TUJUAN
1. Memahami step by step algoritma pengurutan selection sort.

2. Mampu mengimplementasikan algoritma pengurutan selection sort dengan berbagai

macam parameter berupa tipe data primitif atau tipe Generic.

3. Mampu mengimplementasikan algoritma pengurutan selection sort secara ascending

dan descending
3.PERCOBAAN
1. Source Code :

public class SelectionDemo {

public static void selectionSort(int[] arr) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = arr.length;
int temp;
for (pass = 0; pass < n - 1; pass++) {
smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (arr[j]< arr[smallIndex]) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan arr[pass]
temp = arr[pass];
arr[pass] = arr[smallIndex];
arr[smallIndex] = temp;
}
}
public static void tampil(int data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainSelection {
public static void main(String[] args) {
int A[] = {10,6,8,3,1};
SelectionDemo.tampil(A);
SelectionDemo.selectionSort(A);
SelectionDemo.tampil(A);
}
}

Outputnya :

2. Source Code :

public class SelectionDemo {

public static void selectionSort(int[] arr) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = arr.length;
int temp;
for (pass = 0; pass < n - 1; pass++) {
smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (arr[j]> arr[smallIndex]) {
smallIndex = j;
 }
}
// tukar nilai terkecil dengan arr[pass]
temp = arr[pass];
arr[pass] = arr[smallIndex];
arr[smallIndex] = temp;
}
}
public static void tampil(int data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainSelection {
public static void main(String[] args) {
int A[] = {1,3,8,6,10};
SelectionDemo.tampil(A);
SelectionDemo.selectionSort(A);
SelectionDemo.tampil(A);
}
}

Outputnya :

3. Source Code :

public class SelectionSort {

public static void selectionSort(double[] arr) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = arr.length;
double temp;
for (pass = 0; pass < n - 1; pass++) {
smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (arr[j]< arr[smallIndex]) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan arr[pass]
temp = arr[pass];
arr[pass] = arr[smallIndex];
arr[smallIndex] = temp;
}
}
public static void tampil(double data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
 }
public class MainSelection2 {
public static void main(String[] args) {
double A[] = {10.3,6.2,8.4,3.6,1.1};
SelectionSort.tampil(A);
SelectionSort.selectionSort(A);
SelectionSort.tampil(A);
}
}

Outputnya :

4.LATIHAN
1. Source Code :

public class Latihan1 {

public static void selectionSort(Integer[] A) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = A.length;
int temp;

for (pass = 0; pass < n - 1; pass++) {

smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (A[j]< A[smallIndex]) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan A[pass]
temp = A[pass];
A[pass] = A[smallIndex];
A[smallIndex] = temp;
}
}
public static void tampil(Integer data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainSelection1 {
public static void main(String[] args) {
Integer A[] = {10,6,8,3,1};
Latihan1.tampil(A);
Latihan1.selectionSort(A);
Latihan1.tampil(A);
}
}

Outputnya :
2. Source Code :

public class Latihan2 {

public static void selectionSort(Double[] A) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = A.length;
double temp;

for (pass = 0; pass < n - 1; pass++) {

smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (A[j]< A[smallIndex]) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan A[pass]
temp = A[pass];
A[pass] = A[smallIndex];
A[smallIndex] = temp;
}
}
public static void tampil(Double data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainSelection2 {
public static void main(String[] args) {
Double A[] = {10.3,6.2,8.4,3.6,1.1};
Latihan2.tampil(A);
Latihan2.selectionSort(A);
Latihan2.tampil(A);
}
}

Outputnya :

3. Source Code :
 public class Latihan3 {
public static <T> void selectionSort(Integer[] A) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = A.length;
int temp;

for (pass = 0; pass < n - 1; pass++) {

smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (A[j]< A[smallIndex]) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan A[pass]
temp = A[pass];
A[pass] = A[smallIndex];
A[smallIndex] = temp;
}
}

public static <T> void selectionSort(Double[] A) {

// index of smallest element in the sublist
int smallIndex;
int pass, j, n = A.length;
double temp;

for (pass = 0; pass < n - 1; pass++) {

smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (A[j]< A[smallIndex]) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan A[pass]
temp = A[pass];
A[pass] = A[smallIndex];
A[smallIndex] = temp;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainSelection3 {
public static void main(String[] args) {
//Data Integer
Integer arr3[] = {1,5,6,2,8,9};
Latihan3.selectionSort(arr3);
Latihan3.tampil(arr3);

//data Double
Double arr4[] = {1.3,5.2,6.6,2.7,8.8,9.1};
Latihan3.selectionSort(arr4);
Latihan3.tampil(arr4);
}
}
 Outputnya :

4. Source Code :

public class Latihan5 {

public static<T extends Number> void selectionSort(T[] A) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = A.length;
T temp;

for (pass = 0; pass < n - 1; pass++) {

smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (A[j].doubleValue()< A[smallIndex].doubleValue()) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan A[pass]
temp = A[pass];
A[pass] = A[smallIndex];
A[smallIndex] = temp;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainSelection5 {
public static void main(String[] args) {
Float arr5[] = {1.3f,5.2f,6.6f,2.7f,8.8f,9.1f};
Latihan5.selectionSort(arr5);
Latihan5.tampil(arr5);

Byte arr6[] ={6,7,11,1,3,2};

Latihan5.selectionSort(arr6);
Latihan5.tampil(arr6);
}
}

Outputnya :
5. Source Code :

public class Latihan7 {

public static <T extends Comparable> void selectionSort2(T[] arr) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = arr.length;
T temp;

for (pass = 0; pass < n - 1; pass++) {

smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (arr[j].compareTo(arr[smallIndex])>0) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan A[pass]
temp = arr[pass];
arr[pass] = arr[smallIndex];
arr[smallIndex] = temp;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainSelection7 {
public static void main(String[] args) {
//data String
String arr7[]={"jeruk","anggur","belimbing","jambu","kelengkeng"};
Latihan7.selectionSort2(arr7);
Latihan7.tampil(arr7);
}
}

Outputnya :
6. Source Code :

public class Mahasiswa implements Comparable <Mahasiswa> {

private String nrp ;
private String nama ;
Mahasiswa(String nrp, String nama){
this.nrp=nrp;
this.nama=nama;
}
@Override
public int compareTo(Mahasiswa o){
Mahasiswa mhs = (Mahasiswa)o;
return nrp.compareTo(mhs.nrp);
}
@Override
public String toString() {
return " Nrp : "+nrp+" Nama : "+nama+"\n";
}
}
public class Latihan9 {
public static <T extends Comparable> void selectionSort2(T[] arr) {
// index of smallest element in the sublist
int smallIndex;
int pass, j, n = arr.length;
T temp;

for (pass = 0; pass < n - 1; pass++) {

smallIndex = pass;
for (j = pass + 1; j < n; j++) {
if (arr[j].compareTo(arr[smallIndex])>0) {
smallIndex = j;
}
}
// tukar nilai terkecil dengan A[pass]
temp = arr[pass];
arr[pass] = arr[smallIndex];
arr[smallIndex] = temp;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainSelection9 {
public static void main(String[] args) {
 Mahasiswa arr8[] = {new Mahasiswa("02", "Budi"), new
Mahasiswa("01", "Andi"), new Mahasiswa("04", "Udin"), new
Mahasiswa("03", "Candra")};
Latihan9.selectionSort2(arr8);
Latihan9.tampil(arr8);
}
}

Outputnya :

5.KESIMPULAN
Algoritma selection sort adalah menemukan elemen terkecil dalam array kita dan menukarnya (swap) dengan
elemen yang ada di posisi pertama, kemudian algoritma ini akan mengulangi hal yang sama lagi yaitu mencari
elemen terkecil yang ada di dalam array dan kemudian menukarnya (swap) dengan elemen yang ada di posisi
kedua (mengingat elemen di posisi pertama sudah berhasil kita sorting). Proses ini akan terus berlanjut sampai
semua elemen yang ada di dalam array telah berhasil kita sorting.
LAPORAN RESMI ALGORITMA DAN
STRUKTUR DATA (BUBBLE SORT)
Yuliarta Rizki Nusantoko (2103181008)
2.TUJUAN
1. Memahami step by step algoritma pengurutan bubble sort.

2. Mampu mengimplementasikan algoritma pengurutan bubble sort dengan berbagai

macam parameter berupa tipe data primitif atau tipe Generic.

3. Mampu mengimplementasikan algoritma pengurutan bubble sort secara ascending

dan descending
3. PERCOBAAN
1. Source Code

public class BubbleDemo {

public static void bubbleSort(int[] arr) {
int i=1, j, n = arr.length;
int temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (arr[j-1]>arr[j]){
temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}
public static void tampil(int data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainBubble {
public static void main(String[] args) {
int A[] = {10,6,8,3,1};
BubbleDemo.tampil(A);
BubbleDemo.bubbleSort(A);
BubbleDemo.tampil(A);
}
}

Outputnya :

2. Source Code

public class BubbleDemo {

public static void bubbleSort(int[] arr) {
int i=1, j, n = arr.length;
int temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (arr[j-1]<arr[j]){
temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
 j = j - 1;
}
i = i + 1;
}
}
public static void tampil(int data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainBubble {
public static void main(String[] args) {
int A[] = {1,3,8,6,10};
BubbleDemo.tampil(A);
BubbleDemo.bubbleSort(A);
BubbleDemo.tampil(A);
}
}

Outputnya :

3. Source Code

public class BubbleDemo {

public static void bubbleSort(double[] arr) {
int i=1, j, n = arr.length;
double temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (arr[j-1]>arr[j]){
temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}
public static void tampil(double data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainBubble {
public static void main(String[] args) {
double A[] = {10.3,6.2,8.4,3.6,1.1};
BubbleDemo.tampil(A);
 BubbleDemo.bubbleSort(A);
BubbleDemo.tampil(A);
}
}

Outputnya :

4.LATIHAN
1. Source Code

public class Latihan1 {

public static void bubbleSort(Integer[] A) {
int i=1, j, n = A.length;
int temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (A[j-1]>A[j]){
temp = A[j];
A[j] = A[j-1];
A[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}

public static <T> void tampil(Integer data[]) {

for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainBubble1 {
public static void main(String[] args) {
Integer A[] = {10,6,8,3,1};
Latihan1.tampil(A);
Latihan1.bubbleSort(A);
Latihan1.tampil(A);
}
}

Outputnya :
2. Source Code

public class Latihan2 {

public static void bubbleSort(Double[] A) {
int i=1, j, n = A.length;
double temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (A[j-1]>A[j]){
temp = A[j];
A[j] = A[j-1];
A[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}

public static <T> void tampil(Double data[]) {

for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
}
}
public class MainBubble2 {
public static void main(String[] args) {
Double A[] = {10.3,6.2,8.4,3.6,1.1};
Latihan2.tampil(A);
Latihan2.bubbleSort(A);
Latihan2.tampil(A);
}
}

Outputnya :

3. Source Code

public class Latihan3 {

public static<T> void bubbleSort(Integer[] A) {
int i=1, j, n = A.length;
int temp;
 while (i<n){
j = n-1 ;
while(j>=i){
if (A[j-1]<A[j]){
temp = A[j];
A[j] = A[j-1];
A[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}

public static<T> void bubbleSort(Double[] A) {

int i=1, j, n = A.length;
double temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (A[j-1]>A[j]){
temp = A[j];
A[j] = A[j-1];
A[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainBubble3 {
public static void main(String[] args) {
//Data Integer
Integer arr3[] = {1,5,6,2,8,9};
Latihan3.bubbleSort(arr3);
Latihan3.tampil(arr3);

//Data Integer
Double arr4[] = {1.3,5.2,6.6,2.7,8.8,9.1};
Latihan3.bubbleSort(arr4);
Latihan3.tampil(arr4);
}
}

Outputnya :
4. Source Code

public class Latihan5 {

public static<T extends Number> void bubbleSort(T[] A) {
int i=1, j, n = A.length;
T temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (A[j-1].doubleValue()<A[j].doubleValue()){
temp = A[j];
A[j] = A[j-1];
A[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainBubble5 {
public static void main(String[] args) {
Float arr5[] = {1.3f,5.2f,6.6f,2.7f,8.8f,9.1f};
Latihan5.bubbleSort(arr5);
Latihan5.tampil(arr5);

Byte arr6[] = {6,7,11,1,3,2};

Latihan5.bubbleSort(arr6);
Latihan5.tampil(arr6);
}
}

Outputnya :

5. Source Code

public class Latihan7 {

public static<T extends Comparable> void bubbleSort2(T[] arr) {
int i=1, j, n = arr.length;
T temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (arr[j-1].compareTo(arr[j])>0){
temp = arr[j];
 arr[j] = arr[j-1];
arr[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainBubble7 {
public static void main(String[] args) {
//data String
String arr7[] = {"jeruk","anggur","belimbing","jambu","kelengkeng"};
Latihan7.bubbleSort2(arr7);
Latihan7.tampil(arr7);
}
}

Outputnya :

6. Source Code

public class Mahasiswa implements Comparable <Mahasiswa> {

private String nrp ;
private String nama ;
Mahasiswa(String nrp, String nama){
this.nrp=nrp;
this.nama=nama;
}
@Override
public int compareTo(Mahasiswa o){
Mahasiswa mhs = (Mahasiswa)o;
return nrp.compareTo(mhs.nrp);
}
@Override
public String toString() {
return " Nrp : "+nrp+" Nama : "+nama+"\n";
}
}
public class Latihan9 {
public static<T extends Comparable> void bubbleSort2(T[] arr) {
int i=1, j, n = arr.length;
T temp;
while (i<n){
j = n-1 ;
 while(j>=i){
if (arr[j-1].compareTo(arr[j])>0){
temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainBubble9 {
public static void main(String[] args) {
Mahasiswa arr8[] = {new Mahasiswa("02", "Budi"), new
Mahasiswa("01", "Andi"), new Mahasiswa("04", "Udin"), new
Mahasiswa("03", "Candra")};
Latihan9.bubbleSort2(arr8);
Latihan9.tampil(arr8);
}
}

Outputnya :

5.KESIMPULAN
Metode Bubble Sort adalah metode yang mengurutkan data dengan membandingkan satu per satu elemen
dan dilakukan penukaran jika kondisinya memenuhi.
LAPORAN RESMI ALGORITMA DAN
STRUKTUR DATA (SHELL SORT)
Yuliarta Rizki Nusantoko (2103181008)
2.TUJUAN
1. Memahami step by step algoritma pengurutan shell sort.

2. Mampu mengimplementasikan algoritma pengurutan shell sort dengan berbagai

macam parameter berupa tipe data primitif atau tipe Generic.

3. Mampu mengimplementasikan algoritma pengurutan shell sort secara ascending dan

descending.
3.PERCOBAAN
1. Source Code :

public class ShellDemo {

public static void shellSort(int[] arr) {
int n = arr.length;
int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
int temp ;
C = 0;
M = 0;
jarak = n;
while (jarak >= 1) {
jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
i = j + jarak;
C++;
if (arr[j]> arr[i]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
Sudah = true;
}
}
}
}
}
public static void tampil(int data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainShell {
public static void main(String[] args) {
int A[] = {10,6,8,3,1};
ShellDemo.tampil(A);
ShellDemo.shellSort(A);
ShellDemo.tampil(A);
}
}

Outputnya :

2. Source Code :

public class ShellDemo {

public static void shellSort(int[] arr) {
int n = arr.length;
 int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
int temp ;
C = 0;
M = 0;
jarak = n;
while (jarak >= 1) {
jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
i = j + jarak;
C++;
if (arr[j]< arr[i]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
Sudah = true;
}
}
}
}
}
public static void tampil(int data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainShell {
public static void main(String[] args) {
int A[] = {1,3,8,6,10};
ShellDemo.tampil(A);
ShellDemo.shellSort(A);
ShellDemo.tampil(A);
}
}

Outputnya :

3. Source Code :

public class ShellDemo {

public static void shellSort(double[] arr) {
int n = arr.length;
int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
double temp ;
C = 0;
M = 0;
 jarak = n;
while (jarak >= 1) {
jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
i = j + jarak;
C++;
if (arr[j]> arr[i]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
Sudah = true;
}
}
}
}
}
public static void tampil(double data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainShell2 {
public static void main(String[] args) {
double A[] = {10.3,6.2,8.4,3.6,1.1};
ShellDemo.tampil(A);
ShellDemo.shellSort(A);
ShellDemo.tampil(A);
}
}

Outputnya :

4.LATIHAN
1. Source Code :

public class Latihan1 {

public static void shellSort(Integer[] arr) {
int n = arr.length;
int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
Integer temp ;
C = 0;
M = 0;
jarak = n;
while (jarak >= 1) {
 jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
i = j + jarak;
C++;
if (arr[j]> arr[i]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
Sudah = true;
}
}
}
}
}
public static void tampil(Integer data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainShell1 {
public static void main(String[] args) {
Integer A[] = {10,6,8,3,1};
Latihan1.tampil(A);
Latihan1.shellSort(A);
Latihan1.tampil(A);
}
}

Outputnya :

2. Source Code :

public class Latihan2 {

public static void shellSort(Double[] arr) {
int n = arr.length;
int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
Double temp ;
C = 0;
M = 0;
jarak = n;
while (jarak >= 1) {
jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
 i = j + jarak;
C++;
if (arr[j]> arr[i]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
Sudah = true;
}
}
}
}
}
public static void tampil(Double data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainShell2 {
public static void main(String[] args) {
Double A[] = {10.3,6.2,8.4,3.6,1.1};
Latihan2.tampil(A);
Latihan2.shellSort(A);
Latihan2.tampil(A);
}
}

Outputnya :

3. Source Code :

public class Latihan3 {

public static<T> void shellSort(Double[] arr) {
int n = arr.length;
int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
Double temp ;
C = 0;
M = 0;
jarak = n;
while (jarak >= 1) {
jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
i = j + jarak;
C++;
if (arr[j]> arr[i]) {
temp = arr[j];
 arr[j] = arr[i];
arr[i] = temp;
Sudah = true;
}
}
}
}
}

public static void shellSort(Integer[] arr) {

int n = arr.length;
int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
Integer temp ;
C = 0;
M = 0;
jarak = n;
while (jarak >= 1) {
jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
i = j + jarak;
C++;
if (arr[j]> arr[i]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
Sudah = true;
}
}
}
}
}

public static<T> void tampil(T data[]){

for(T objek : data)
System.out.print(objek);
}
}
public class MainShell3 {
public static void main(String[] args) {
//Data Integer
Integer arr3[] = {1,5,6,2,8,9};
Latihan3.shellSort(arr3);
Latihan3.tampil(arr3);
//data Double
Double arr4[] = {1.3,5.2,6.6,2.7,8.8,9.1};
Latihan3.shellSort(arr4);
Latihan3.tampil(arr4);
}
}

Outputnya :
4. Source Code :

public class Latihan5 {

public static<T extends Number> void shellSort(T[] A) {
int n = A.length;
int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
T temp ;
C = 0;
M = 0;
jarak = n;
while (jarak >= 1) {
jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
i = j + jarak;
C++;
if (A[j].doubleValue() < A[i].doubleValue()) {
temp = A[j];
A[j] = A[i];
A[i] = temp;
Sudah = true;
}
}
}
}
}

public static<T> void tampil(T data[]){

for(T objek : data)
System.out.print(objek);
}
}
public class MainShell5 {
public static void main(String[] args) {
Float arr5[] = {1.3f,5.2f,6.6f,2.7f,8.8f,9.1f};
Latihan5.shellSort(arr5);
Latihan5.tampil(arr5);

Byte arr6[] = {6,7,11,1,3,2};

Latihan5.shellSort(arr6);
Latihan5.tampil(arr6);
}
}

Outputnya :
5. Source Code :

public class Latihan7 {

public static<T extends Comparable> void shellSort2(T[] arr) {
int n = arr.length;
int C,M ;
int jarak, i, j, kondisi;
boolean Sudah = true;
T temp ;
C = 0;
M = 0;
jarak = n;
while (jarak >= 1) {
jarak = jarak / 2;
Sudah = true;
while (Sudah) {
Sudah = false;
for (j = 0; j < n - jarak; j++) {
i = j + jarak;
C++;
if (arr[j].compareTo(arr[i])<0) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
Sudah = true;
}
}
}
}
}

public static<T> void tampil(T data[]){

for(T objek : data)
System.out.print(objek);
}
}
public class MainShell7 {
public static void main(String[] args) {
//data String
String arr7[]=
{"jeruk","anggur","belimbing","jambu","kelengkeng"};
Latihan7.shellSort2(arr7);
Latihan7.tampil(arr7);
}
}

Outputnya :
6. Source Code :

public class Mahasiswa implements Comparable <Mahasiswa> {

private String nrp ;
private String nama ;
Mahasiswa(String nrp, String nama){
this.nrp=nrp;
this.nama=nama;
}
@Override
public int compareTo(Mahasiswa o){
Mahasiswa mhs = (Mahasiswa)o;
return nrp.compareTo(mhs.nrp);
}
@Override
public String toString() {
return " Nrp : "+nrp+" Nama : "+nama+"\n";
}
}
public class Latihan9 {
public static<T extends Comparable> void shellSort2(T[] arr) {
int i=1, j, n = arr.length;
T temp;
while (i<n){
j = n-1 ;
while(j>=i){
if (arr[j-1].compareTo(arr[j])>0){
temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
j = j - 1;
}
i = i + 1;
}
}

public static <T> void tampil(T data[]) {

for (T objek : data) {
System.out.print(objek);
}
System.out.println();
}
}
public class MainShell9 {
public static void main(String[] args) {
Mahasiswa arr8[] = {new Mahasiswa("02", "Budi"), new
Mahasiswa("01", "Andi"), new Mahasiswa("04", "Udin"), new
Mahasiswa("03", "Candra")};
Latihan9.shellSort2(arr8);
Latihan9.tampil(arr8);
 }
}

Outputnya :

5.KESIMPULAN
Metode Shell Sort bekerja dengan membandingkan suatu data dengan data lian yang memiliki jarak tertentu
dan dilakukan penukaran apabila kondisinya memenuhi.
LAPORAN RESMI ALGORITMA DAN
STRUKTUR DATA (QUICK SORT)
Yuliarta Rizki Nusantoko (2103181008)
2.TUJUAN
1.Memahami step by step algoritma pengurutan quick sort.

2. Mampu mengimplementasikan algoritma pengurutan quick sort dengan berbagai

macam parameter berupa tipe data primitif atau tipe Generic.

3. Mampu mengimplementasikan algoritma pengurutan quick sort secara ascending dan

descending.
3.PERCOBAAN
1. Source Code :

public class QuickDemo {

private static int partition(int[] A, int p, int r) {
int pivot, i, j;
pivot = A[p];
i = p - 1;
j = r + 1;
for (;;) {
do {
i++;
} while (A[i] < pivot);
do {
j--;
} while (A[j] > pivot);
if (i < j) {
int temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
}
}
public static void quickSort(int[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}
public static void tampil(int data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainQuick {
public static void main(String[] args) {
int A[] = {10,6,8,3,1};
QuickDemo.tampil(A);
QuickDemo.quickSort(A,0,A.length-1);
QuickDemo.tampil(A);
}
}

Outputnya:

2. Source Code :

public class QuickDemo {

 private static int partition(double[] A, int p, int r) {
double pivot;
int i, j;
pivot = A[p];
i = p - 1;
j = r + 1;
for (;;) {
do {
i++;
} while (A[i] < pivot);
do {
j--;
} while (A[j] > pivot);
if (i < j) {
double temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
}
}
public static void quickSort(double[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}
public static void tampil(double data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainQuick {
public static void main(String[] args) {
double A[] = {10.3,6.2,8.4,3.6,1.1};
QuickDemo.tampil(A);
QuickDemo.quickSort(A,0,A.length-1);
QuickDemo.tampil(A);
}
}

Outputnya:

4.LATIHAN
1. Source Code :

public class Latihan1 {

 private static int partition(Integer[] A, int p, int r) {
Integer pivot;
int i, j;
pivot = A[p];
i = p - 1;
j = r + 1;
for (;;) {
do {
i++;
} while (A[i] < pivot);
do {
j--;
} while (A[j] > pivot);
if (i < j) {
Integer temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
}
}
public static void quickSort(Integer[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}
public static void tampil(Integer data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainQuick1 {
public static void main(String[] args) {
Integer A[] = {10,6,8,3,1};
Latihan1.tampil(A);
Latihan1.quickSort(A,0,A.length-1);
Latihan1.tampil(A);
}
}

Outputnya:

2. Source Code :

public class Latihan2 {

private static int partition(Double[] A, int p, int r) {
Double pivot;
int i, j;
pivot = A[p];
 i = p - 1;
j = r + 1;
for (;;) {
do {
i++;
} while (A[i] < pivot);
do {
j--;
} while (A[j] > pivot);
if (i < j) {
Double temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
}
}
public static void quickSort(Double[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}
public static void tampil(Double data[]){
for(int i=0;i<data.length;i++)
System.out.print(data[i]+" ");
System.out.println();
}
}
public class MainQuick2 {
public static void main(String[] args) {
Double A[] = {10.3,6.2,8.4,3.6,1.1};
Latihan2.tampil(A);
Latihan2.quickSort(A,0,A.length-1);
Latihan2.tampil(A);
}
}

Outputnya:

3. Source Code :

public class Latihan3 {

private static int partition(Double[] A, int p, int r) {
Double pivot;
int i, j;
pivot = A[p];
i = p - 1;
j = r + 1;
for (;;) {
 do {
i++;
} while (A[i] < pivot);
do {
j--;
} while (A[j] > pivot);
if (i < j) {
Double temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
}
}
public static void quickSort(Double[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}

private static int partition(Integer[] A, int p, int r) {

Integer pivot;
int i, j;
pivot = A[p];
i = p - 1;
j = r + 1;
for (;;) {
do {
i++;
} while (A[i] < pivot);
do {
j--;
} while (A[j] > pivot);
if (i < j) {
Integer temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
}
}
public static void quickSort(Integer[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}

public static<T> void tampil(T data[]){

for(T objek : data)
System.out.print(objek);
System.out.println();
}
}
 public class MainQuick3 {
public static void main(String[] args) {
//Data Integer
Integer arr3[] = {1,5,6,2,8,9};
Latihan3.quickSort(arr3, 0,arr3.length-1);
Latihan3.tampil(arr3);
//data Double
Double arr4[] = {1.3,5.2,6.6,2.7,8.8,9.1};
Latihan3.quickSort(arr4,0,arr4.length-1);
Latihan3.tampil(arr4);
}
}

Outputnya:

4. Source Code :

public class Latihan5 {

private static<T extends Number> int partition(T[] A, int p, int r) {
T pivot;
int i, j;
pivot = A[p];
i = p - 1;
j = r + 1;
for (;;) {
do {
i++;
} while (A[i].doubleValue() < pivot.doubleValue());
do {
j--;
} while (A[j].doubleValue() > pivot.doubleValue());
if (i < j) {
T temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
}
}
public static<T extends Number> void quickSort(T[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}
public static<T> void tampil(T data[]){
for(T objek : data)
System.out.print(objek);
System.out.println();
}
 }
public class MainQuick5 {
public static void main(String[] args) {
Float arr5[] = {1.3f,5.2f,6.6f,2.7f,8.8f,9.1f};
Latihan5.quickSort(arr5, 0,arr5.length-1);
Latihan5.tampil(arr5);
Byte arr6[] = {6,7,11,1,3,2};
Latihan5.quickSort(arr6, 0,arr6.length-1);
Latihan5.tampil(arr6);
}
}

Outputnya:

5. Source Code :

public class Latihan7 {

private static<T extends Comparable> int partition(T[] A, int p, int r) {
T pivot;
int i, j;
pivot = A[p];
i = p - 1;
j = r + 1;
for (;;) {
do {
i++;
} while (A[i].compareTo(pivot) < 0);
do {
j--;
} while (A[j].compareTo(pivot) > 0);
if (i < j) {
T temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
}
}
public static<T extends Comparable> void quickSort(T[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}
public static<T> void tampil(T data[]){
for(T objek : data)
System.out.print(objek);
System.out.println();
}
}
 public class MainQuick7 {
public static void main(String[] args) {
//data String
String arr7[]=
{"jeruk","anggur","belimbing","jambu","kelengkeng"};
Latihan7.quickSort(arr7, 0,arr7.length-1);
Latihan7.tampil(arr7);
}
}

Outputnya:

6. Source Code :

public class Mahasiswa implements Comparable <Mahasiswa> {

private String nrp ;
private String nama ;
Mahasiswa(String nrp, String nama){
this.nrp=nrp;
this.nama=nama;
}
@Override
public int compareTo(Mahasiswa o){
Mahasiswa mhs = (Mahasiswa)o;
return nrp.compareTo(mhs.nrp);
}
@Override
public String toString() {
return " Nrp : "+nrp+" Nama : "+nama+"\n";
}
}
public class Latihan9 {
private static<T extends Comparable> int partition(T[] A, int p, int r) {
T pivot;
int i, j;
pivot = A[p];
i = p - 1;
j = r + 1;
for (;;) {
do {
i++;
} while (A[i].compareTo(pivot) < 0);
do {
j--;
} while (A[j].compareTo(pivot) > 0);
if (i < j) {
T temp = A[i];
A[i] = A[j];
A[j] = temp;
} else {
return j;
}
 }
}
public static<T extends Comparable> void quickSort(T[] A, int p, int r) {
int q;
if (p < r) {
q = partition(A,p,r);
quickSort(A,p, q);
quickSort(A,q + 1, r);
}
}
public static<T> void tampil(T data[]){
for(T objek : data)
System.out.print(objek);
System.out.println();
}
}
public class MainQuick9 {
public static void main(String[] args) {
Mahasiswa arr8[] = {new Mahasiswa("02", "Budi"), new
Mahasiswa("01", "Andi"), new Mahasiswa("04", "Udin"), new
Mahasiswa("03", "Candra")};
Latihan9.quickSort(arr8, 0,arr8.length-1);
Latihan9.tampil(arr8);
}
}

Outputnya:

5.KESIMPULAN
Metode Quick Sort merupakan metode partisi dengancara kerja menukarkan dua elemen dengan jarak yang
cukup besar.
LAPORAN RESMI ALGORITMA DAN
STRUKTUR DATA (MERGE SORT)
Yuliarta Rizki Nusantoko (2103181008)
2.TUJUAN
1. Memahami step by step algoritma pengurutan merge sort.

2. Mampu mengimplementasikan algoritma pengurutan merge sort dengan berbagai

macam parameter berupa tipe data primitif atau tipe Generic.

3. Mampu mengimplementasikan algoritma pengurutan merge sort secara ascending dan

descending.
3.PERCOBAAN
1. Source Code :

public class MergeDemo {

private int[] array;
private int[] tempMergArr;
private int length;
public MergeDemo(int[] array) {
this.array = array;
this.length = array.length;
this.tempMergArr = new int[length];
}

public void mergeSort(int lowerIndex, int higherIndex) {

if (lowerIndex < higherIndex) {
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Below step sorts the left side of the array
mergeSort(lowerIndex, middle);
// Below step sorts the right side of the array
mergeSort(middle + 1, higherIndex);
// Now merge both sides
mergeParts(lowerIndex, middle, higherIndex);
}
}

private void mergeParts(int lowerIndex, int middle, int higherIndex) {

for (int i = lowerIndex; i <= higherIndex; i++) {
tempMergArr[i] = array[i];
}
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) {
if (tempMergArr[i] <= tempMergArr[j]) {
array[k] = tempMergArr[i];
i++;
} else {
array[k] = tempMergArr[j];
j++;
}
k++;
}
while (i <= middle) {
array[k] = tempMergArr[i];
k++;
i++;
}
}

public void tampil() {

for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
public class MainMerge {
public static void main(String[] args) {
int[] inputArr = {45, 23, 11, 89, 77, 98, 4, 28, 65, 43};
MergeDemo mms = new MergeDemo(inputArr);
 mms.tampil();
mms.mergeSort(0,inputArr.length-1);
mms.tampil();
}
}

Outputnya :

2. Source Code :

public class MergeDemo {

private int[] array;
private int[] tempMergArr;
private int length;
public MergeDemo(int[] array) {
this.array = array;
this.length = array.length;
this.tempMergArr = new int[length];
}

public void mergeSort(int lowerIndex, int higherIndex) {

if (lowerIndex < higherIndex) {
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Below step sorts the left side of the array
mergeSort(lowerIndex, middle);
// Below step sorts the right side of the array
mergeSort(middle + 1, higherIndex);
// Now merge both sides
mergeParts(lowerIndex, middle, higherIndex);
}
}

private void mergeParts(int lowerIndex, int middle, int higherIndex) {

for (int i = lowerIndex; i <= higherIndex; i++) {
tempMergArr[i] = array[i];
}
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) {
if (tempMergArr[i] >= tempMergArr[j]) {
array[k] = tempMergArr[i];
i++;
} else {
array[k] = tempMergArr[j];
j++;
}
k++;
}
while (i <= middle) {
array[k] = tempMergArr[i];
k++;
i++;
 }
}

public void tampil() {

for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
public class MainMerge {
public static void main(String[] args) {
int[] inputArr = {45, 23, 11, 89, 77, 98, 4, 28, 65, 43};
MergeDemo mms = new MergeDemo(inputArr);
mms.tampil();
mms.mergeSort(0,inputArr.length-1);
mms.tampil();
}
}

Outputnya :

4.LATIHAN
1. Source Code :

public class Latihan1<T extends Number & Comparable> {

private T[] array;
private T[] tempMergArr;
private int length;
public Latihan1(T[] array) {
this.array = array;
this.length = array.length;
this.tempMergArr = (T[])new Number[length];
}

public<T extends Number> void mergeSort(int lowerIndex, int higherIndex) {

if (lowerIndex < higherIndex) {
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Below step sorts the left side of the array
mergeSort(lowerIndex, middle);
// Below step sorts the right side of the array
mergeSort(middle + 1, higherIndex);
// Now merge both sides
mergeParts(lowerIndex, middle, higherIndex);
}
}

private<T extends Number> void mergeParts(int lowerIndex, int middle, int higherIndex) {
for (int i = lowerIndex; i <= higherIndex; i++) {
tempMergArr[i] = array[i];
 }
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) {
if (tempMergArr[i].compareTo(tempMergArr[j]) >= 0) {
array[k] = tempMergArr[i];
i++;
} else {
array[k] = tempMergArr[j];
j++;
}
k++;
}
while (i <= middle) {
array[k] = tempMergArr[i];
k++;
i++;
}
}

public void tampil() {

for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
public class MainMerge1 {
public static void main(String[] args) {
Double[] inputArr = {45.4, 23.1, 11.4, 89.1, 77.9, 98.7,
4.2, 28.6, 65.8, 43.9};
Latihan1 mms = new Latihan1(inputArr);
mms.tampil();
mms.mergeSort(0,inputArr.length-1);
mms.tampil();
}
}

Outputnya :

2. Source Code :

public class Latihan2<T extends Comparable> {

private T[] array;
private T[] tempMergArr;
private int length;
public Latihan2(T[] array) {
this.array = array;
this.length = array.length;
 this.tempMergArr = (T[])new Comparable[length];
}

public<T extends Comparable> void mergeSort(int lowerIndex, int higherIndex) {

if (lowerIndex < higherIndex) {
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Below step sorts the left side of the array
mergeSort(lowerIndex, middle);
// Below step sorts the right side of the array
mergeSort(middle + 1, higherIndex);
// Now merge both sides
mergeParts(lowerIndex, middle, higherIndex);
}
}

private<T extends Comparable> void mergeParts(int lowerIndex, int middle, int higherIndex) {
for (int i = lowerIndex; i <= higherIndex; i++) {
tempMergArr[i] = array[i];
}
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) {
if (tempMergArr[i].compareTo(tempMergArr[j]) < 0) {
array[k] = tempMergArr[i];
i++;
} else {
array[k] = tempMergArr[j];
j++;
}
k++;
}
while (i <= middle) {
array[k] = tempMergArr[i];
k++;
i++;
}
}

public void tampil() {

for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
public class MainMerge2 {
public static void main(String[] args) {
String inputArr []=
{"jeruk","anggur","belimbing","jambu","kelengkeng"};
Latihan2 mms = new Latihan2(inputArr);
mms.tampil();
mms.mergeSort(0,inputArr.length-1);
mms.tampil();
}
}

Outputnya :
3. Source Code :

public class Latihan3<T extends Comparable> {

private T[] array;
private T[] tempMergArr;
private int length;
public Latihan3(T[] array) {
this.array = array;
this.length = array.length;
this.tempMergArr = (T[])new Comparable[length];
}

public<T extends Comparable> void mergeSort(int lowerIndex, int higherIndex) {

if (lowerIndex < higherIndex) {
int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Below step sorts the left side of the array
mergeSort(lowerIndex, middle);
// Below step sorts the right side of the array
mergeSort(middle + 1, higherIndex);
// Now merge both sides
mergeParts(lowerIndex, middle, higherIndex);
}
}

private<T extends Comparable> void mergeParts(int lowerIndex, int middle, int higherIndex) {
for (int i = lowerIndex; i <= higherIndex; i++) {
tempMergArr[i] = array[i];
}
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) {
if (tempMergArr[i].compareTo(tempMergArr[j]) < 0) {
array[k] = tempMergArr[i];
i++;
} else {
array[k] = tempMergArr[j];
j++;
}
k++;
}
while (i <= middle) {
array[k] = tempMergArr[i];
k++;
i++;
}
}

public void tampil() {

 for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
public class Mahasiswa implements Comparable <Mahasiswa> {
private String nrp ;
private String nama ;
Mahasiswa(String nrp, String nama){
this.nrp=nrp;
this.nama=nama;
}
@Override
public int compareTo(Mahasiswa o){
Mahasiswa mhs = (Mahasiswa)o;
return nrp.compareTo(mhs.nrp);
}
@Override
public String toString() {
return " Nrp : "+nrp+" Nama : "+nama+"\n";
}
}
public class MainMerge3 {
public static void main(String[] args) {
Mahasiswa inputArr[] = {new Mahasiswa("02", "Budi"), new
Mahasiswa("01", "Andi"), new Mahasiswa("04", "Udin"), new Mahasiswa("03",
"Candra")};
Latihan3 mms = new Latihan3(inputArr);
mms.tampil();
mms.mergeSort(0,inputArr.length-1);
}
}

Outputnya :

5.KESIMPULAN
Merge sort merupakan algoritma pengurutan dalam ilmu komputer yang dirancang untuk memnuhi
kebutuhan pengurutan atas suatu rangkaian data yang tidak memungkinkan utnuk ditampung dalam memori.