Algoritma Quick Sort Java
algoritma tentang quick sort dengan delphi 7 ?jelaskan?
1. algoritma tentang quick sort dengan delphi 7 ?jelaskan?
Untuk menyeragamkan penulisan tiap-tiap algoritma, dibuat sebuah common class, yaitu TQuickSort
2. Perhatikan gambar pseudocode di bawah ini! Berdasarkan pseudocode di atas menggunakan algoritma pengurutan a. Bubble Sort b. Insertion Sort c. Selection Sort d. Quick Sort e. Merger Sort
Jawaban:
a. Bubble Sort
Penjelasan:
bisa didefenisikan algoritma Bubble Sort adalah pengurutan dengan cara pertukaran data dengan data disebelahnya secara terus menerus sampai dalam satu iterasi tertentu tidak ada lagi perubahan. seperti yang ada pada gambar tersebut untuk melakukan perintah swap(pertukaran)
3. Berikut merupakan algoritma sorting kecuali ..... sort. a. shell c. quickb. merge d. concrete
Jawaban:
concrete(d)
sori klu salah
4. 1.Buatlah pengurutan dari data 29 ,27, 10 ,8 ,76,21 dengan metode sorting Selection Sort, Bubble Sort, Merge Sort, Quick Sort dan Insertion Sort.
METODE SORTING
Seringkali perancang program perlu mengurutkan sekumpulan data yang dimiliki untuk memudahkan pemrosesan selanjutnya terhadap data tersebut. Pengurutan adalah sebuah algoritma dasar yang sering diperlukan dalam pembuatan program. Berbagai algoritma pengurutan telah diciptakan dan dapat digunakan. Pemahaman tentang beberapa algoritma pengurutan dasar perlu diketahui, termasuk cara penggunaannya dalam program.
PENGERTIAN SORT
Sorting atau pengurutan data adalah proses yang sering harus dilakukan dalam pengolahan data. Sort dalam hal ini diartikan mengurutkan data yang berada dalam suatu tempat penyimpanan, dengan urutan tertentu baik urut menaik (ascending) dari nilai terkecil sampai dengan nilai terbesar, atau urut menurun (descending) dari nilai terbesar sampai dengan nilai terkecil. Sorting adalah proses pengurutan.
Terdapat dua macam pengurutan:
Pengurutan internal (internal sort), yaitu pengurutan terhadap sekumpulan data yang disimpan dalam media internal komputer yang dapat diakses setiap elemennya secara langsung. Dapat dikatakan sebagai pengurutan tabel
Pengurutan eksternal (external sort), yaitu pengurutan data yang disimpan dalam memori sekunder, biasanya data bervolume besar sehingga tidak mampu untuk dimuat semuanya dalam memori.
Dalam courseware ini, hanya akan dibahas algoritma pengurutan internal, dengan data berada dalam array satu dimensi.
Algoritma pengurutan internal yang utama antara lain:
1.Bubble Sort
2.Selection Sort
3.Insertion Sort
4.Shell Sort
5.Merge Sort
6.Radix Sort
7.Quick Sort
8.Heap Sort
Dalam courseware ini hanya akan dibahas tiga metode sort yang pertama yang dianggap mudah, yaitu: Bubble Sort , Selection Sort dan Insertion Sort
1.1 BUBBLE SORT
Bubble sort adalah proses pengurutan sederhana yang bekerja dengan cara berulang kali membandingkan dua elemen data pada suatu saat dan menukar elemen data yang urutannya salah. Ide dari Bubble sort adalah gelembung air yang akan “mengapung” untuk table yang terurut menaik (ascending). Elemen bernilai kecil akan “diapungkan” (ke indeks terkecil), artinya diangkat ke “atas” (indeks terkecil) melalui pertukaran. Karena
algoritma ini melakukan pengurutan dengan cara membandingkan elemen-elemen data satu sama lain, maka bubble sort termasuk ke dalam jenis algoritma comparison-based sorting.
Proses dalam Bubble sort dilakukan sebanyak N-1 langkah (pass) dengan N adalah ukuran array. Pada akhir setiap langkah ke – I , array L[0..N] akan terdiri atas dua bagian, yaitu bagian yang sudah terurut L[0..I] dan bagian yang belum terurut L[I+1..N-1]. Setelah langkah terakhir, diperoleh array L[0..N-1] yang terurut menaik.
0
terurut
Untuk mendapatkan urutan yang menaik, algoritmanya
5. Terdapat deret angka 99,34,11,50,23,89,65,2,6,37, 74, 44Urutkanlah deret angka Tersebut dengan menggunakan teknik sort yang sudah di jelaskan(Selection Sort,bubble sort, insertion Sort Quick Sort dan Merge Sort)
Contoh menggunakan program C/C++
Selection Sort#include <stdio.h>
void swap(int *xp, int *yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void selectionSort(int arr[], int n)
{
int i, j, min_idx;
// Digunakan untuk memindahkan angka satu per satu
for (i = 0; i < n-1; i++)
{
// Mencari nilai minimum dari deret angka
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
// Menukar nilai minimum dengan angka pertama
swap(&arr[min_idx], &arr[i]);
}
}
void printArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int arr[] = {99,34,11,50,23,89,65,2,6,37,74,44};
int n = sizeof(arr)/sizeof(arr[0]);
selectionSort(arr, n);
printf("Sorted array: \n");
printArray(arr, n);
return 0;
}
Bubble Sort#include <stdio.h>
void swap(int *xp, int *yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void bubbleSort(int arr[], int n)
{
int i, j;
for (i = 0; i < n-1; i++)
for (j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
swap(&arr[j], &arr[j+1]);
}
void printArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf("%d ", arr[i]);
printf("n");
}
int main()
{
int arr[] = {99,34,11,50,23,89,65,2,6,37,74,44};
int n = sizeof(arr)/sizeof(arr[0]);
bubbleSort(arr, n);
printf("Sorted array: \n");
printArray(arr, n);
return 0;
}
Insertion Sort#include <stdio.h>
#include <math.h>
void insertionSort(int arr[], int n)
{
int i, key, j;
for (i = 1; i < n; i++)
{
key = arr[i];
j = i-1;
/*Memindahkan elemen dari arr[0..i-1], yang lebih besar dari key, satu posisi diatas posisi saat ini */
while (j >= 0 && arr[j] > key)
{
arr[j+1] = arr[j];
j = j-1;
}
arr[j+1] = key;
}
}
void printArray(int arr[], int n)
{
int i;
for (i=0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int arr[] = {99,34,11,50,23,89,65,2,6,37,74,44};
int n = sizeof(arr)/sizeof(arr[0]);
insertionSort(arr, n);
printArray(arr, n);
return 0;
}
Quick Sort#include<stdio.h>
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
/* Fungsi ini mengambil elemen terakhir sebagai pivot, menempatkan pivot di posisi yang tepat dalam array yang telah di sort, menempatkan nilai yang lebih kecil dari pivot ke bagian kiri pivot dan nilai yang lebih besar dari pivot ke bagian kanan pivot */
int partition (int arr[], int low, int high)
{
int pivot = arr[high]; // pivot
int i = (low - 1); // Index dari element yang lebih kecil
for (int j = low; j <= high- 1; j++)
{
if (arr[j] <= pivot)
{
i++; // increment dari indeks elemen yang lebih kecil
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
/* arr[] --> Array yang akan di sort,
low --> Indeks awal,
high --> Indeks akhir */
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
/* pi adalah indeks partisi */
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
void printArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf("%d ", arr[i]);
printf("n");
}
int main()
{
int arr[] = {99,34,11,50,23,89,65,2,6,37,74,44};
int n = sizeof(arr)/sizeof(arr[0]);
quickSort(arr, 0, n-1);
printf("Sorted array: n");
printArray(arr, n);
return 0;
}
Merge Sort#include<stdlib.h>
#include<stdio.h>
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[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 A[], int size)
{ int i;
for (i=0; i < size; i++)
printf("%d ", A[i]);
printf("\n");
}
int main()
{
int arr[] = {99,34,11,50,23,89,65,2,6,37,74,44};
int arr_size = sizeof(arr)/sizeof(arr[0]);
printf("Given array is \n");
printArray(arr, arr_size);
mergeSort(arr, 0, arr_size - 1);
printf("\nSorted array is \n");
printArray(arr, arr_size);
return 0;
}
Kelas : SMP
Mapel : TIK
Kode : 7.11.8
Kategori : Perangkat Lunak Komputer
Kata kunci : Selection Sort, Bubble Sort, Insertion Sort, Quick Sort, Merge Sort
6. Bagaimana cara mempertinggi efektivitas dari metode quick sort
Jawaban:
Algortima QuickSort merupakan algoritma untuk mengurutkan data dengan pendekatan rekursif. Proses pengurutan dilakukan dengan memecah kumpulan data menjadi dua bagian berdasarkan nilai pivot yang dipilih. Pada prinsipnya nilai pivot yang dipilih ini akan ditempatkan pada posisinya disetiap akhir proses partisi.
Penjelasan:
maaf ya kalo salah
7. Hal yang mempengaruhi kecepatan algoritma sort adalah
Hal yang mempengaruhi kecepatannya adalah Operasi perbandingan dan jumlah Operasi pemindahan data.
Semoga membantu :)
8. buatlah contoh program sorting yang anda ketahui sebagai berikut : 1. Bubble Sort 2. Selection Sort 3. Insertion Sort 4. Merge Sort 5. Quick Sort
Jawaban:1. Bubble Sort :
int main()
{ int a,k,c,d,g;
k=4;
int b[4];
cout<<"BUBBLE SORT"<<endl;
cout<<"mengurutkan nilai dari besar ke kecil"<<endl<<endl;
for(a=0;a<k;a++)
{
cout<<"Masukkan nilai "<<a+1<<" : ";cin>>b[a];
}
for(a=0;a<k-1;a++)
{
for(d=a+1;d<k;d++)
{
c=a;
if(b[c]<b[d])
{
c=d;
}
g=b[c];
b[c]=b[a];
b[a]=g;
}
}
cout<<"\n setelah diurutkan akan menjadi : \n";
for(a=0;a<k;a++)
{
cout<<b[a]<<" \n";
}
}
2. Selection Sort :#include<iostream>
using namespace std;
int main()
{ int a,k,c,d,g;
k=4;
int b[4];
cout<<"SELECTION SORT"<<endl;
cout<<"mengurutkan nilai dari besar ke kecil"<<endl<<endl;
for(a=0;a<k;a++)
{
cout<<"Masukkan nilai "<<a+1<<" : ";cin>>b[a];
}
for(a=0;a<k-1;a++)
{
c=a;
for(d=a+1;d<k;d++)
{
if(b[c]<b[d])
{
c=d;
}
}
g=b[c];
b[c]=b[a];
b[a]=g;
}
cout<<"\n setelah diurutkan akan menjadi : \n";
for(a=0;a<k;a++)
{
cout<<b[a]<<" \n";
}
}
3. Insertion Sort#include <iostream>
using namespace std;
int data[10], data2[10];
int n;
void insertion_sort()
{
int temp, i, j;
for(i=1;i<=n;i++)
{
temp = data[i];
j = i -1;
while(data[j]>temp && j>=0)
{
data[j+1] = data[j];
j--;
}
data[j+1] = temp;
}
}
main()
{
cout << "Masukkan jumlah data: ";
cin >> n;
cout << endl;
for(int i=1; i<=n; i++)
{
cout << "Masukkan data ke-" << i << ": ";
cin >> data[i];
data2[i] = data[i];
}
insertion_sort();
cout << "\nData Setelah diurutkan" << endl;
cout << "------------------------" << endl;
for(int i=1; i<=n; i++)
{
cout << data[i] << " ";
}
cout << endl;
system("pause");
}
4. Merge Sort#include <iostream>
#include <conio.h>
using namespace std;
int a[50];
void merge(int,int,int);
void merge_sort(int low,int high)
{
int mid;
if(low<high)
{
mid=(low+high)/2;
merge_sort(low,mid);
merge_sort(mid+1,high);
merge(low,mid,high);
}
}
void merge(int low,int mid,int high)
{
int h,i,j,b[50],k;
h=low;
i=low;
j=mid+1;
while((h<=mid)&&(j<=high))
{
if(a[h]<=a[j])
{
b[i]=a[h]; h++;
}
else
{
b[i]=a[j]; j++;
} i++;
}
if(h>mid)
{
for(k=j;k<=high;k++)
{
b[i]=a[k]; i++;
}
}
else
{
for(k=h;k<=mid;k++)
{
b[i]=a[k]; i++;
}
}
for(k=low;k<=high;k++)
a[k]=b[k];
}
main()
{
int num,i;
cout<<"Hardifal "<<endl;
cout<<"---------------------------"<<endl;
cout<<" ALGORITMA MERGE SORT C++ "<<endl;
cout<<"---------------------------"<<endl;
cout<<endl;
cout<<"Masukkan Banyak Bilangan: ";cin>>num;
cout<<endl;
cout<<"Sekarang masukkan "<< num <<" Bilangan yang ingin Diurutkan :"<<endl;
for(i=1;i<=num;i++)
{
cout<<"Bilangan ke-"<<i<<" ";cin>>a[i] ;
}
merge_sort(1,num);
cout<<endl;
cout<<"Hasil akhir pengurutan :"<<endl;
cout<<endl;
for(i=1;i<=num;i++)
cout<<a[i]<<" ";
cout<<endl<<endl<<endl<<endl;
}
5. Quick Sort#include <iostream>
#include <conio.h>
using namespace std;
void quick_sort(int arr[], int left, int right)
{
int i = left, j = right;int tmp;
int pivot = arr[(left+right)/2];/* partition */
while (i<j){
while (arr[i] < pivot)
i++;
while (arr[j] > pivot)
j--;
if (i<=j){
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;j--;
};
}; /* recursion */
if (left < j)
quick_sort(arr, left, j);
if (i < right)
quick_sort(arr, i, right);
}
int main()
{
int i,n,data[50];
cout<<"Masukan banyak data: ";cin>>n;
for(i=0;i<n;i++)
{cout<<"Masukan data ["<<i<<"] : ";cin>>data[i];}
cout<<"\nData sebelum diurutkan: "<<endl;
for(i=0;i<n;i++)
{
cout<<data[i]<<" ";
}cout<<"\n";
quick_sort(data,0,n-1);//hasil pengurutan
cout<<"\nHasil pengurutan:\n";
{
int i;
for (i=0;i<n;i++)
cout<<data[i]<<" ";
cout<<"\n";
}getch();
}
Penjelasan:Semua koding program diatas dibuat menggunakan Bahasa Pemrograman C++.
Semoga membantu :)9. Pengurutan tingi badan seperti gambar disamping menggunakan(2.5 Poin) Selecton Sort Ascending Bubble Sort Descending Quick Sort
Jawaban:
selection sort
Penjelasan:
10. jabarkan tentang pola conquer pada logaritma quick sort
Algortima QuickSort merupakan algoritma untuk mengurutkan data dengan pendekatan rekursif. Proses pengurutan dilakukan dengan memecah kumpulan data menjadi dua bagian berdasarkan nilai pivot yang dipilih. Pada prinsipnya nilai pivot yang dipilih ini akan ditempatkan pada posisinya disetiap akhir proses partisi. Setelah proses partisi selesai dan menempatkan pivot pada posisinya yang tepat maka proses pengurutan dilanjutkan secara rekursif untuk mengurutkan data bagian kiri dari pivot dan bagian kanan dari pivot tersebut.
11. Algoritma Bubble Sort disebut juga sebagai Sinking Sort. Mengapa demikian? Jelaskan!
Jawaban dan Penjelasan:
Untuk menjelaskan mengapa algoritma bubble sort disebut juga sebagai sinking sort, kita gunakan prinsip kesetimbangan, yaitu “yang kecil naik dan yang besar turun”.
Kita bayangkan bahwa data direpresentasikan dalam bentuk susunan elemen data (seperti stack), di mana jenis pengurutan adalah menaik dari atas hingga paling bawah.
Dengan bubble sort, pada iterasi tertentu, jika suatu elemen data bernilai lebih dari elemen lain yang berada di bawahnya, maka terjadi pertukaran. Elemen yang lebih kecil naik 1 tingkat, dan elemen yang lebih besar turun 1 tingkat.
Anggap saja elemen terkecil berada pada posisi paling bawah dari susunan data belum terurut, dan elemen terbesar berada pada posisi paling atas dari susunan data tersebut. Maka, elemen terkecil akan naik secara bertahap hingga mencapai puncak susunan data terurut. Hal ini bisa dianalogikan dengan gelembung udara dalam air (bubble), yang akan naik hingga ke permukaan.
Sebaliknya, elemen terbesar akan turun secara bertahap hingga mencapai dasar (posisi terbawah) dari susunan data terurut. Hal ini dapat dianalogikan dengan sebuah batu (bukan batu apung) yang dimasukkan ke air. Batu tersebut akan turun (tenggelam, atau sinking) hingga dasar.
Jadi, dengan jenis pengurutan seperti disebutkan di atas, algoritma ini disebut bubble sort dengan memandang elemen terkecil; disebut sinking sort dengan memandang elemen terbesar.
Ilustrasi
Data belum terurut:
[tex]\large\text{$\begin{aligned}\boxed{\begin{array}{c}5\\3\\4\\2\\1\end{array}}\end{aligned}$}[/tex]
Tahapan bubble/sinking sort:
“Tenggelamnya“ 5[tex]\large\text{$\begin{aligned}&\boxed{\begin{array}{c}\boxed{5}\\3\\4\\2\\1\end{array}}\to \boxed{\begin{array}{c}3\\\boxed{5}\\4\\2\\1\end{array}}\to\boxed{\begin{array}{c}3\\4\\\boxed{5}\\2\\1\end{array}}\to\boxed{\begin{array}{c}3\\4\\2\\\boxed{5}\\1\end{array}}\to\boxed{\begin{array}{c}3\\4\\2\\1\\\boxed{5}\end{array}}\end{aligned}$}[/tex]“Tenggelamnya“ 4
[tex]\large\text{$\begin{aligned}\to\:&\boxed{\begin{array}{c}\boxed{3}\\4\\2\\1\\5\end{array}}\to\boxed{\begin{array}{c}3\\\boxed{4}\\2\\1\\5\end{array}}\to\boxed{\begin{array}{c}3\\2\\\boxed{4}\\1\\5\end{array}}\to\boxed{\begin{array}{c}3\\2\\1\\\boxed{4}\\5\end{array}}\end{aligned}$}[/tex]”Tenggelamnya“ 3
[tex]\large\text{$\begin{aligned}\to\:&\boxed{\begin{array}{c}\boxed{3}\\2\\1\\4\\5\end{array}}\to\boxed{\begin{array}{c}2\\\boxed{3}\\1\\4\\5\end{array}}\to\boxed{\begin{array}{c}2\\1\\\boxed{3}\\4\\5\end{array}}\end{aligned}$}[/tex]”Tenggelamnya“ 2
[tex]\large\text{$\begin{aligned}\to\:&\boxed{\begin{array}{c}\boxed{2}\\1\\3\\4\\5\end{array}}\to\boxed{\begin{array}{c}1\\\boxed{2}\\3\\4\\5\end{array}}\end{aligned}$}[/tex]Data terurut.
[tex]\large\text{$\begin{aligned}\to\:&\boxed{\begin{array}{c}\bf1\\\bf2\\\bf3\\\bf4\\\bf5\end{array}}\end{aligned}$}[/tex]
12. Buatlah sebuah pengurutan data dari terkecil hingga terbesar dari data berikut (30, 40, 10, 5, 60, 1) dengan menggunakan algoritma Merge-sort yang diimplementasikan dalam bahasa pemrograman Java? Kemudian analisa mengenai kinerja algoritma tersebut. Buatlah sebuah pengurutan data dari terkecil hingga terbesar dari data berikut (30, 40, 10, 5, 60, 1) dengan menggunakan algoritma Counting-sort yang diimplementasikan dalam bahasa pemrograman Java? Kemudian analisa mengenai kinerja algoritma tersebut.
dari terkecil:1,5,10,30,40,60
dari terbesar:60,40,30,10,5,1
Penjelasan:
itu saja
kalau salah maafkan
13. Pengertian algoritma sort
Secara garis besarnya, Sorting (Pengurutan) adalah suatu proses penyusunan kembali kumpulan objek menggunakan tata aturan tertentu. Sorting disebut juga sebagai suatu algoritma untuk meletakkan kumpulan elemen data ke dalam urutan tertentu berdasarkan satu atau beberapa kunci dalam tiap-tiap elemen. Pengurutan atau sorting merupakan proses dasar yang ada dalam sebuah algoritma dan struktur data. Tujuan utama dari proses pengurutan atau sorting adalah untuk mengurutkan data berdasarkan keinginan baik itu dari yang terendah maupun yang tertinggi, sehingga data yang dihasilkan akan lebih terstruktur, teratur dan sesuai dengan kebutuhan.
=•=•=•=•=•=•=•=•=•=•=•=•=•=•=•=•=•=•=•=•=•=MAAF KALAU JAWABANNYA SALAH ATAU KURANG TEPAT ..SEMOGA MEMBANTU DAN SEKIAN TERIMA KASIH ✨✨
14. Buatlah sebuah pengurutan data dari terkecil hingga terbesar dari data berikut (30, 40, 10, 5, 60, 1) dengan menggunakan algoritma merge-sort yang diimplementasikan dalam bahasa pemrograman java? kemudian analisa mengenai kinerja algoritma tersebut.
Jawaban:
// Merge sort
public class mergesort {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7,8,9,10};
mergesort(a);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
public static void mergesort(int[] a) {
int[] b = new int[a.length];
mergesort(a, b, 0, a.length-1);
}
public static void mergesort(int[] a, int[] b, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergesort(a, b, left, mid);
mergesort(a, b, mid+1, right);
merge(a, b, left, mid+1, right);
}
}
public static void merge(int[] a, int[] b, int left, int mid, int right) {
int i = left;
int j = mid;
int k = left;
while (i <= mid-1 && j <= right) {
if (a[i] < a[j]) {
b[k] = a[i];
i++;
} else {
b[k] = a[j];
j++;
}
k++;
}
while (i <= mid-1) {
b[k] = a[i];
i++;
k++;
}
while (j <= right) {
b[k] = a[j];
j++;
k++;
}
for (int l = left; l <= right; l++) {
a[l] = b[l];
}
}
}
Penjelasan:
Merge sort memiliki kompleksitas waktu O(n*logn)
15. insertion sort? dan algoritmanya
menyusun bilangan acak dari yang terkecil ke terbesar, semoga bermanfaat.Untuk penjelasan bisa agam lihat digambar
Algoritmannya
1.Apabila di elemen pertama dan telah disortir return 1
2.Ambil elemen berikutnya
3.Bandingkan
4.Ganti posisi dari kedua elemen yang dibandingkan
5.Ulangi apabila dilakukan pemindahan elemen pada pengulangan sekarang ini
Posting Komentar untuk "Algoritma Quick Sort Java"