Docstoc

Tentang Algoritma

Document Sample
Tentang Algoritma Powered By Docstoc
					Bubble Shot
Merupakan algoritma penyortiran yang dimulai dan berakhir pada sebuah daftar dengan n elemen dan
memindahkan seluruhnya, menguji nilai setiap pasangan item yang berdekatan dan menukarkannya jika
mereka tidak berada dalam urutan yang tepat.
Metode sorting termudah
Diberi nama “Bubble” karena proses pengurutan secara berangsur-angsur bergerak/berpindah
keposisinya yang tepat, seperti gelembung yang keluar dari sebuah gelas bersoda..
Bubble Sort mengurutkan data dengan cara membandingkan elemen sekarang dengan elemen
berikutnya.
Pengurutan Ascending : Jika elemen sekarang lebih besar dari elemen berikutnya maka kedua elemen
tersebut ditukar.
Pengurutan Descending : Jika elemen sekarang lebih kecil dari elemen berikutnya, maka kedua elemen
tersebut ditukar.
Algoritma ini seolah-olah menggeser satu per satu elemen dari kanan ke kiri atau kiri ke kanan,
tergantung jenis pengurutannya, asc atau desc. Ketika satu proses telah selesai, maka bubble sort akan
mengulangi proses, demikian seterusnya sampai dengan iterasi sebanyak n-1.
Kapan berhentinya? Bubble sort berhenti jika seluruh array telah diperiksa dan tidak ada pertukaran lagi
yang bisa dilakukan, serta tercapai perurutan yang telah diinginkan.



64 25 12 22 11

11 25 12 22 64

11 12 25 22 64

11 12 22 25 64

11 12 22 25 64


/ * A [0] ke [1 n-] adalah array untuk mengurutkan * /
int iPos ; int IPO;
int iMin ; int iMin;

/* advance the position through the entire array */ / * Muka posisi melalui
seluruh array * /
/* (could do iPos < n-1 because single element is also min element) */ / *
(Bisa melakukan IPO <n-1 karena elemen tunggal juga unsur min) * /
for ( iPos = 0 ; iPos < n ; iPos ++ ) untuk (IPO = 0; n <IPO; IPO + +)
{ {
  /* find the min element in the unsorted a[iPos .. / * Menemukan elemen
menit di [unsorted IPO sebuah .. n-1] */ n-1] * /

  /* assume the min is the first element */ / * Menganggap menit adalah
elemen pertama * /
  iMin = iPos ; iMin = IPO;
  /* test against all other elements */ / * Uji terhadap semua elemen lain *
/
  for ( i = iPos + 1 ; i < n ; i ++ ) untuk (IPO i = + 1; i <n; i + +)
    { {
      /* if this element is less, then it is the new minimum */ / * Jika
unsur ini kurang, maka itu adalah * minimum baru /
      if ( a [ i ] < a [ iMin ] ) jika (a [i] <a [iMin])
        { {
          /* found new minimum; remember its index */ / * Menemukan minimum
baru; ingat * indeks /
          iMin = i ; iMin = i;
        } }
    } }

  /* iMin is the index of the minimum element. / IMin * adalah indeks dari
elemen minimum. Swap it with the current position */ Swap itu dengan posisi
sekarang * /
  if ( iMin != iPos ) if (iMin! = IPO)
  { {
    swap ( a , iPos , iMin ) ; swap (a, IPO, iMin);
  } }
} }




Bubble sort memiliki terburuk dan rata-rata kompleksitas kedua О (n 2), dimana n adalah jumlah
item yang disortir. There exist many sorting algorithms with substantially better worst-case or
average complexity of O ( n log n ). Terdapat banyak algoritma pengurutan dengan jauh lebih
baik-kasus terburuk atau rata-rata kompleksitas O (n log n). Even other О ( n 2 ) sorting
algorithms, such as insertion sort , tend to have better performance than bubble sort. Bahkan О
lain (n 2) algoritma pengurutan, seperti insertion sort , cenderung memiliki kinerja yang lebih
baik daripada bubble sort. Therefore, bubble sort is not a practical sorting algorithm when n is
large. Oleh karena itu, gelembung menyortir tidak praktis algoritma sorting ketika n adalah
besar.

The only significant advantage that bubble sort has over most other implementations, even
quicksort , but not insertion sort , is that the ability to detect that the list is sorted is efficiently
built into the algorithm. Yang signifikan satunya keuntungan yang semacam gelembung
memiliki lebih dari implementasi lainnya, bahkan quickSort , tetapi tidak insertion sort , adalah
bahwa kemampuan untuk mendeteksi bahwa daftar diurutkan secara efisien dibangun ke dalam
algoritma. Performance of bubble sort over an already-sorted list (best-case) is O ( n ). Kinerja
semacam gelembung di atas sebuah-daftar diurutkan sudah (kasus terbaik) adalah O (n). By
contrast, most other algorithms, even those with better average-case complexity, perform their
entire sorting process on the set and thus are more complex. Sebaliknya, sebagian besar
algoritma lain, bahkan mereka dengan kompleksitas rata-kasus yang lebih baik, melakukan
penyortiran mereka seluruh proses di set sehingga lebih kompleks. However, not only does
insertion sort have this mechanism too, but it also performs better on a list that is substantially
sorted (having a small number of inversions ). Namun, tidak hanya insertion sort memiliki
mekanisme ini juga, tetapi juga melakukan lebih baik pada daftar yang diurutkan secara
substansial (memiliki sejumlah kecil inversi ).

[ edit ] Rabbits and turtles [ sunting ] Kelinci dan kura-kura

The positions of the elements in bubble sort will play a large part in determining its performance.
Posisi elemen dalam bubble sort akan memainkan peran besar dalam menentukan kinerjanya.
Large elements at the beginning of the list do not pose a problem, as they are quickly swapped.
elemen besar pada awal daftar tidak menimbulkan masalah, karena mereka dengan cepat
bertukar. Small elements towards the end, however, move to the beginning extremely slowly.
unsur kecil menjelang akhir, bagaimanapun, pindah ke awal sangat perlahan. This has led to
these types of elements being named rabbits and turtles, respectively. Hal ini mengakibatkan
jenis elemen yang bernama kelinci dan kura-kura, masing-masing.

Various efforts have been made to eliminate turtles to improve upon the speed of bubble sort.
Cocktail sort achieves this goal fairly well, but it retains O(n 2 ) worst-case complexity. Comb
sort compares elements separated by large gaps, and can move turtles extremely quickly before
proceeding to smaller and smaller gaps to smooth out the list. Berbagai upaya telah dilakukan
untuk menghilangkan kura-kura untuk memperbaiki kecepatan bubble sort. semacam Cocktail
mencapai tujuan ini cukup baik, tapi tetap O (n 2) kompleksitas kasus terburuk. semacam Sisir
membandingkan elemen yang dipisahkan oleh gap yang besar, dan dapat bergerak kura-kura
sangat cepat sebelum melanjutkan ke kesenjangan yang lebih kecil dan lebih kecil untuk
kelancaran keluar daftar. Its average speed is comparable to faster algorithms like quicksort .
kecepatan rata-rata adalah sebanding dengan algoritma lebih cepat seperti quickSort .

[ edit ] Step-by-step example [ sunting ]-demi-langkah contoh Langkah

Let us take the array of numbers "5 1 4 2 8", and sort the array from lowest number to greatest
number using bubble sort algorithm. Mari kita ambil array dari angka "5 1 4 2 8", dan menyusun
deret dari angka terendah ke nomor terbesar nomor menggunakan gelembung sort Algoritma. In
each step, elements written in bold are being compared. Dalam setiap langkah, unsur yang ditulis
dalam huruf tebal sedang dibandingkan.

First Pass: Pertama Pass:
( 5 1 4 2 8 ) (5 1 4 2 8) ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and
swaps them. (1 5 4 2 8), Di sini, Algoritma membandingkan dua elemen pertama, dan swap
mereka.
( 1 5 4 2 8 ) (1 5 4 2 8) ( 1 4 5 2 8 ), Swap since 5 > 4 (1 4 5 2 8), Swap sejak 5> 4
( 1 4 5 2 8 ) (1 4 5 2 8) ( 1 4 2 5 8 ), Swap since 5 > 2 (1 4 2 5 8), Swap sejak 5> 2
( 1 4 2 5 8 ) (1 4 2 5 8) ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5),
algorithm does not swap them. (1 4 2 5 8), Sekarang, sejak elemen ini sudah dalam rangka (8>
5), algoritma tidak swap mereka.
Second Pass: Kedua Pass:
( 1 4 2 5 8 ) (1 4 2 5 8) ( 1 4 2 5 8 ) (1 4 2 5 8)
( 1 4 2 5 8 ) (1 4 2 5 8)   ( 1 2 4 5 8 ), Swap since 4 > 2 (1 2 4 5 8), Swap sejak 4> 2
( 1 2 4 5 8 ) (1 2 4 5 8)   ( 1 2 4 5 8 ) (1 2 4 5 8)
( 1 2 4 5 8 ) (1 2 4 5 8)   ( 1 2 4 5 8 ) (1 2 4 5 8)
Now, the array is already sorted, but our algorithm does not know if it is completed. Sekarang,
array sudah disortir, tetapi kami tidak Algoritma tahu jika sudah selesai. The algorithm needs one
whole pass without any swap to know it is sorted. Algoritma satu kebutuhan seluruh lulus tanpa
swap untuk mengetahui itu disortir.
Third Pass: Ketiga Pass:
( 1 2 4 5 8 ) (1 2 4 5 8)   ( 1 2 4 5 8 ) (1 2 4 5 8)
( 1 2 4 5 8 ) (1 2 4 5 8)   ( 1 2 4 5 8 ) (1 2 4 5 8)
( 1 2 4 5 8 ) (1 2 4 5 8)   ( 1 2 4 5 8 ) (1 2 4 5 8)
( 1 2 4 5 8 ) (1 2 4 5 8)   ( 1 2 4 5 8 ) (1 2 4 5 8)
Finally, the array is sorted, and the algorithm can terminate. Akhirnya, array diurutkan, dan
algoritma dapat menghentikan.

[ edit ] Implementation [ sunting ] Implementasi
[ edit ] Pseudocode implementation [ sunting ] Pseudocode pelaksanaan

The algorithm can be expressed as: Algoritma ini dapat dinyatakan sebagai:

procedure bubbleSort( A : list of sortable items ) do swapped = false for
each i in 1 to length(A) - 1 inclusive do: if A[i-1] > A[i] then swap( A[i-
1], A[i] ) swapped = true end if end for while swapped end procedure

[ edit ] Optimizing bubble sort [ sunting ] Mengoptimalkan bubble sort

The bubble sort algorithm can be easily optimized by observing that the largest elements are
placed in their final position in the first passes. Algoritma bubble sort dapat dengan mudah
dioptimalkan dengan mengamati bahwa elemen terbesar ditempatkan pada posisi akhir mereka
dalam melewati pertama. Or, more generally, after every pass, all elements after the last swap are
sorted, and do not need to be checked again. Atau, lebih umum, setelah lulus setiap, semua
elemen setelah swap terakhir diurutkan, dan tidak perlu diperiksa kembali. This not only allows
us to skip over a lot of the elements, but also skip tracking of the "swapped" variable. Hal ini
tidak hanya memungkinkan kita untuk melewatkan banyak elemen, tetapi juga melewatkan
pelacakan dari variabel "bertukar". This results in about a worst case 50% improvement in
iteration count, but no improvement in swap counts. Hal ini menghasilkan tentang kasus terburuk
peningkatan 50% pada jumlah iterasi, tetapi tidak ada perbaikan dalam jumlah swap.

To accomplish this in pseudocode we write the following: Untuk mencapai hal ini dalam
pseudocode kita tulis sebagai berikut:

procedure bubbleSort( A : list of sortable items ) n = length(A) do newn = 0
for (i = 0; i < n-1; i++) do: if A[i] > A[i+1] then swap(A[i], A[i+1]) newn =
i + 1 end if end for n = newn while n > 1 end procedure
procedure bubbleSort( A : list of sortable items ) n = length(A) do newn = 0
for (i = 0; i < n-1; i++) do: if A[i] > A[i+1] then swap(A[i], A[i+1]) newn =
i + 1 end if end for n = newn while n > 1 end procedure

Here is the Nested Loop Method: [ citation needed ] Berikut adalah Nested Loop Metode: [ rujukan? ]

procedure bubbleSort( A : list of sortable items ) n = length(A) for (i = 0;
i < n; i++) /* back through the area bringing smallest remaining element to
position i */ for (j = n-1; j > i; j--) if A[j-1] > A[j] then swap(A[j-1],
A[j]) end if end for end for end procedure
procedure bubbleSort( A : list of sortable items ) n = length(A) for (i = 0;
i < n; i++) /* back through the area bringing smallest remaining element to
position i */ for (j = n-1; j > i; j--) if A[j-1] > A[j] then swap(A[j-1],
A[j]) end if end for end for end procedure

Alternate modifications, such as the cocktail shaker sort attempt to improve on the bubble sort
performance without removing the compare and swap adjacent items behaviour. Alternatif
modifikasi, seperti cocktail shaker semacam upaya untuk memperbaiki kinerja bubble sort tanpa
mengeluarkan membandingkan dan swap item perilaku yang berdekatan.

[ edit ] In practice [ sunting ]



CONTOH PROGRAM PENGURUTAN NAMA



Prosedur BubbleSort (nomor: Array of Integer; size: Integer);
Var i, j, temp : Integer; Var i, j, temp: Integer;


Begin Mulai
 For i := size-1 DownTo 1 do Untuk i: = ukuran-1 DownTo 1 lakukan
  For j := 2 to i do Untuk j: = 2 sampai i do
   If (numbers[j-1] > numbers[j]) then Jika (angka [j-1]> angka [j]) maka
    Begin Mulai
     temp := numbers[j-1]; temp: = angka [j-1];
     numbers[j-1] := numbers[j]; nomor [j-1]: = angka [j];
     numbers[j] := temp; angka [j]: = temp;
    End; End;

End. Akhir.

Prosedur Bubble_Sort (Data: di           luar Data_T) adalah
     procedure Swap(A : in out           Item_T; B : in out Item_T) is Prosedur Swap
(A: di luar Item_T, B: di luar           Item_T) adalah
        T : constant Item_T :=           A; T: Item_T konstan: = A;
     begin mulai
        A := B; A: = B;
        B := T; B: T =;
   end Swap; Swap akhir;
   Finished : Boolean; Selesai: Boolean;
   Top : Integer := Data'Last; Top: Integer: Data'Last =;
begin mulai
   loop putaran
      Finished := True; Selesai: = True;
      Top := Top - 1; Top: = Top - 1;
      for I in Data'First..Top loop karena aku di Data'First .. loop Top
         if Data(I) > Data(I + 1) then jika Data (I)> Data (I + 1) maka
            Swap (Data(I), Data(I + 1)); Swap (Data (I), Data (I + 1));
            Finished := False; Selesai: = False;
         end if; berakhir jika;
      end loop; loop end;
      exit when Finished; keluar ketika jadi;
   end loop; loop end;
end Bubble_Sort; Bubble_Sort akhir;

				
DOCUMENT INFO
Shared By:
Categories:
Tags: algoritma
Stats:
views:39
posted:12/27/2011
language:Malay
pages:6