Kaedah untuk menyusun data dalam pengaturcaraan. Kaedah untuk menyusun tatasusunan. Ciri-ciri perbandingan kaedah pengisihan

KAEDAH MENGISIH

Semasa pembangunan perisian Operasi yang sangat biasa adalah untuk mengisih nilai, i.e. menyusun senarai unsur dalam susunan tertentu (contohnya, perkataan dalam susunan abjad atau nombor dalam susunan menaik atau menurun).

Terdapat banyak algoritma untuk menyusun elemen. Yang paling mudah ialah kaedah "gelembung". Algoritma ini dilaksanakan dalam bentuk dua gelung bersarang. Dalam gelung dalam, semua elemen tatasusunan dilihat mengikut tertib, elemen bersebelahan dibandingkan secara berpasangan, dan jika yang kedua lebih besar daripada yang pertama (apabila mengisih dalam tertib menurun), elemen ditukar. Parameter gelung dalam ialah indeks (nombor) elemen tatasusunan. Untuk jenis lengkap, pilih atur sedemikian mesti dilakukan n-1 kali, dengan n ialah bilangan elemen dalam tatasusunan. Untuk melakukan ini, gelung luaran diatur, parameternya ialah langkah pengisihan.

Contoh. Isih elemen tatasusunan satu dimensi integer dalam tertib menaik.

Rajah 1 menunjukkan urutan penyusunan semula unsur.

Rajah 1. Isih gelembung

Walaupun dalam contoh yang dicadangkan pengisihan telah diselesaikan dalam empat langkah, menyemak elemen akan diteruskan untuk dua lagi lelaran, kerana jumlah bilangan lelaran adalah kurang satu daripada saiz tatasusunan.

Rajah 2 menunjukkan gambarajah blok bagi algoritma yang dipertimbangkan.

Rajah 2. Carta alir algoritma isihan buih

Pembolehubah m diperkenalkan untuk membolehkan pertukaran nilai antara dua pembolehubah, k bertanggungjawab untuk langkah pengisihan.

Program C++ menggunakan algoritma ini akan kelihatan seperti ini.

Rajah 3. Program untuk menyusun elemen tatasusunan menggunakan kaedah “bubble”.

Pengisihan gelembung adalah kaedah yang tidak cekap kerana nombor besar perbandingan.

Kaedah pemilihan langsung lebih berkesan

Langkah pertama melibatkan melihat secara berurutan keseluruhan senarai nilai dan memilih minimum atau maksimum daripadanya (bergantung pada susunan pengisihan), kemudian meletakkannya di kedudukan pertama dengan menukarnya dengan elemen yang ada sebelum ini.

Kemudian prosedur ini diulang, tetapi carian untuk nilai minimum (maksimum) berlaku dari kedudukan kedua, dsb. Gambar rajah algoritma ini ditunjukkan dalam Rajah 4.

perisian nilai pengisihan

Rajah 4. Isih Pemilihan Terus

Serpihan program yang melaksanakan pengisihan menggunakan kaedah pemilihan langsung diberikan di bawah.

// menyusun elemen tatasusunan dalam tertib menaik

int temp;//pembolehubah untuk storan sementara apabila menukar nilai

int i; // pembolehubah kawalan gelung (nombor elemen tatasusunan)

int k; // pembolehubah kawalan gelung (mengisih nombor langkah)

int nmin;//nombor nilai minimum

untuk (k=0; i< к 1; i++)

// cari bilangan elemen minimum di antara senarai nilai [ i ... n -1]

untuk (i = k+1; i< n; i++)

jika (senarai[i]< list[ nmin ]) nmin = i;

//swap list[ nmin ] dan list[ k ]

temp = senarai[nmin];

senarai[nmin]= senarai[k];

senarai[ k ] = temp;

Perlu diingatkan bahawa carian untuk nilai minimum dalam gelung dalaman berlaku di seluruh senarai.

Untuk mengisih dalam tertib menurun, anda perlu mencari nilai maksimum pada setiap langkah dan bukannya nilai minimum.

Pada hari yang lain, dalam komen di VKontakte, saya bertengkar dengan salah seorang pelajar lain projek itu. Intipati pertikaian ialah "siapa yang menang" - kaedah sort() daripada kelas java.util.Arrays atau pelaksanaan algoritma mudah yang ditulis sendiri: gelembung(gelembung), sisipan(sisipan), pemilihan(dengan pilihan), cangkerang(Algoritma Shell). Bagi sesetengah orang jawapan kepada soalan ini mungkin jelas, tetapi sejak pertikaian itu timbul, walaupun pada hakikatnya setiap pihak mempunyai "sumber yang dihormati" yang memihak kepada pandangan mereka, ia telah memutuskan untuk menjalankan kajian, meregangkan masalah kelabu dalam proses itu, melaksanakan pelbagai algoritma . TL;DR: java.util.Arrays.sort() memimpin tanpa syarat pada tatasusunan 100,000 elemen, dengan saiz yang lebih kecil Kaedah Shell kadangkala boleh bersaing dengannya. Selebihnya algoritma yang dipertimbangkan adalah kosong sepenuhnya dan boleh berguna hanya dalam beberapa keadaan eksotik. Sekarang mari kita lihat bagaimana tatasusunan diisih dalam peranti uber silikon kami.

Isihan pilihan. Isih mengikut pilihan

Mari kita mulakan dengan yang paling mudah dan cara yang jelas. Intipatinya ditunjukkan dengan sempurna kepada kita oleh Robert Sedgwick dalam kuliah videonya tentang coursera (saya akan memetik animasi dari sana, yang saya mampatkan dengan teruk menjadi gif): Menjalankan tatasusunan dari elemen pertama, kita mencari di sebelah kanan pada setiap langkah elemen minimum, yang dengannya kita menukar yang semasa. Akibatnya, kami menempah versi akhir tatasusunan kami dalam bentuk yang diisih. Berikut ialah kod yang melaksanakan algoritma ini dalam Java: public void sort (int array) ( int n = array. length; for (int i = 0 ; i< n; i ++ ) { int minIndex = min (array, i, n - 1 ) ; swap (array, i, minIndex) ; } } public static void swap (int array, int i, int j) { int temp = array[ i] ; array[ i] = array[ j] ; array[ j] = temp; } public static int min (int array, int begin, int end) { int minVal = array[ begin] ; int minIndex = begin; for (int i = begin + 1 ; i <= end; i++ ) { if (array[ i] < minVal) { minVal = array[ i] ; minIndex = i; } } return minIndex; } Анализ алгоритма показывает, что необходимо на каждом проходе прошерстить весть остаток массива, то есть нам понадобится ровно N + (N-1) + (N-2) + … + 1 = N^2/2 сравнений. Таким образом, сложность алгоритма составляет O(N^2). Что же это означает? А означает это, что, увеличив количество элементов в массиве (N) в 2 раза, мы увеличим время работы алгоритма не в 2, а в 2^2 = 4 раза. Увеличив N в 10 раз, время работы увеличим в 100 раз и так далее. На моем ноутбуке 2012 года с процессором Core i3 под Ubuntu 14.4 я получил следующее время работы:

Isihan sisipan. Isihan sisipan

Di sini ideanya sedikit berbeza. Sekali lagi, mari kita beralih kepada animasi daripada Doktor Sedgwick: Apa yang di hadapan masih belum dilihat oleh kita lagi, dan semua yang kita tinggalkan sentiasa kekal teratur. Intinya ialah kita "mengembalikan" setiap elemen baharu tatasusunan asal ke permulaan sehingga ia "bersandar" pada elemen yang lebih kecil. Oleh itu, kita sekali lagi mempunyai N pas (untuk setiap elemen tatasusunan asal), tetapi dalam setiap pas, dalam kebanyakan kes, kita tidak melihat keseluruhan baki, tetapi hanya sebahagian. Iaitu, kita akan mendapat pilihan 1 + (N-1) + (N-2) + … + N = N^2/2 hanya jika kita perlu mengembalikan setiap elemen seterusnya ke permulaan, iaitu, dalam kes daripada input yang diisih tatasusunan "dalam songsang" (malang, malang). Dalam kes tatasusunan yang telah diisih (inilah nasib) akan ada freebie yang lengkap - pada setiap pas hanya terdapat satu perbandingan dan membiarkan elemen di tempatnya, iaitu, algoritma akan berfungsi dalam masa yang berkadar dengan N. Kerumitan algoritma akan ditentukan oleh kes teori yang paling teruk, iaitu, O(N^2). Secara purata, masa operasi akan berkadar dengan N^2/4, iaitu, dua kali lebih pantas daripada algoritma sebelumnya. Dalam pelaksanaan saya, disebabkan penggunaan pilihatur yang tidak optimum, masa berjalan lebih lama daripada Pemilihan. Saya bercadang untuk membetulkan dan mengemas kini siaran itu tidak lama lagi. Berikut ialah kod dan hasil menjalankannya pada mesin yang sama: public void sort (int array) ( int length = array. length; for (int i = 1 ; i< length; i++ ) { for (int j = i; j >= 1 ; j-- ) ( jika (tatasusunan[ j]< array[ j - 1 ] ) swap (array, j, j - 1 ) ; else break ; } } }

Isih cangkerang. Isih cangkerang

Seorang lelaki pintar, Donald Schell, menyedari pada tahun 1959 bahawa kes yang paling mahal dalam algoritma untuk sisipan adalah apabila elemen kembali sangat jauh ke permulaan tatasusunan: pada beberapa laluan kita mengembalikan elemen ke permulaan dengan beberapa kedudukan , dan pada satu lagi laluan hampir melalui keseluruhan tatasusunan ke permulaan adalah jauh dan panjang. Adakah mungkin untuk melakukan ini sekaligus, melompat melalui beberapa elemen? Dan dia menemui cara sedemikian. Ia terdiri daripada pelaksanaan berurutan jenis separa khas, yang dipanggil Pandangan umum d-sort atau, mengikut Sedgwick, h-sort (saya mengesyaki h bermaksud hop). 3-sort, sebagai contoh, akan membandingkan elemen yang dipersoalkan bukan dengan yang sebelumnya, tetapi akan melangkau dua dan membandingkan dengan satu 3 kedudukan kembali. Jika diubah, ia akan membandingkannya semula dengan kedudukan elemen 3 kembali dan seterusnya. Intinya ialah tatasusunan yang terhasil akan menjadi "3-isih", iaitu, kedudukan elemen yang salah akan kurang daripada 3 kedudukan. Bekerja dengan algoritma sisipan ini akan menjadi mudah dan menyenangkan. By the way, "1-sort" tidak lebih daripada sekadar algoritma sisipan =) Dengan menggunakan h-sort secara berurutan pada tatasusunan dengan menurunkan nilai h, kita boleh mengisih tatasusunan yang besar dengan lebih cepat. Begini rupanya: Kesukaran di sini ialah cara memilih urutan yang betul jenis separa. Akhirnya, prestasi algoritma bergantung pada ini. Yang paling biasa ialah jujukan yang dicadangkan oleh Donald Knuth: h = h*3 + 1, iaitu, 1, 4, 13, 40, ... dan seterusnya sehingga 1/3 daripada saiz tatasusunan. Urutan ini memberikan prestasi yang baik dan juga mudah untuk dilaksanakan. Analisis algoritma memerlukan banyak bahasa dan di luar kemampuan saya. Keluasan analisis juga ditentukan oleh banyak variasi jujukan h. Secara empirik, kita boleh mengatakan bahawa kelajuan algoritma adalah sangat baik - lihat sendiri: Sejuta elemen dalam masa kurang dari satu saat! Dan inilah kod Java dengan urutan Knut. sort void awam (int array) ( int h = 1 ; manakala (h* 3< array. length) h = h * 3 + 1 ; while (h >= 1 ) ( hSort (susunan, h); h = h/ 3 ; ) ) private void hSort (int array, int h) ( int length = array. length; for (int i = h; i< length; i++ ) { for (int j = i; j >= h; j = j - h) ( jika (tatasusunan[ j]< array[ j - h] ) swap (array, j, j - h) ; else break ; } } }

Isih gelembung. Kaedah gelembung

Ini adalah klasik! Hampir setiap pengaturcara pemula melaksanakan algoritma ini. Ia sangat klasik sehingga Dr. Sedgwick tidak mempunyai animasi untuknya, jadi saya terpaksa melakukan kerja itu sendiri. Di sini, pada setiap laluan, kami melintasi tatasusunan dari awal hingga akhir, menukar elemen jiran yang tidak teratur. Akibatnya, elemen terbesar "terapung" (oleh itu namanya) ke penghujung tatasusunan. Kami memulakan setiap pas baharu dengan optimis mengharapkan tatasusunan sudah diisih (diisih = benar). Di penghujung petikan, jika kita melihat bahawa kita telah melakukan kesilapan, kita mulakan laluan baru. Kesukaran di sini ialah, sekali lagi, kita sedang melintasi (hampir) keseluruhan tatasusunan pada setiap laluan. Perbandingan berlaku pada setiap langkah, pertukaran berlaku pada hampir setiap langkah algoritma ini salah satu yang paling perlahan (jika kita menganggap yang dilaksanakan secara rasional, dan bukan "goncang jenis" dan lain-lain seperti itu). Sungguh menarik bahawa secara rasmi kerumitan di sini juga akan sama dengan O(N^2), tetapi pekalinya jauh lebih tinggi daripada sisipan dan pemilihan. Kod algoritma: sort void awam (int array) ( boolean isSorted; int nMinusOne = array. length - 1 ; for (int i = 0 ; i< nMinusOne; i++ ) { isSorted = true ; for (int j = 0 ; j < nMinusOne - i; j++ ) { if (array[ j] >tatasusunan[ j + 1 ] ) ( swap (susunan, j, j + 1 ); isSorted = false ; ) ) jika (isSorted) return ; ) ) Masa operasi: Rasai perbezaannya: lebih daripada setengah jam pada sejuta elemen! Kesimpulan: Jangan gunakan algoritma ini!!!

Ringkasan bahagian pertama

Akibatnya, saya cadangkan melihat jadual umum untuk algoritma ini. Anda juga boleh membandingkan dengan keputusan untuk kaedah java.util.Arrays.sort() terbina dalam. Ia kelihatan seperti sejenis sihir - apakah yang lebih pantas daripada Shell? Saya akan menulis tentang ini di bahagian seterusnya. Di sana kita akan melihat algoritma pengisihan pantas yang digunakan secara meluas, serta pengisihan gabungan, belajar tentang perbezaan kaedah untuk menyusun tatasusunan primitif dan jenis rujukan, dan juga berkenalan dengan antara muka Setanding, yang sangat penting dalam perkara ini ;) Di bawah anda boleh mengkaji graf yang dibina pada skala logaritma oleh data jadual. Lebih rata garisan, lebih baik algoritma =) Bagi mereka yang ingin memuat turun keseluruhan projek dan menjalankan ujian sendiri, simpan pautan: Java Jumpa anda di bahagian seterusnya! =) Kaedah pengisihan asas Sebagai lawatan pertama kami ke dalam bidang pengisihan algoritma, kami akan meneroka beberapa kaedah "asas" yang berfungsi dengan baik untuk fail kecil atau fail dengan struktur khas. Terdapat beberapa sebab mengapa mempelajari ini kaedah mudah. Pertama, mereka memberi kita cara yang agak tidak menyakitkan untuk mempelajari istilah dan cara kerja asas algoritma pengisihan, yang memberikan kita asas yang diperlukan untuk mengkaji algoritma yang lebih kompleks. Kedua, untuk banyak masalah pengisihan mungkin lebih baik menggunakan kaedah yang mudah daripada yang lebih kompleks. algoritma yang kompleks. Akhir sekali, beberapa kaedah yang lebih mudah boleh diperluaskan kepada lebih banyak lagi kaedah yang baik atau gunakannya untuk menambah baik yang lebih kompleks. Dalam sesetengah atur cara pengisihan, lebih baik menggunakan algoritma mudah. Program pengisihan selalunya digunakan sekali sahaja (atau beberapa kali). Jika bilangan elemen yang perlu diisih tidak besar (katakan, kurang daripada 500 elemen), maka mungkin menggunakan algoritma mudah akan lebih cekap daripada membangunkan dan menyahpepijat algoritma yang kompleks. Kaedah asas sentiasa sesuai untuk fail kecil (katakan, lebih kecil daripada 50 elemen); Tidak mungkin algoritma yang kompleks akan bijak digunakan untuk fail sedemikian, melainkan sudah tentu terdapat keperluan untuk mengisih sejumlah besar fail sedemikian. Sebagai peraturan, kaedah asas, yang akan kita bincangkan, lakukan tentang operasi untuk pengisihan N elemen yang dipilih secara rawak. Jika N cukup kecil, maka ini mungkin tidak menjadi masalah, dan jika elemen tidak diedarkan secara rawak, maka algoritma ini boleh berfungsi lebih cepat daripada yang kompleks. Walau bagaimanapun, perkara yang perlu diingat adalah bahawa algoritma ini tidak boleh digunakan untuk fail yang besar dan dipesan secara rawak, dengan satu pengecualian ialah algoritma isihan shell, yang sering digunakan dalam banyak program. Peraturan permainan

Sebelum melihat mana-mana algoritma tertentu, adalah berguna untuk mempelajari terminologi dan beberapa konvensyen asas mengenai algoritma pengisihan. Kami akan mengkaji algoritma untuk menyusun merakam fail mengandungi kunci. Kekunci, yang hanya sebahagian daripada rekod (selalunya sebahagian kecil daripadanya), digunakan untuk mengawal proses pengisihan. Tujuan algoritma pengisihan adalah untuk menyusun semula rekod dalam fail supaya ia muncul dalam beberapa susunan yang ditetapkan dengan ketat (biasanya mengikut abjad atau angka).

Jika fail yang hendak diisih sesuai sepenuhnya ke dalam memori (atau dimuatkan sepenuhnya ke dalam tatasusunan), maka untuk itu kami gunakan dalaman kaedah pengasingan. Mengisih data daripada pita atau cakera dipanggil luaran menyusun. Perbezaan utama antara mereka ialah dengan pengisihan dalaman, sebarang rekod mudah diakses, manakala dengan pengisihan luaran, kita hanya boleh menggunakan rekod secara berurutan, atau dalam blok besar. Kebanyakan algoritma pengisihan yang akan kami lihat adalah dalaman.

Biasanya, perkara utama yang akan menarik minat kita dalam algoritma adalah masa berjalannya. Empat algoritma pertama yang akan kita lihat untuk menyusun elemen N mempunyai masa berjalan berkadar, manakala algoritma yang lebih kompleks menggunakan masa berjalan berkadar. (Ia boleh ditunjukkan bahawa tiada algoritma pengisihan boleh menggunakan kurang daripada perbandingan antara kekunci.) Selepas meneroka kaedah mudah, kita akan melihat kaedah yang lebih kompleks yang masa berjalannya adalah berkadar dan kaedah yang menggunakan sifat binari kunci untuk mengurangkan jumlah masa berjalan kepada N.

Kuantiti yang digunakan ingatan tambahan algoritma pengisihan adalah satu lagi faktor penting, yang akan kami ambil kira. Secara umumnya, kaedah pengisihan terbahagi kepada tiga jenis:

kaedah pengisihan yang mengisih tanpa menggunakan sebarang memori tambahan, kecuali mungkin timbunan kecil dan/atau tatasusunan;

kaedah yang digunakan untuk menyusun senarai berkaitan dan oleh itu gunakan N petunjuk tambahan yang disimpan dalam ingatan;

dan kaedah yang memerlukan memori tambahan untuk menyimpan salinan fail yang sedang diisih.

Kestabilan- satu lagi ciri penting kaedah pengisihan. Kaedah pengisihan dipanggil stabil, jika ia mengekalkan susunan relatif rekod dengan kunci yang sama. Sebagai contoh, jika senarai abjad kumpulan diisih mengikut gred, kaedah stabil mencipta senarai di mana nama pelajar dengan gred yang sama akan disusun mengikut abjad, dan kaedah tidak stabil akan membuat senarai di mana susunan asal mungkin dilanggar. Kebanyakan kaedah mudah adalah stabil, manakala kaedah yang paling terkenal kaedah yang kompleks- Tidak. Jika kestabilan diperlukan, ia boleh dicapai dengan menambahkan indeks kecil pada kunci sebelum mengisih atau dengan memanjangkan kunci dalam beberapa cara. Kestabilan mudah diterima sebagai norma; orang ramai melayan ketidakstabilan dengan rasa tidak percaya. Pada hakikatnya, beberapa kaedah mencapai kestabilan tanpa menggunakan masa atau ruang tambahan.

Program berikut, untuk menyusun tiga rekod, bertujuan untuk menggambarkan konvensyen asas yang akan kami gunakan. khususnya, program utama ingin tahu kerana ia hanya berfungsi untuk N=3; Intinya ialah mana-mana program pengisihan boleh dikurangkan kepada prosedur isihan3 program ini.

Tiga penyata tugasan, setiap satu diikuti oleh pengendali jika, sebenarnya, mereka melaksanakan operasi "pertukaran". Kami menampalnya terus ke dalam kod program bukannya menggunakan panggilan prosedur, kerana ia adalah asas kepada banyak algoritma dan selalunya termasuk dalam gelung.

Untuk memfokuskan pada isu algoritma, kami akan bekerja dengan algoritma yang hanya mengisih tatasusunan integer dalam susunan berangka. Secara umum, sangat mudah untuk menyesuaikan algoritma sedemikian kegunaan praktikal, yang termasuk bekerja dengan kunci atau rekod yang besar. Pada asasnya, program pengisihan berfungsi dengan rekod dalam dua cara: sama ada ia membandingkan dan mengisih kunci sahaja, atau ia memindahkan keseluruhan rekod. Kebanyakan algoritma yang akan kita kaji boleh digunakan, dengan merumuskannya semula dari segi dua operasi ini, untuk rekod sewenang-wenangnya. Jika rekod yang diisih agak besar, adalah perkara biasa untuk cuba mengelak daripada mengalihkannya melalui "isihan tidak langsung": ini tidak menyusun semula rekod itu sendiri, sebaliknya menyusun semula tatasusunan penunjuk (indeks) supaya penunjuk pertama menunjuk ke unsur terkecil, dan seterusnya. Kekunci boleh disimpan sama ada dengan rekod (jika ia besar) atau dengan penunjuk (jika ia kecil). Jika perlu, anda boleh menyusun semula rekod selepas mengisih. Ini diterangkan di bawah.

Program isihan3 menggunakan lebih banyak lagi akses terhad ke fail: ini adalah tiga operasi dalam bentuk "bandingkan dua rekod dan tukarkannya, jika perlu, untuk meletakkan rekod dengan kunci yang lebih kecil di tempat pertama." Program yang terhad kepada operasi sedemikian adalah menarik kerana ia sesuai untuk dilaksanakan pada tahap perkakasan. Kami akan mengkajinya dengan lebih terperinci kemudian.

Semua program sampel digunakan untuk menyusun tatasusunan global. Ini tidak bermakna pendekatan ini lebih baik atau lebih teruk daripada menghantar tatasusunan sebagai parameter. Semuanya bergantung pada sudut pandangan dan algoritma tertentu. Tatasusunan dibuat secara global sahaja kerana contoh menjadi lebih pendek dan jelas.

Isih mengikut pilihan Salah satu kaedah pengisihan paling mudah berfungsi seperti ini: cari elemen terkecil dalam tatasusunan dan tukarkannya dengan elemen di tempat pertama. Kemudian kami mengulangi proses dari kedudukan kedua dalam fail dan menukar elemen yang ditemui dengan elemen kedua dan seterusnya sehingga keseluruhan tatasusunan diisih. Kaedah ini dipanggil jenis pemilihan, kerana ia berfungsi dengan memilih unsur terkecil yang tinggal secara kitaran, seperti yang ditunjukkan dalam Rajah 1. Pada laluan pertama, aksara ruang pergi dahulu, bertukar dengan huruf `P'. Pada hantaran kedua, elemen `B' ditukar dengan elemen `P', dan seterusnya .Program berikut memberikan pelaksanaan lengkap proses ini.Untuk setiap i dari 1 hingga N- 1 , ia menukar unsur terkecil dari [ i..N] dengan [ i]:Semasa penunjuk bergerak i dari kiri ke kanan melalui fail, unsur-unsur di sebelah kiri penuding sudah berada di kedudukan terakhirnya (dan tidak akan disentuh lagi), jadi tatasusunan akan diisih sepenuhnya pada masa penuding mencapai tepi kanan. Kaedah ini adalah salah satu yang paling mudah, dan ia berfungsi sangat baik untuk fail kecil. "Gelung dalam"nya terdiri daripada membandingkan a[ i]min] (ditambah kod yang diperlukan untuk meningkatkan j dan menyemak bahawa ia tidak melebihi N), yang tidak dapat dipermudahkan lagi. Selain itu, walaupun isihan pemilihan ialah kaedah kekerasan, ia mempunyai aplikasi yang sangat penting: memandangkan setiap elemen dialihkan paling banyak sekali, ia sangat bagus untuk rekod besar dengan kekunci kecil. Isihan sisipan Kaedah menyusun masukkan, hampir semudah jenis pemilihan, tetapi lebih fleksibel. Kaedah ini sering digunakan semasa mengisih kad: kami mengambil satu elemen dan memasukkannya ke tempat yang betul antara yang telah kami proses (sehingga meninggalkannya diisih). Elemen yang dimaksudkan dimasukkan ke dalam kedudukan dengan mengalihkan elemen yang lebih besar satu kedudukan ke kanan dan kemudian meletakkan elemen yang lebih kecil pada kedudukan yang dikosongkan, seperti yang ditunjukkan dalam Rajah 2. Jadi `I" pada langkah ketiga adalah lebih kecil daripada semua elemen yang diisih lain, jadi kami "menenggelamkannya" ke permulaan tatasusunan. `M " adalah lebih besar daripada `I" tetapi kurang daripada semua yang lain, jadi kami meletakkannya di antara `I' dan `P', dan seterusnya. Proses ini dilaksanakan dalam program berikut. Untuk setiap i dari 2 hingga N, subarray a diisih dengan meletakkan a[ i] ke kedudukan yang sesuai di kalangan elemen yang telah diisih: Seperti dengan isihan pemilihan, semasa mengisih unsur di sebelah kiri penuding i sudah dalam susunan yang diisih, tetapi tidak semestinya mereka berada di kedudukan terakhir mereka, kerana mereka masih boleh dialihkan ke kanan untuk memasukkan elemen yang lebih kecil yang ditemui kemudian. Tatasusunan menjadi diisih sepenuhnya apabila penuding mencapai tepi kanan. Walau bagaimanapun, terdapat satu butiran yang lebih penting: atur cara sisipan tidak selalu berfungsi kerana sementara boleh melompat ke atas tepi kiri tatasusunan apabila v- elemen terkecil tatasusunan. Untuk membetulkan keadaan, kami meletakkan kunci "pengawal" dalam a, menjadikannya sekurang-kurangnya tidak lebih besar daripada kunci terkecil dalam tatasusunan. Anjing pemerhati biasanya digunakan dalam situasi seperti ini untuk mengelakkan pemeriksaan tambahan (masuk dalam kes ini j>0), yang hampir selalu membantu dalam gelung dalam. Isih gelembung Kaedah pengisihan asas yang sering diberikan pada kelas pengenalan- Ini jenis gelembung: Elemen tatasusunan bersebelahan ditukar selagi pasangan tidak diisih ditemui. Pelaksanaan kaedah ini diberikan di bawah. Ia mungkin mengambil sedikit masa untuk mempercayai bahawa ia benar-benar berkesan. Untuk melakukan ini, perhatikan bahawa apabila kita menemui elemen maksimum semasa hantaran pertama, kita menukarnya dengan setiap elemen di sebelah kanannya sehingga ia berada di kedudukan paling kanan. Pada pas kedua, kami meletakkan elemen maksimum kedua dalam kedudukan kedua terakhir, dan seterusnya. Isih gelembung berfungsi dengan cara yang sama seperti isihan pemilihan, walaupun ia melakukan lebih banyak lagi kerja lebih untuk memindahkan elemen ke kedudukan terakhirnya. Ciri-ciri jenis yang paling mudahHarta 1 Isih pemilihan menggunakan tentang perbandingan dan pertukaran N.Harta 2Isihan sisipan menggunakan tentang perbandingan dan pertukaran secara purata, dan dua kali lebih banyak dalam kes terburuk.Hartanah 3 Isih gelembung menggunakan lebih kurang. perbandingan dan pertukaran dalam kes purata dan terburuk.Harta benda 4 Isihan sisipan adalah linear untuk fail "hampir diisih".Harta 5 Isih pemilihan adalah linear untuk fail dengan rekod besar dan kekunci kecil.Menyusun fail dengan rekod besar Selalunya adalah mungkin (dan wajar) untuk memastikan bahawa apabila menyusun fail yang terdiri daripada elemen N, menggunakan sebarang kaedah, hanya operasi pertukaran N dilakukan. rekod penuh dengan menangani secara tidak langsung elemen tatasusunan (menggunakan tatasusunan indeks atau penunjuk), dan melakukan penyusunan semula itu sendiri selepas itu. Lebih khusus lagi: jika tatasusunan a mengandungi entri yang besar, maka kita akan lebih suka menggunakan tatasusunan penunjuk p untuk mengetahui di mana elemen seterusnya tatasusunan a terletak, dan untuk melakukan pertukaran pseudo. Di bawah ialah atur cara isihan sisipan menggunakan tatasusunan penunjuk: Untuk mengelakkan kawalan yang tidak perlu dalam gelung, atur cara sekali lagi menggunakan elemen "menonton". Pada mulanya, indeks adalah teratur. Kemudian susunan indeks mula berubah supaya tatasusunan a, dibaca mengikut susunan indeks dibaca, disusun.

Untuk ini kita boleh gunakan prosedur berikut, yang menyusun rekod fail secara fizikal menggunakan pilih atur N:

Isih cangkerang Isihan sisipan adalah perlahan kerana ia hanya menukar elemen bersebelahan. Isih shell ialah lanjutan termudah bagi jenis sisipan, yang meningkatkan kelajuan algoritma kerana ia membolehkan anda bertukar-tukar elemen yang jauh antara satu sama lain. Idea utama algoritma adalah untuk mengisih semua kumpulan a fail yang terdiri daripada elemen fail yang dijarakkan antara satu sama lain mengikut jarak h . Fail sedemikian dipanggil h-sorted. Apabila kita h-isih fail dengan beberapa h besar, kita menggerakkan elemennya pada jarak yang jauh. Ini menjadikan kerja pengisihan lebih mudah untuk nilai h yang lebih kecil. Proses ini berakhir apabila h berkurangan kepada 1.

Atur cara di atas menggunakan jujukan... 1093, 364, 121, 40, 13, 4, 1. Mungkin terdapat jujukan lain - ada yang lebih baik, yang lain lebih teruk.

Harta 6Isih Shell tidak pernah melakukan lebih daripada N1.5 perbandingan bagi urutan di atas h.

Pengiraan pengedaran Dalam banyak kes, kita tahu bahawa nilai utama dalam fail terletak dalam julat tertentu. Dalam situasi ini, algoritma yang dipanggil pengiraan pengedaran boleh digunakan. Berikut ialah program untuk algoritma mudah ini.

8 Isihan sisipan

9 A N Biarkan perlu untuk mengisih tatasusunan A dalam tertib menaik, di mana unsur N dimasukkan menggunakan kaedah sisipan. Pembolehubah bantu j j ialah nombor unsur pertama bagi baki. i i – nombor unsur yang digerakkan. f f=1 f – syarat untuk keluar dari gelung (jika f=1, maka keluar) Val Val – nilai perantaraan yang digunakan untuk memindahkan elemen tatasusunan Pernyataan masalah

A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma." title="10 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A [i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma." class="link_thumb"> 10 !} 10 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah Langkah Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah Langkah i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma."> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:= i- 1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma."> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma." title="10 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A [i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma."> title="10 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma."> !}

A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Apakah yang "title="11 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A> A[ i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j :=j+1. Tamat algoritma. Apakah maksudnya?" class="link_thumb"> 11 !} 11 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah Langkah Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah Langkah i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Apakah maksudnya syarat ini? A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Apakah maksud "> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i- 1 , Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Apakah maksud keadaan ini?"> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Apakah yang "title="11 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A> A[ i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j :=j+1. Tamat algoritma. Apakah maksudnya?"> title="11 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Apakah maksudnya"> !}

A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa bermula" title="12 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A> A[ i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j :=j+1. Tamat algoritma. Mengapa bermula" class="link_thumb"> 12 !} 12 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah Langkah Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah Langkah i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapakah nilai permulaan j =2? A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa bermula"> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1 , Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa nilai permulaan j =2 ? "> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa bermula" title="12 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A> A[ i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j :=j+1. Tamat algoritma. Mengapa bermula"> title="12 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa bermula"> !}

A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa bermula" title="13 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A> A[ i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j :=j+1. Tamat algoritma. Mengapa bermula" class="link_thumb"> 13 !} 13 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah Langkah Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah Langkah i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapakah nilai permulaan i =2? A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa bermula"> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1 , Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa nilai permulaan i =2 ? "> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa bermula" title="13 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A> A[ i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j :=j+1. Tamat algoritma. Mengapa bermula"> title="13 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Mengapa bermula"> !}

A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah ia sentiasa benar" title="14 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A [i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah ia sentiasa benar" class="link_thumb"> 14 !} 14 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah Langkah Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah Langkah i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah elemen input j sentiasa bertukar dengan elemen yang diisih? A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah selalu "> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i- 1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah elemen input j sentiasa bertukar dengan elemen yang diisih?"> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah ia sentiasa benar" title="14 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A [i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah ia sentiasa benar"> title="14 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah sentiasa mungkin untuk"> !}

A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah mungkin untuk" title="15 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A [i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah mungkin dalam" class="link_thumb"> 15 !} 15 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah Langkah Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah Langkah i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah mungkin untuk menggantikan gelung BYE dan IF dengan satu gelung BYE dengan keadaan i>=2 dan A>A[i] ? A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah mungkin untuk "> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i - 1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah mungkin untuk menggantikan gelung BYE dan IF dengan satu gelung BYE dengan keadaan i>=2 dan A>A[i] ?> A [i] kemudian Val:= A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah mungkin untuk" title="15 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A [i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah mungkin dalam"> title="15 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Adakah mungkin untuk"> !}

A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Untuk apa" title="16 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A [i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Untuk apa?" class="link_thumb"> 16 !} 16 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Semasa j=2 dan f=0 melakukan: Langkah Langkah Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah Langkah i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Untuk apa operator ini? A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Untuk apa"> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i - 1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Untuk apa operator ini? "> A[i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Untuk apa" title="16 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A [i] kemudian Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Untuk apa?"> title="16 Permulaan algoritma. Langkah 1 Langkah 1 j:=2, Langkah 2 Langkah 2 Manakala j=2 dan f=0 lakukan: Langkah 2.2.1 Langkah 2.2.1 Jika A>A[i] maka Val:=A; A:=A[i]; A[i]:=Val, jika tidak f:=1, Langkah 2.2.2 Langkah 2.2.2 i:=i-1, Langkah 2.3 Langkah 2.3 j:=j+1. Tamat algoritma. Untuk apa ia diperlukan"> !}

18 Intipati pengisihan: Unsur dengan nilai terendah dan ia ditukar dengan elemen pertama tatasusunan. Kemudian unsur dengan nilai terkecil daripada unsur n-1 yang tinggal dijumpai dan ia ditukar dengan unsur kedua, dsb. sebelum menukar dua elemen terakhir.

Isih pilihan Bahagian yang diisih Bahagian yang diisih Tatasusunan dalam tertib menaik

20 Pernyataan masalah A N Biarkan anda perlu mengisih tatasusunan A dalam tertib menaik, di mana terdapat N elemen mengikut pemilihan. Pembolehubah bantu j j – nombor unsur pertama bagi baki. i i – nombor unsur yang digerakkan. min min – nombor minimum dalam tatasusunan. Imin Imin – nombor nombor minimum dalam tatasusunan

25 Intipati pengisihan: Tatasusunan diimbas secara berurutan dan setiap pasangan elemen dibandingkan antara satu sama lain. Dalam kes ini, susunan unsur yang "salah" dihapuskan dengan menyusun semulanya. Proses melihat dan membandingkan elemen diulang sehingga keseluruhan tatasusunan telah dilihat.

26 Isih mengikut pertukaran

27 A N Biarkan ianya perlu untuk mengisih tatasusunan A dalam tertib menaik, di mana N elemen ditukar menggunakan kaedah pertukaran Pembolehubah tambahan j j – nombor elemen pertama bagi baki. i i – nombor unsur yang digerakkan. Val Val ialah nilai perantaraan yang digunakan untuk memindahkan elemen tatasusunan. Pernyataan masalah

2 melaksanakan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Perbandingan jiran" title="28 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 melaksanakan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Perbandingan jiran" class="link_thumb"> 28 !} 28 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah Langkah i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Perbandingan unsur jiran Tukar elemen jiran jika yang kiri lebih besar daripada yang kanan. Bahagian yang diisih terbentuk =2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Bandingkan jiran "> =2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Perbandingan unsur jiran Tukar elemen jiran, jika yang kiri lebih besar daripada yang kanan. Bahagian yang disusun terbentuk "> =2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Perbandingan jiran" title="28 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 melaksanakan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Perbandingan jiran"> title="28 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Perbandingan jiran"> !}

2 melaksanakan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapakah syarat "title="29 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Manakala j>=2 melaksanakan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1 Akhir algoritma Mengapa keadaannya sama?" class="link_thumb"> 29 !} 29 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah Langkah i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Kenapa syarat ini? =2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapa syarat ta"> =2 dipenuhi: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2. 2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapa keadaannya begini?"> =2 lakukan: Langkah 2.1 Langkah 2.1 i:=1 ;, Langkah 2.2 Langkah 2.2 Buat masa ini iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapakah syarat "title="29 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Manakala j>=2 melaksanakan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1 Akhir algoritma Mengapa keadaannya sama?"> title="29 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Kenapa syaratnya sama?"> !}

2 melaksanakan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapakah nilai j" title="30 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 melakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j- 1. Akhir algoritma Mengapakah nilai j" class="link_thumb"> 30 !} 30 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah Langkah i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapakah nilai j berkurangan? Adakah mungkin untuk meningkatkannya? Apa yang perlu diubah? =2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapakah nilai j"> =2 dilakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2. 2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapakah nilai j berkurangan? Bolehkah ia dinaikkan? Apa yang perlu diubah?"> =2 lakukan: Langkah 2.1 Langkah 2.1 i: =1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapakah nilai j" title="30 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 melakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j- 1. Akhir algoritma Mengapakah nilai j"> title="30 Permulaan algoritma. Langkah 1 Langkah 1 j:=N, Langkah 2 Langkah 2 Semasa j>=2 lakukan: Langkah 2.1 Langkah 2.1 i:=1;, Langkah 2.2 Langkah 2.2 Manakala iA kemudian Val:=A[i]; A[i]:=A; A:=Val, Langkah 2.2.2 Langkah 2.2.2 i=i+1, Langkah 2.3 Langkah 2.3 j:=j-1. Tamat algoritma. Mengapakah nilai j"> !}

35 12 Langkah pengisihan cangkerang. 4 kumpulan 2 elemen langkah. 2 kumpulan 4 unsur

36 Langkah pengisihan cangkerang. 1 kumpulan daripada 8 elemen Tatasusunan disusun mengikut tertib menaik

37 A N Biarkan perlu untuk mengisih tatasusunan A dalam tertib menaik, di mana terdapat N elemen menggunakan kaedah Shell. Pembolehubah bantu j j ialah nombor elemen pertama bagi baki. i i – nombor unsur yang digerakkan. M M- langkah optimum P P – nilai perantaraan yang digunakan untuk menggerakkan elemen tatasusunan Pernyataan masalah

45 Intipati pengisihan: Nilai tertentu (x) dipilih - elemen penghalang, yang ditentukan dengan membundarkan kepada pembahagian integer bagi bilangan elemen yang diisih dengan 2; Kami melintasi tatasusunan, bergerak dari kiri ke kanan, sehingga kami menjumpai elemen yang lebih besar daripada x. Kemudian kami melintasinya dari kanan ke kiri, sehingga kami menemui elemen yang kurang daripada x.

46 Intipati pengisihan: Tukar elemen yang ditemui. Jika unsur terbesar atau terkecil tidak ditemui, unsur tengah ditukar dengan unsur terbesar atau terkecil ditemui; Setelah sampai ke tengah kita mempunyai 2 bahagian tatasusunan; Proses berterusan untuk setiap bahagian sehingga tatasusunan diisih

7 dipindahkan ke sebelah kanan, kerana 16>7 tidak boleh dipindah milik, 47 boleh dipindahkan ke sebelah kanan, kerana 16>7, 8>7,11>7, 19>7 tidak boleh dipindah milik, 7=7 penyair" title="(!LANG :47 Isih pantas 812371911416 Elemen halangan 4378123 4 Elemen halangan 8121119 Elemen halangan 1219 1619 8>7 dialihkan ke sebelah kanan, kerana 16>7 tidak dipindahkan, 47 dialihkan ke sebelah kanan, kerana 16>7,11> >7, 19>7 tidak tertanggung, 7=7 penyair" class="link_thumb"> 47 !} 47 Isih pantas Elemen halangan Elemen halangan Elemen halangan >7 dialihkan ke sebelah kanan, kerana 16>7 tidak dipindahkan, 47 dialihkan ke sebelah kanan, kerana 16>7, 8>7,11>7, 19> 7 tidak boleh dipindah milik, 7=7 oleh itu kita menukar 7 dan 12 4>3 Bahagian yang diisih 12>11 dipindahkan ke sebelah kanan, kerana >11 tidak boleh dipindah milik, 811 dipindahkan ke sebelah kanan, kerana 16>11, 12 >11,tidak boleh dipindah milik, 11 11=11 jadi kita menukar 11 dan 19 Bahagian yang diisih 19>12 dipindahkan ke sebelah kanan, kerana 16>12,tidak boleh dipindah milik, 12 12=12 jadi kita menukar 12 dan 19 19> 16 Tatasusunan diisih dalam tertib menaik Kurang daripada sama dengan 7 Lebih besar daripada 7 Kami bergerak 7 ke sebelah kanan, kerana 16>7 tidak boleh dipindah milik, 47 dipindahkan ke sebelah kanan, kerana 16>7, 8>7,11>7, 19>7 tidak boleh dipindah milik, 7=7 penyair"> Kami bergerak 7 ke sebelah kanan, kerana 16>7 tidak boleh dipindah milik, 47 dipindahkan ke sebelah kanan, kerana 16>7, 8>7,11>7, 19>7 tidak boleh dipindah milik, 7=7, jadi kita tukar tempat 7 dan 12 4>3 Bahagian yang diisih 12>11 dipindahkan ke sebelah kanan, kerana 8 12 16>11 tidak boleh dipindah milik, 811 dipindahkan ke sebelah kanan, kerana 16>11, 12>11 tidak boleh dipindah milik , 11 11=11 jadi kita menukar 11 dan 19 Bahagian yang diisih 19>12 dialihkan ke sebelah kanan, kerana 16>12 tidak boleh dipindah milik, 12 12=12 jadi kita menukar 12 dan 19 19>16 Tatasusunan diisih dalam tertib menaik Kurang bersamaan 7 Lebih besar daripada 7"> 7 dipindahkan ke sebelah kanan, kerana 16>7 tidak boleh dipindah milik, 47 dipindahkan ke sebelah kanan, kerana 16>7, 8>7,11>7, 19>7 tidak boleh dipindah milik, 7=7 penyair" title="47 Isih cepat 812371911416 Elemen penghalang 4378123 4 Elemen penghalang 8121119 Elemen penghalang 1219 1619 8>7 dialihkan ke sebelah kanan, kerana 16>7 tidak boleh dipindahkan, 47 dialihkan ke sebelah kanan , kerana 16>7, 8>7,11>7, 19>7 tidak boleh diterima, 7=7 penyair"> title="47 Isih pantas 812371911416 Elemen penghalang 4378123 4 Elemen penghalang 8121119 Elemen penghalang 1219 1619 8>7 dialihkan ke sebelah kanan, kerana 16>7 tidak boleh dipindahkan, 47 dialihkan ke sebelah kanan, kerana 8>16>7, . 11>7, 19>7 tidak dapat ditanggung, 7=7 penyair"> !}

48 A n Biarkan anda perlu mengisih tatasusunan A dalam tertib menaik, di mana terdapat n elemen kaedah cepat Pembolehubah bantu: t – t – unsur akhir tatasusunan m - m ialah elemen awal tatasusunan x – x ialah unsur relatif kepada mana semua elemen lain dipindahkan. w – w – nilai perantaraan yang digunakan untuk memindahkan elemen tatasusunan Pernyataan masalah

58 Kestabilan - tatasusunan yang diisih tidak mengubah susunan unsur daripada nilai yang sama. Kedudukan relatif elemen yang sama dengan kunci 1 dan medan tambahan Parameter penilaian algoritma "a", "b", "c".

59 Kelakuan semula jadi - keberkesanan kaedah apabila memproses data yang telah diisih atau sebahagiannya diisih. Algoritma bertindak secara semula jadi jika ia mengambil kira ciri urutan input ini dan berfungsi parameter yang lebih baik penilaian algoritma

60 Penilaian algoritma isihan pemilihan Jumlah bilangan perbandingan C =N-l + N = (N 2 -N)/2 Jumlah bilangan operasi n + (n-1) + (n-2) + (n-3) = 1 /2 * ( n 2 +n) = Theta(n 2) Bilangan pertukaran

63 Menilai Algoritma Isih Sisipan Tatasusunan memerlukan perbandingan N-1. Tatasusunan memerlukan perbandingan (N 2 -N)/2. Jumlah bilangan operasi Theta(n 2)

66 Tidak kaedah yang berkesan, memandangkan kemasukan elemen dikaitkan dengan peralihan semua elemen sebelumnya dengan satu kedudukan, dan operasi ini tidak ekonomik. Jika digabungkan, kestabilan dan kelakuan semula jadi algoritma menjadikan kaedah Pilihan baik dalam situasi yang sesuai

70 Perbandingan kaedah pengisihan mudah N N – bilangan elemen, M M – bilangan pemindahan, C – bilangan perbandingan MinimumMaksimum Kemasukan mudah M=2(n-1) C = n-1 M=2(n-1) C=( n 2 -n)/2 М=(n+3n-4)/2 М=(n 2 +3n-4)/2 Pertukaran mudah C=(n 2 -n)/2M=3(n-1) С =(n 2 -n)/2 М=n/4+3(n-1) М=n 2 /4+3(n-1) Pilihan mudah C=(n 2 -n)/2 M = 0 С =(n 2 -n)/2 М=(n-n)*1.5 М=(n 2 -n)*1.5? Apakah bilangan pemindahan?

72 Penilaian algoritma Shell n 1.2 Masa pelaksanaan adalah berkadar dengan n 1.2, kerana setiap pas menggunakan bilangan kecil elemen atau elemen tatasusunan sudah berada dalam susunan relatif, dan pesanan meningkat dengan setiap paparan baharu data

73 Menilai Algoritma Isih Pantas N=2g X N N/2N/2 Jika saiz tatasusunan ialah kuasa dua nombor (N=2g), dan setiap pecahan meletakkan elemen X tepat di tengah tatasusunan, maka pada pandangan pertama , N perbandingan dibuat dan tatasusunan dibahagikan kepada dua bahagian berukuran N/2. Bagi setiap bahagian ini terdapat N/2 perbandingan, dsb. Oleh itu C=N+2*(N/2)+4*(N/4)+...+N*(N/N). N Jika N bukan kuasa dua, maka anggaran akan menjadi susunan yang sama

74 Theta(n). Jumlah bilangan operasi Theta(n). log n O(n log n) Bilangan langkah pembahagian (kedalaman rekursi) adalah lebih kurang log n jika tatasusunan dibahagikan kepada bahagian yang lebih kurang sama. Oleh itu, prestasi keseluruhan ialah: O(n log n) O(n 2) Jika setiap kali maksimum atau minimum urutan input dipilih sebagai elemen pusat, maka prestasinya ialah O(n 2)

77 Soalan kawalan? Apakah "menyisih"? ? Apakah kaedah pemilihan? ? Apakah kaedah isihan sisipan? ? Apakah kaedah isihan gelembung? ? Apakah kaedah isihan pantas? ? Apakah kaedah pengisihan Shell?

78 Soalan ujian? Algoritma pengisihan yang manakah dianggap paling mudah? ? Algoritma pengisihan yang manakah dianggap paling cekap? ? Berapakah bilangan kumpulan algoritma pengisihan yang ada? ? Dengan kriteria apakah algoritma pengisihan dicirikan? ? Apakah yang perlu anda pertimbangkan semasa memilih algoritma pengisihan?

Ia bukan sahaja tidak dianggap kaedah terpantas, malah ia menutup senarai kaedah pesanan paling lambat. Walau bagaimanapun, ia juga mempunyai kelebihannya. Jadi, pengisihan gelembung adalah penyelesaian yang paling logik dan semula jadi kepada masalah jika anda perlu menyusun elemen dalam susunan tertentu. Orang biasa secara manual, sebagai contoh, akan menggunakannya dengan tepat - hanya dengan gerak hati.

Dari mana datangnya nama luar biasa itu?

Nama kaedah itu dicipta menggunakan analogi dengan gelembung udara di dalam air. Ini adalah metafora. Sama seperti gelembung udara kecil naik ke atas - lagipun, ketumpatannya lebih besar daripada sebarang cecair (dalam kes ini, air), jadi setiap elemen tatasusunan, semakin kecil nilainya, semakin ia beransur-ansur jalan ke permulaan senarai nombor.

Penerangan tentang algoritma

Isih gelembung berfungsi seperti ini:

hantaran pertama: elemen tatasusunan nombor diambil dua pada satu masa dan juga dibandingkan secara berpasangan. Jika dalam beberapa pasangan elemen nilai pertama lebih besar daripada yang kedua, program menukarnya;
oleh itu berakhir pada penghujung tatasusunan. Walaupun semua elemen lain kekal seperti sedia ada, dalam susunan yang huru-hara dan memerlukan pengisihan selanjutnya;
itulah sebabnya pas kedua diperlukan: ia dilakukan dengan analogi dengan yang sebelumnya (sudah diterangkan) dan mempunyai bilangan perbandingan - tolak satu;
Petikan nombor tiga mempunyai satu perbandingan yang lebih sedikit daripada yang kedua, dan dua kurang daripada yang pertama. Dan sebagainya;
Mari kita ringkaskan apa yang ada pada setiap pas (jumlah nilai dalam tatasusunan, nombor tertentu) tolak (nombor lulus) perbandingan.

Algoritma yang lebih pendek program masa hadapan boleh ditulis seperti ini:

tatasusunan nombor disemak sehingga mana-mana dua nombor ditemui, dan yang kedua daripadanya mestilah lebih besar daripada yang pertama;
Program menukar elemen tatasusunan yang diletakkan secara tidak betul berhubung antara satu sama lain.

Pseudokod berdasarkan algoritma yang diterangkan

Paling banyak pelaksanaan mudah dilakukan seperti ini:

Prosedur Sortirovka_Puzirkom;

Mulakan

gelung untuk j daripada indeks_permulaan sebelum ini konechii_index;

gelung untuk i daripada indeks_permulaan sebelum ini konechii_index-1;

Jika massiv[i]>massiv

(tukar nilai);

tamat

Sudah tentu, di sini kesederhanaan hanya memburukkan keadaan: daripada algoritma yang lebih mudah, terutamanya kerana semua kekurangan muncul di dalamnya. Penggunaan masa terlalu besar walaupun untuk tatasusunan yang kecil (relativiti memainkan peranan di sini: untuk orang biasa, jumlah masa mungkin kelihatan kecil, tetapi dalam perniagaan seorang pengaturcara, setiap saat atau bahkan milisaat dikira).

Pelaksanaan yang lebih baik diperlukan. Sebagai contoh, dengan mengambil kira pertukaran nilai dalam tatasusunan:

Prosedur Sortirovka_Puzirkom;

Mulakan

sortirovka = benar;

kitaran setakat ini sortirovka = benar;

sortirovka = palsu;

gelung untuk i daripada indeks_permulaan sebelum ini konechii_index-1;

Jika massiv[i]>massiv(elemen pertama lebih besar daripada yang kedua), maka:

(tukar elemen);

sortirovka = benar; (menunjukkan bahawa pertukaran telah dibuat).

tamat.

Kelemahan kaedah

Kelemahan utama adalah tempoh proses. Berapa lama masa yang diambil untuk membuat gelembung?

Masa pelaksanaan dikira daripada kuasa dua bilangan nombor dalam tatasusunan - hasil akhir adalah berkadar dengannya.

Dalam senario kes terburuk, tatasusunan akan dilalui bilangan kali yang sama kerana terdapat elemen di dalamnya tolak satu nilai. Ini berlaku kerana akhirnya hanya ada satu elemen yang tinggal tanpa sebarang perbandingan, dan laluan terakhir melalui tatasusunan menjadi tindakan yang tidak berguna.

Di samping itu, kaedah pengisihan adalah berkesan pertukaran mudah, kerana ia juga dipanggil, adalah untuk tatasusunan sahaja saiz kecil. Ia tidak akan dapat memproses sejumlah besar data dengan bantuannya: hasilnya akan menjadi sama ada ralat atau kegagalan program.

Kelebihan

Bubble sort agak mudah untuk difahami. DALAM program pendidikan Universiti teknikal mengambilnya dahulu apabila mengkaji susunan elemen tatasusunan. Kaedah ini mudah dilaksanakan baik dalam bahasa pengaturcaraan Delphi(D (Delphi) dan C/C++ (C/C plus plus), algoritma yang sangat mudah untuk mengatur nilai dalam susunan yang betul dan Bubble Sort sesuai untuk pemula.

Oleh kerana kekurangannya, algoritma tidak digunakan untuk tujuan ekstrakurikuler.