Heapsort

Merge sort

Algoritma

Algorithm

Versi Sederhana

Insertion Sort

Insertion sort adalah algoritma sorting sederhana yang membangun array akhir diurutkan (atau daftar) satu item pada suatu waktu. Hal ini jauh lebih efisien dalam daftar besar daripada algoritma yang lebih canggih seperti quicksort, heapsort, atau menggabungkan semacam. Namun, insertion sort memberikan beberapa keuntungan:

• Wikipedia pelaksanaan: Bentley menunjukkan C versi tiga baris, dan lima-line versi yang dioptimalkan [1]: 116

• Efisien untuk (cukup) set data kecil

• Lebih efisien dalam praktek daripada kebanyakan lainnya sederhana kuadrat (yaitu, O (n2)) algoritma seperti pemilihan jenis atau bubble sort

• Adaptive, yaitu, efisien untuk data set yang sudah substansial diurutkan: kompleksitas waktu O (nk) ketika setiap elemen dalam input tidak lebih dari k tempat jauh dari posisi diurutkan nya

• Stabil; yaitu, tidak mengubah urutan relatif elemen dengan kunci yang sama

• Di tempat; yaitu, hanya membutuhkan jumlah konstan O (1) ruang memori tambahan

• online; yaitu, dapat mengurutkan daftar seperti itu menerimanya

Ketika orang-orang secara manual memilah sesuatu (misalnya, setumpuk kartu remi), sebagian besar menggunakan metode yang mirip dengan insertion sort. [2]

Contoh grafis insertion sort.

Insertion sort iterates, mengkonsumsi satu elemen input setiap pengulangan, dan tumbuh daftar keluaran diurutkan. Setiap iterasi, insertion sort menghapus satu elemen dari input data, menemukan lokasi itu milik dalam daftar diurutkan, dan memasukkan ke sana. Ini mengulangi sampai tidak ada unsur masukan tetap.

Sortasi biasanya dilakukan di tempat, dengan iterasi atas array, tumbuh daftar diurutkan belakangnya. Pada setiap array posisi, cek nilai ada terhadap nilai terbesar dalam daftar diurutkan (yang kebetulan sebelahnya, dalam array-posisi sebelumnya diperiksa). Jika lebih besar, ia meninggalkan unsur di tempat dan bergerak ke depan. Jika lebih kecil, ia menemukan posisi yang benar dalam daftar diurutkan, menggeser semua nilai yang lebih besar untuk membuat ruang, dan memasukkan ke dalam posisi yang benar.

Array yang dihasilkan setelah k iterasi memiliki properti di mana pertama k + 1 entri diurutkan ("+1" karena masuknya pertama dilewati). Dalam setiap iterasi masuknya sisa pertama input dihapus, dan dimasukkan ke dalam hasil pada posisi yang benar, sehingga memperpanjang hasil

becomes

dengan setiap elemen yang lebih besar dari x disalin ke kanan seperti yang dibandingkan terhadap x.

Varian yang paling umum dari insertion sort, yang beroperasi pada array, dapat digambarkan sebagai berikut:

1. Misalkan ada sebuah fungsi yang disebut Insert dirancang untuk memasukkan nilai ke urutan diurutkan di awal array. Ini beroperasi dengan mulai pada akhir urutan dan pergeseran setiap elemen satu tempat ke kanan sampai posisi yang cocok ditemukan unsur baru. Fungsi ini memiliki efek samping Timpa nilai yang tersimpan setelah urutan diurutkan dalam array.

2. Untuk melakukan semacam penyisipan, mulai dari elemen paling kiri dari array dan memanggil Insert untuk menyisipkan setiap elemen ditemui dalam posisi yang benar. Urutan memerintahkan di mana elemen dimasukkan disimpan pada awal array di set indeks yang sudah diperiksa. Setiap penyisipan menimpa nilai tunggal: nilai yang dimasukkan.

Pseudocode dari algoritma lengkap berikut, di mana array berbasis nol: [1]: 116

for i ← 1 to length(A) - 1

j ← i

while j > 0 and A[j-1] > A[j]

swap A[j] and A[j-1]

j ← j - 1

end while

end for

Loop luar berjalan di atas semua elemen kecuali yang pertama , karena awalan tunggal elemen A [ 0 : 1 ] adalah sepele diurutkan , sehingga invarian bahwa saya pertama + 1 entri diurutkan benar dari awal . Batin lingkaran bergerak elemen A [ i] ke tempat yang benar sehingga setelah loop , i pertama + 2 unsur diurutkan .

Setelah memperluas " Swap " operasi - tempat seperti t ← A [ j ] ; A [ j ] ← A [ j - 1 ] ; A [ j - 1 ] ← t ( dimana t adalah variabel sementara ) , versi yang sedikit lebih cepat dapat diproduksi yang bergerak A [ i ] untuk posisinya dalam satu pergi dan hanya melakukan satu tugas dalam lingkaran dalam tubuh : [ 1 ] : 116

Loop batin yang baru bergeser unsur ke kanan untuk membersihkan tempat untuk x = A [ i ] .

Perhatikan bahwa meskipun praktek umum adalah untuk menerapkan di tempat , yang mengharuskan memeriksa unsur-unsur di -order , urutan pengecekan ( dan menghapus ) elemen masukan sebenarnya sewenang-wenang . Pilihan dapat dilakukan dengan menggunakan hampir pola apapun , asalkan semua elemen input akhirnya diperiksa ( dan dihapus dari input ) .

http://en.wikipedia.org/wiki/Insertion_sort

Bubble Sort

Algoritma bubble sort dapat dengan mudah dioptimalkan dengan mengamati bahwa ke-n lulus menemukan elemen terbesar ke-n dan menempatkan ke tempat akhir . Jadi , loop batin dapat menghindari melihat terakhir n - 1 item ketika berjalan untuk waktu ke-n :

procedure bubbleSort( A : list of sortable items )

    n = length(A)

    repeat

       swapped = false

       for i = 1 to n-1 inclusive do

          if A[i-1] > A[i] then

             swap(A[i-1], A[i])

             swapped = true

          end if

       end for

       n = n - 1

    until not swapped

end procedure

Secara umum , hal ini bisa terjadi bahwa lebih dari satu unsur ditempatkan pada posisi akhir mereka pada single pass . Secara khusus , setelah setiap lulus , semua elemen setelah swap terakhir diurutkan , dan tidak perlu diperiksa lagi . Hal ini memungkinkan kita untuk melewatkan banyak elemen , sehingga tentang kasus terburuk peningkatan 50 % dibandingkan count ( meskipun tidak ada perbaikan dalam pertukaran penting ) , dan menambahkan sedikit kompleksitas karena kode baru subsumes " bertukar " variabel :

Untuk mencapai hal ini dalam pseudocode kita menulis sebagai berikut :

procedure bubbleSort( A : list of sortable items )

    n = length(A)

    repeat

       newn = 0

       for i = 1 to n-1 inclusive do

          if A[i-1] > A[i] then

             swap(A[i-1], A[i])

             newn = i

          end if

       end for

       n = newn

    until n = 0

end procedure

Modifikasi alternatif , seperti cocktail pengocok semacam upaya untuk memperbaiki kinerja bubble sort sambil menjaga ide yang sama berulang kali membandingkan dan bertukar item yang berdekatan

In practice

Semacam gelembung, algoritma sorting yang terus langkah-langkah melalui daftar, bertukar item sampai mereka muncul dalam urutan yang benar. Daftar diplot dalam sistem koordinat Cartesian, dengan setiap titik (x, y) menunjukkan bahwa nilai y disimpan pada indeks x. Maka daftar akan diurutkan oleh Bubble sort sesuai dengan nilai setiap pixel. Perhatikan bahwa akhir terbesar akan diurutkan terlebih dahulu, dengan unsur-unsur yang lebih kecil waktu lebih lama untuk pindah ke posisi yang benar.

Meskipun bubble sort yaitu salah satu dari yang paling sederhana algoritma pengurutan untuk memahami dan melaksanakan, O (n2) kompleksitas berarti bahwa efisiensi menurun secara drastis pada daftar lebih dari sejumlah kecil elemen. Bahkan di antara O sederhana (n2) algoritma pengurutan, algoritma seperti insertion sort biasanya jauh lebih efisien.

Karena kesederhanaannya, bubble sort sering digunakan untuk memperkenalkan konsep algoritma, atau algoritma sorting, untuk pengantar siswa ilmu komputer. Namun, beberapa peneliti seperti Owen Astrachan telah berusaha keras untuk meremehkan bubble sort dan popularitasnya terus dalam pendidikan ilmu komputer, merekomendasikan bahwa bahkan tidak lagi diajarkan. [2]

Jargon File, yang terkenal panggilan Bogosort "yang archetypical algoritma [sic] anehnya mengerikan", juga menyerukan bubble sort "algoritma buruk generik". [3] Donald Knuth, dalam bukunya yang terkenal The Art of Computer Programming, menyimpulkan bahwa " bubble sort tampaknya memiliki apa-apa untuk merekomendasikan hal ini, kecuali nama yang menarik dan fakta yang mengarah ke beberapa masalah teoritis yang menarik ", beberapa di antaranya ia kemudian membahas. [1]

Bubble sort adalah asimtotik sama dalam menjalankan waktu untuk insertion sort dalam kasus terburuk, tetapi dua algoritma sangat berbeda dalam jumlah swap yang diperlukan. Hasil eksperimen seperti dari Astrachan juga menunjukkan bahwa insertion sort melakukan jauh lebih baik bahkan pada daftar acak. Untuk alasan ini banyak buku teks algoritma yang modern menghindari menggunakan algoritma bubble sort mendukung insertion sort.

Bubble sort juga berinteraksi buruk dengan hardware CPU modern. Hal ini membutuhkan setidaknya dua kali lebih banyak menulis sebagai insertion sort, dua kali lebih banyak cache misses, dan mispredictions cabang asimtotik lagi. Percobaan oleh Astrachan menyortir string di Jawa menunjukkan bubble sort menjadi sekitar seperlima secepat semacam penyisipan dan 70% secepat semacam seleksi. [2]

Dalam grafik komputer itu populer karena kemampuannya untuk mendeteksi kesalahan yang sangat kecil (seperti swap hanya dua elemen) dalam array hampir-disortir dan memperbaikinya dengan kompleksitas hanya linear (2n). Sebagai contoh, digunakan dalam algoritma poligon mengisi, di mana melompat-lompat garis diurutkan menurut mereka koordinat x pada garis pemindaian tertentu (garis yang sejajar dengan sumbu x) dan dengan incrementing y perubahan pesanan mereka (dua elemen yang bertukar) hanya di persimpangan dari dua baris. Bubble sort merupakan algoritma semacam stabil, seperti insertion sort

http://en.wikipedia.org/wiki/Bubble_sort

Exchange Sort

Pertukaran semacam ini mirip dengan sepupunya , semacam bubble , dalam hal ini membandingkan elemen array dan swap mereka yang tidak dalam posisi yang tepat . ( Beberapa orang merujuk pada " pertukaran semacam " sebagai " bubble sort " . ) Perbedaan antara kedua jenis ini adalah cara di mana mereka membandingkan elemen . Pertukaran semacam membandingkan elemen pertama dengan setiap elemen berikut array , membuat setiap swap yang diperlukan .

Ketika lulus pertama melalui array selesai , pertukaran semacam kemudian mengambil elemen kedua dan membandingkannya dengan setiap elemen berikut array swapping elemen yang rusak . Proses pemilahan ini berlanjut sampai seluruh array diperintahkan .

Mari kita memeriksa meja yang sama kami elemen lagi menggunakan semacam pertukaran untuk urutan . Ingat , sebuah " lulus " didefinisikan sebagai satu perjalanan penuh melalui array membandingkan dan jika perlu , swapping elemen .

Pertukaran semacam , dalam beberapa situasi , sedikit lebih efisien daripada jenis bubble . Hal ini tidak perlu untuk jenis pertukaran untuk membuat lulus lengkap akhir yang dibutuhkan oleh semacam bubble untuk menentukan bahwa itu selesai .

// Efek Urutkan Fungsi untuk Descending order

kekosongan ExchangeSort ( apvector < int > & num )

int temp;   // holding variable
     int numLength = num.length( );
     for (i=0; i< (numLength -1); i++)    // element to be compared
    {
          for(j = (i+1); j < numLength; j++)   // rest of the elements
       {
                if (num[i] < num[j])         // descending order
               {
                        temp= num[i];         // swap
                        num[i] = num[j];
                        num[j] = temp;
               }
          }
     }
     return;
}

http://mathbits.com/MathBits/CompSci/Arrays/Exchange.htm

Selection sort

Dalam ilmu komputer, semacam seleksi adalah algoritma sorting, khususnya perbandingan semacam di tempat. Memiliki O (n2) kompleksitas waktu, sehingga tidak efisien dalam daftar besar, dan umumnya melakukan lebih buruk daripada jenis penyisipan yang sama. Seleksi semacam terkenal karena kesederhanaan, dan memiliki keunggulan kinerja dari algoritma yang lebih rumit dalam situasi tertentu, terutama di mana memori tambahan terbatas.

Algoritma membagi daftar masukan menjadi dua bagian: sublist barang sudah disortir, yang dibangun dari kiri ke kanan di depan (kiri) dari daftar, dan sublist dari item yang tersisa akan diurutkan yang menempati sisa daftar. Awalnya, sublist diurutkan kosong dan sublist disortir adalah seluruh daftar masukan. Algoritma hasil dengan menemukan terkecil (atau terbesar, tergantung menyortir order) elemen dalam sublist disortir, menukarnya dengan elemen disortir paling kiri (meletakkan terurut), dan memindahkan batas sublist satu elemen ke kanan.

Berikut adalah contoh dari algoritma semacam ini menyortir lima elemen:

64 25 12 22 11 // ini adalah awal, mulai keadaan array

11 25 12 22 64 // diurutkan sublist = {} 11

11 12 25 22 64 // diurutkan sublist = {11, 12}

11 12 22 25 64 // diurutkan sublist = {11, 12, 22}

11 12 22 25 64 // sublist diurutkan = {11, 12, 22, 25}

11 12 22 25 64 // sublist diurutkan = {11, 12, 22, 25, 64}

Seleksi semacam animasi . Merah adalah min saat ini . Kuning diurutkan daftar . Biru adalah item saat ini .

( Tidak ada yang muncul berubah pada dua baris terakhir karena dua angka terakhir sudah dalam rangka )

Seleksi semacam ini juga dapat digunakan pada daftar struktur yang membuat menambah dan menghapus efisien , seperti linked list . Dalam hal ini lebih umum untuk menghapus elemen minimum dari sisa daftar, dan kemudian masukkan pada akhir nilai diurutkan sejauh ini. Sebagai contoh:

64 25 12 22 11

11 64 25 12 22

11 12 64 25 22

11 12 22 64 25

11 12 22 25 64

/* a[0] to a[n-1] is the array to sort */

int i,j;

int iMin;

/* advance the position through the entire array */

/* (could do j < n-1 because single element is also min element) */

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

/* find the min element in the unsorted a[j .. n-1] */

/* assume the min is the first element */

iMin = j;

/* test against elements after j to find the smallest */

for ( i = j+1; i < n; i++) {

/* if this element is less, then it is the new minimum */

if (a[i] < a[iMin]) {

/* found new minimum; remember its index */

iMin = i;

}

if(iMin != j) {

swap(a[j], a[iMin]);

}

http://en.wikipedia.org/wiki/Selection_sort

Dalam pemrograman komputer, heapsort adalah algoritma sorting-perbandingan berbasis. Heapsort dapat dianggap sebagai peningkatan semacam seleksi: seperti algoritma itu, membagi input menjadi diurutkan dan wilayah disortir, dan iteratif menyusut wilayah disortir dengan mengekstraksi elemen terbesar dan bergerak yang ke wilayah diurutkan. Peningkatan tersebut terdiri dari penggunaan struktur data tumpukan daripada pencarian linear-waktu untuk menemukan maksimal. [2

Meskipun agak lambat dalam praktek pada kebanyakan mesin dari quicksort yang dilaksanakan, ini memiliki keunggulan yang lebih menguntungkan terburuk O (n log n) runtime. Heapsort adalah algoritma di tempat, tapi itu bukan semacam stabil.

Heapsort diciptakan oleh JWJ Williams pada tahun 1964. [3] Hal ini juga kelahiran tumpukan, disajikan sudah oleh Williams sebagai struktur data yang berguna dalam dirinya sendiri. [4] Pada tahun yang sama, RW Floyd menerbitkan sebuah versi perbaikan yang bisa mengurutkan array di tempat, melanjutkan penelitian sebelumnya ke dalam algoritma Treesort. [4]

Algoritma heapsort sendiri memiliki O (n log n) kompleksitas waktu baik menggunakan versi heapify.

procedure heapify(a,count) is

     (end is assigned the index of the first (left) child of the root)

     end := 1

     while end < count

         (sift up the node at index end to the proper place such that all nodes above

          the end index are in heap order)

         siftUp(a, 0, end)

         end := end + 1

     (after sifting up the last node all nodes are in heap order)

 procedure siftUp(a, start, end) is

     input:  start represents the limit of how far up the heap to sift.

                   end is the node to sift up.

     child := end

     while child > start

         parent := floor((child-1) / 2)

         if a[parent] < a[child] then (out of max-heap order)

             swap(a[parent], a[child])

             child := parent (repeat to continue sifting up the parent now)

         else

             return

http://en.wikipedia.org/wiki/Heapsort

Quicksort

Quicksort merupakan Algoritma Sorting yang dikembangkan oleh Tony Hoare yang, secara kasus rata-rata, membuat pengurutan O(n log n) untuk mengurutkan n item. Algoritma ini juga dikenal sebagai Partition-Exchange Sort atau disebut sebagai Sorting Pergantian Pembagi. Pada kasus terburuknya, algoritma ini membuat perbandingan O(n²), malaupun kejadian seperti ini sangat langka. Quicksort sering lebih cepat dalam praktiknya dari pada algoritma O(n log n) yang lainnya.^[1] Dan juga, urutan dan referensi lokalisasi memori quicksort bekerja lebih baik dengan menggunakan cache CPU, jadi keseluruhan sorting dapat dilakukan hanya dengan ruang tambahan O(log n).^[2]

Quicksort merupakan sorting pembanding dan pada implementasi efisien tidak merupakan algoritma sorting yang stabil.

Quicksort merupakan Algoritma Pembagi. Pertama sekali quicksort membagi list yang besar menjadi dua buah sub list yang lebih kecil: element kecil dan element besar. Quicksort kemudian dapat menyortir sub list itu secara rekursif.

Langkah-Langkah pengerjaannya ialah:

Ambil sebuah elemen, yang disebut dengan pivot, pada sebuah daftar.
Urutkan kembali sebuah list sehingga elemen dengan nilai yang kecil dari pivot berada sebelum pivot, sedangkan seluruh element yang memiliki nilai yang lebih besar dari pivot berada setelahnya (nilai yang sama dapat berada pada pivot setelahnya). Setelah pemisahan, pivot berada pada posisi akhirnya. Operasi ini disebut Partition.
Sub list kemudian disortir secara recursif dari elemen yang lebih kecil dan sub list dari elemen yang lebih besar.

Kasus dasar dari rekusrif ialah list dari besaran nol atau satu, yang tidak perlu untuk di sorting.

Dalam Pseudocode sederhana, Algoritmanya dapat dinyatakan sebagai berikut:

  function quicksort('array')

      if length('array') ≤ 1

          return 'array'  // an array of zero or one elements is already sorted

      select and remove a pivot value 'pivot' from 'array'

      create empty lists 'less' and 'greater'

      for each 'x' in 'array'

          if 'x' ≤ 'pivot' then append 'x' to 'less'

          else append 'x' to 'greater'

      return concatenate(quicksort('less'), 'pivot', quicksort('greater')) // two recursive calls

Contoh keseluruhan dari quicksort pada kumpulan acak dari angka. Element yang gelap merupakan pivot. Pivot selalu dipilih sebagai element terakhir pada partisi. Bagaimanapun, selalu memilih elemen terakhir pada partisi sebagai pivot sehingga hasil pada kasus terburuk (

) pada daftar yang telah diurutkan, atau daftar yang serupa. Karena elemen yang sama memotong hingga pada akhir dari prosedur soring pada jumlah yang besar, versi dari algoritma quicksort yang memilih pivot sebagai elemen tengah berjalan lebih cepat dari pada algortima yang dijelaskan pada diagram ini pada sejumlah besar angka.

Perlu diperhatikan bahwa kita hanya memeriksa elemen dengan membandingkan mereka pada elemen yang lain. Prosedur ini disebuk Sorting Pembandingan. Jenis ini juga merupakan jenis sorting yang stabil (asumsikan bahwa untuk setiap method menerima elemen pada urutan aslinya dan pivot yang dipilih merupakan elemen terakhir dari nilai yang sama).
Kebenaran dari algoritma partisi didasari pada dua argumen berikut:

Pada setiap iterasi, seluruh elemen diproses selama ini berada pada posisi yang diinginkan: sebelum pivot lebih kurang dari nilai pivot, setelah pivot lebih besar dari nilai pivot (Invarian Loop).

Kebenaran dari keseluruhan algortima dapat dibuktikan dengan penyederhanaan fakta: untuk elemen nol atau satu, algoritma tidak akan mengubah data; untuk jumlah data yang lebih besar, algoritma akan menghasilkan dua bagian, elemen yang kurang dari pivot dan elemen yang lebih besar dari nya, data ini sendiri akan diurutkan secara hipotesa rekursif.

Contoh dari penerapan Quicksort.

Partisi ditepat bekerja pada daftar yang kecil. Elemen kotak merupakan element pivot, elemen berwarna biru merupakan elemen yang bernilai kecil atau sama, dan elemen yang berwarna merah lebih besar.

http://id.wikipedia.org/wiki/Quicksort

Dalam ilmu komputer , menggabungkan semacam ( juga biasa dieja mergesort ) adalah O ( n log n ) perbandingan berbasis algoritma sorting . Kebanyakan implementasi menghasilkan semacam stabil , yang berarti bahwa pelaksanaan mempertahankan urutan masukan dari elemen yang sama dalam output diurutkan . Mergesort adalah membagi dan menaklukkan algoritma yang diciptakan oleh John von Neumann pada tahun 1945. [ 1 ] Sebuah penjelasan rinci dan analisis bottom - up mergesort muncul dalam sebuah laporan oleh Goldstine dan Neumann pada awal 1948. [ 2

Array at beginning:

After Pass #1:

After Pass #2:

After Pass #3:

After Pass #4:

After Pass #5 (done):

Menggabungkan semacam animasi . Unsur-unsur diurutkan diwakili oleh titik .

Secara konseptual , merge semacam bekerja sebagai berikut :

1. Bagilah daftar disortir ke n sublists , masing-masing berisi 1 elemen ( daftar 1 elemen dianggap diurutkan ) .

2. berulang menggabungkan sublists untuk menghasilkan sublists diurutkan baru sampai hanya ada 1 sublist tersisa . Ini akan menjadi daftar diurutkan .

Implementasi top -down

Contoh C seperti kode menggunakan indeks untuk top down algoritma merge sort secara rekursif membagi daftar ( disebut berjalan dalam contoh ini ) ke dalam sublists sampai ukuran sublist adalah 1 , kemudian menggabungkan mereka sublists untuk menghasilkan daftar diurutkan . Salinan kembali langkah dapat dihindari jika rekursi berganti-ganti antara dua fungsi sehingga arah penggabungan sesuai dengan tingkat rekursi

TopDownMergeSort(A[], B[], n)

    TopDownSplitMerge(A, 0, n, B);

// iBegin is inclusive; iEnd is exclusive (A[iEnd] is not in the set)

TopDownSplitMerge(A[], iBegin, iEnd, B[])

    if(iEnd - iBegin < 2)                       // if run size == 1

        return;                                 //   consider it sorted

    // recursively split runs into two halves until run size == 1,

    // then merge them and return back up the call chain

    iMiddle = (iEnd + iBegin) / 2;              // iMiddle = mid point

    TopDownSplitMerge(A, iBegin,  iMiddle, B);  // split / merge left  half

    TopDownSplitMerge(A, iMiddle,    iEnd, B);  // split / merge right half

    TopDownMerge(A, iBegin, iMiddle, iEnd, B);  // merge the two half runs

    CopyArray(B, iBegin, iEnd, A);              // copy the merged runs back to A

//  left half is A[iBegin :iMiddle-1]

// right half is A[iMiddle:iEnd-1   ]

TopDownMerge(A[], iBegin, iMiddle, iEnd, B[])

    i0 = iBegin, i1 = iMiddle;

    // While there are elements in the left or right runs

    for (j = iBegin; j < iEnd; j++) {

        // If left run head exists and is <= existing right run head.

        if (i0 < iMiddle && (i1 >= iEnd || A[i0] <= A[i1]))

            B[j] = A[i0];

            i0 = i0 + 1;

        else

            B[j] = A[i1];

            i1 = i1 + 1;

CopyArray(B[], iBegin, iEnd, A[])

    for(k = iBegin; k < iEnd; k++)

        A[k] = B[k];

http://en.wikipedia.org/wiki/Merge_sort

Shellsort

Shellsort, juga dikenal sebagai Shell sort atau metode Shell, merupakan perbandingan semacam di tempat. Hal ini dapat dilihat baik sebagai generalisasi dari menyortir melalui pertukaran (bubble sort) atau menyortir dengan memasukkan (insertion sort). [1] Metode ini dimulai dengan menyortir pasang elemen jauh terpisah dari satu sama lain, maka semakin mengurangi kesenjangan antara elemen untuk dibandingkan. Dimulai dengan berjauhan elemen dapat memindahkan beberapa out-of-tempat elemen ke posisi lebih cepat dari pertukaran tetangga terdekat yang sederhana. Donald Shell menerbitkan versi pertama semacam ini pada tahun 1959. [2] [3] Waktu berjalan dari Shellsort sangat bergantung pada urutan kesenjangan yang digunakannya. Bagi banyak varian praktis, menentukan kompleksitas waktu mereka tetap merupakan masalah terbuka.

Deskripsi

Shellsort adalah generalisasi dari insertion sort yang memungkinkan pertukaran item yang terpisah jauh. Idenya adalah untuk mengatur daftar elemen sehingga, mulai di mana saja, mengingat setiap elemen hth memberikan daftar diurutkan. Daftar semacam dikatakan-h diurutkan. Dengan kata lain, hal itu dapat dianggap sebagai h disisipkan daftar, masing-masing individu diurutkan. [4] Dimulai dengan nilai-nilai besar h, penataan ulang ini memungkinkan elemen untuk memindahkan jarak jauh dalam daftar asli, mengurangi jumlah besar gangguan dengan cepat, dan meninggalkan sedikit pekerjaan untuk langkah-langkah h-jenis yang lebih kecil untuk melakukan. [5] Jika file yang kemudian k-diurutkan untuk suatu bilangan bulat k lebih kecil, maka file tersebut tetap-h diurutkan. Setelah ide ini untuk urutan penurunan nilai h berakhir pada 1 dijamin untuk meninggalkan daftar diurutkan pada akhirnya. [4]

Contoh dijalankan dari Shellsort dengan kesenjangan 5, 3 dan 1 ditampilkan di bawah.

Pertama lulus, 5-pemilahan, melakukan insertion sort pada subarrays terpisah (a1, a6, a11), (a2, a7, A12), (a3, a8), (a4, a9), (a5, a10). Misalnya, mengubah subarray (a1, a6, a11) dari (62, 17, 25) ke (17, 25, 62). Lulus berikutnya, 3-pemilahan, melakukan insertion sort pada subarrays (a1, a4, a7, a10), (a2, a5, a8, a11), (a3, a6, a9, A12). Lulus terakhir, 1-penyortiran, adalah semacam penyisipan biasa dari seluruh array (a1, ..., A12).

Sebagai contoh menggambarkan, para subarrays yang Shellsort beroperasi pada awalnya pendek; kemudian mereka lagi tapi hampir memerintahkan. Dalam kedua kasus insertion sort bekerja secara efisien.

Shellsort tidak stabil: mungkin mengubah urutan relatif elemen dengan nilai-nilai yang sama. Ini adalah adaptif algoritma sorting dalam dijalankan lebih cepat ketika input sebagian diurutkan.

Pseudocode

Menggunakan urutan kesenjangan Marcin Ciura itu, dengan insertion sort batin.

# Sort an array a[0...n-1].

gaps = [701, 301, 132, 57, 23, 10, 4, 1]

# Start with the largest gap and work down to a gap of 1

foreach (gap in gaps)

{

# Do a gapped insertion sort for this gap size.

# The first gap elements a[0..gap-1] are already in gapped order

# keep adding one more element until the entire array is gap sorted

for (i = gap; i < n; i += 1)

{

# add a[i] to the elements that have been gap sorted

# save a[i] in temp and make a hole at position i

temp = a[i]

# shift earlier gap-sorted elements up until the correct location for a[i] is found

for (j = i; j >= gap and a[j - gap] > temp; j -= gap)

{

a[j] = a[j - gap]

}

# put temp (the original a[i]) in its correct location

a[j] = temp

}

http://en.wikipedia.org/wiki/Shellsort

Referensi