Artikel ini membincangkan beberapa algoritma pengisihan yang paling popular untuk tatasusunan, digunakan secara praktikal dan untuk tujuan pendidikan. Saya ingin membuat tempahan dengan segera bahawa semua algoritma yang dipertimbangkan adalah lebih perlahan daripada kaedah klasik untuk mengisih tatasusunan melalui senarai nilai, tetapi bagaimanapun, ia patut diberi perhatian. Terdapat banyak teks, jadi untuk setiap algoritma saya menerangkan yang paling asas.
1. Algoritma "Isih mengikut pilihan".
Ia adalah salah satu algoritma pengisihan tatasusunan yang paling mudah. Ideanya adalah untuk melalui tatasusunan dan setiap kali mencari elemen minimum tatasusunan, menukarnya dengan elemen permulaan bahagian tatasusunan yang tidak diisih. Pada tatasusunan kecil ia mungkin lebih berkesan daripada algoritma pengisihan yang lebih kompleks, tetapi dalam apa jua keadaan ia kalah pada tatasusunan besar. Bilangan pertukaran elemen berbanding dengan algoritma "gelembung" ialah N/2, di mana N ialah bilangan elemen tatasusunan.
Algoritma:
1. Cari elemen minimum dalam tatasusunan.
2. Tukar elemen minimum dan pertama.
3. Sekali lagi kita mencari elemen minimum dalam bahagian tatasusunan yang tidak diisih
4. Tukar elemen kedua tatasusunan dan yang minimum ditemui, kerana elemen pertama tatasusunan ialah bahagian yang diisih.
5. Kami mencari nilai minimum dan swap elemen sehingga tatasusunan diisih hingga akhir.
//Isih mengikut pemilihan (--- Fungsi Isih mengikut Pemilihan(Susun Nilai) Min = 0; Untuk i = 0 Mengikut Array.VBoundary() Gelung Min = i; Untuk j = i + 1 Mengikut Array.VBoundary() Gelung / /Cari elemen minimum dalam tatasusunan If Array[j]< Массив[Мин] Тогда Мин = j; КонецЕсли; КонецЦикла; Если Массив [Мин] = Массив [i] Тогда //Если мин. элемент массива = первому элементу неотс. части массива, то пропускаем. Продолжить; КонецЕсли; Смена = Массив[i]; //Производим замену элементов массива. Массив[i] = Массив[Мин]; Массив[Мин] = Смена; КонецЦикла; Возврат Массив; КонецФункции
2. Algoritma "Isih gelembung".
Mungkin algoritma yang paling terkenal, digunakan untuk tujuan pendidikan, terlalu lambat untuk kegunaan praktikal. Algoritma ini mendasari algoritma yang lebih kompleks: "Isih shaker", "Isih piramid", "Isih cepat". Perlu diperhatikan bahawa salah satu algoritma terpantas, "Algoritma Pantas," telah dibangunkan dengan menaik taraf salah satu algoritma yang paling teruk, "Isih Buih." Jenis "Pantas" dan "Shaker" akan dibincangkan lebih lanjut. Maksud algoritma ialah elemen "paling ringan" dari tatasusunan "terapung", dan yang "paling berat" "tenggelam". Oleh itu nama "Isih Buih"
Algoritma:
1. Setiap elemen tatasusunan dibandingkan dengan yang seterusnya dan jika elemen[i] > elemen diganti. Oleh itu, elemen "paling ringan" "terapung" - bergerak ke permulaan senarai, dan "tenggelam" yang paling berat - bergerak ke penghujung.
2. Ulangi Langkah 1 n-1 kali, dengan n ialah Array.Kuantiti ().
//Isih Buih (--- Fungsi Isih Buih(Susun Nilai) Untuk i = 0 Mengikut Array.InBorder() Gelung Untuk j = 0 Mengikut Array.InBorder() - i - 1 Gelung Jika Tatasusunan[j] > Tatasusunan Kemudian Penggantian = Tatasusunan[j]; Tatasusunan[j] = Tatasusunan; Tatasusunan = Penggantian; EndIf; EndCycle; EndCycle; Return Array; EndFunction //---)
3. Algoritma "Isih Shaker" (Isih Kocok, Isih gelembung Dwiarah).
Algoritma ialah versi jenis sebelumnya - "isih gelembung". Perbezaan utama ialah dalam pengisihan gelembung klasik terdapat pergerakan satu arah elemen dari bawah ke atas, manakala dalam pengisihan shaker pergerakan pertama berlaku dari bawah ke atas, dan kemudian dari atas ke bawah.
Algoritma adalah sama seperti isihan gelembung + kitaran atas ke bawah ditambah.
Dalam contoh di bawah, terdapat peningkatan pada pengisihan shaker. Tidak seperti yang klasik, 2 kali lebih sedikit lelaran digunakan.
//Isih mengikut percampuran (Shaker-Isih) (--- Fungsi Isih mengikut Percampuran (Value Array) Untuk i = 0 OLEH Array.VBoundary()/2 Gelung nIter = 0; conIter = Array.VBoundary(); Manakala nIter Array [nIter+ 1] Kemudian Penggantian = Array[nIter]; Array[nIter] = Array[nIter + 1]; Array[nIter + 1] = Penggantian; EndIf; nIter = nIter + 1; // Gerakkan kedudukan satu langkah ke hadapan / / Lulus dengan hujung Jika Array[conIter - 1] > Array[conIter] Kemudian Penggantian = Array[conIter - 1]; Array[conIter-1] = Array[conIter]; Array[conIter] = Penggantian; EndIf; conIter = conIter - 1; // Gerakkan kedudukan satu langkah ke belakang EndCycle; EndCycle; Return Array; EndFunction //---)
4. Algoritma "Isih kerdil".
Algoritma itu dinamakan begitu aneh terima kasih kepada saintis Belanda Dick Grun.
Pengisihan Gnome adalah berdasarkan teknik yang digunakan oleh gnome taman Belanda biasa (tuinkabouter Belanda). Ini adalah kaedah yang mana gnome taman menyusun barisan pasu bunga. Pada asasnya dia melihat pasu taman seterusnya dan sebelumnya: jika ia berada dalam susunan yang betul, dia melangkah satu pasu ke hadapan, jika tidak, dia menukarnya dan melangkah satu pasu ke belakang. Syarat sempadan: jika tiada periuk sebelumnya, ia melangkah ke hadapan; jika tiada periuk seterusnya, ia sudah selesai.
Dick Grun
Itulah sebenarnya keseluruhan perihalan algoritma "Isih Kerdil". Menariknya, algoritma tidak mengandungi gelung bersarang, tetapi mengisih keseluruhan tatasusunan dalam satu laluan.
//Isih kerdil (--- Fungsi DwarvenSort(Susun Nilai) i = 1; j = 2; Manakala i< Массив.Количество() Цикл // Сравнение < - Сортировка по возрастанию, >- menurun Jika Tatasusunan i = j; j = j + 1; Penggantian Lain = Tatasusunan[i]; Tatasusunan[i] = Tatasusunan; Susunan = Penggantian; i = i - 1; Jika i = 0 Maka i = j; j = j + 1; endIf; endIf; EndCycle; Return Array; EndFunction //---)
5. Algoritma "Isihan sisipan".
Ini adalah algoritma pengisihan mudah. Intinya ialah pada setiap langkah kita mengambil elemen, cari kedudukan untuknya dan masukkannya ke tempat yang betul.
Contoh asas: Apabila bermain bodoh, anda menarik kad dari dek dan memasukkannya ke tempat yang sesuai dalam tertib menaik dalam kad yang anda miliki. Ataupun
di kedai mereka memberi anda pertukaran untuk 550 rubel - satu bil ialah 500, satu lagi ialah 50. Anda melihat ke dalam dompet anda, dan terdapat bil dalam denominasi 10,100,1000. Anda masukkan bil
bernilai 50 rubel. antara wang kertas 10r dan 100r, dan wang kertas 500 ruble antara wang kertas 100r dan 1000r. Ternyata 10,50,100,500,1000 - Ini dia
dan algoritma Isih Sisipan.
Oleh itu, dengan setiap langkah algoritma, anda perlu mengisih subarray data dan memasukkan nilai ke tempat yang betul.
//Isih Sisipan (--- Isih Sisipan Fungsi(Susun Nilai) Untuk i = 0 Mengikut Tatasusunan.BBorder()-1 Kunci Gelung = i + 1; Ganti = Tatasusunan[Kunci]; j = i + 1; Manakala j > 0 Dan Penggantian< Массив Цикл Массив[j] = Массив; Замена = j - 1; Ключ = j - 1; j = j - 1; КонецЦикла; Массив[Ключ] = Замена; КонецЦикла; Возврат Массив; КонецФункции //---}
6. Algoritma "Isih Gabung".
Algoritma yang menarik dari segi pelaksanaan dan idea. Maksudnya ialah untuk membahagikan tatasusunan kepada subarray sehingga panjang setiap subarray adalah sama dengan 1. Kemudian kami mendakwa bahawa subarray tersebut diisih. Kemudian kami menggabungkan subarray yang terhasil bersama-sama, pada masa yang sama membandingkan dan mengisih nilai elemen subarray demi elemen.
p/s Saya tidak dapat memasukkan lukisan di sini dengan gambar rajah yang lebih visual, ia sentiasa comot. Tetapi ia jelas kelihatan dalam blok tangkapan skrin di bawah. Anda boleh melihat bagaimana algoritma berfungsi.
//Gabung isihan (---
Fungsi MergeSort(Value Array) Jika Array.Count() = 1 Kemudian Kembalikan Array; endIf; PointBreak = Array.Count() / 2; lArray = Susunan Baharu; prArray = Tatasusunan Baru; Untuk Kiraan = 0 OLEH Array.VBoundary() Kitaran Jika Kira< ТочкаРазрыв Тогда лМассив.Добавить(Массив[Сч]); Иначе прМассив.Добавить(Массив[Сч]); КонецЕсли; КонецЦикла; Возврат Слияние(СортировкаСлиянием(лМассив),СортировкаСлиянием(прМассив)); КонецФункции Функция Слияние(массив1,массив2) a = 0; b = 0; слМассив = Новый Массив; Для Сч = 0 ПО (Массив1.Количество() + Массив2.Количество())-1 Цикл слМассив.Добавить(); КонецЦикла; Для i = 0 ПО (массив1.Количество() + массив2.Количество())-1 Цикл Если b < массив2.Количество() И a < массив1.Количество() Тогда Если (массив1[a] >tatasusunan2[b]) DAN (b< массив2.Количество()) Тогда слМассив[i] = массив2[b]; b = b + 1; Иначе слМассив[i] = массив1[a]; a = a + 1; КонецЕсли; Иначе Если b < массив2.количество() Тогда слМассив[i] = массив2[b]; b = b + 1; Иначе слМассив[i] = массив1[a]; a = a + 1; КонецЕсли; КонецЕсли; КонецЦикла; Возврат слМассив; КонецФункции //---}
7. Algoritma "Pengisihan Shell".
Algoritma ini dinamakan sempena saintis Amerika Donald Schell. Pada terasnya, algoritma ini ialah algoritma Isih Sisipan yang dipertingkatkan. Inti algoritma adalah untuk membandingkan bukan sahaja elemen yang terletak bersebelahan, tetapi juga pada jarak tertentu. Pertama, Langkah dipilih - selang tertentu di mana elemen tatasusunan akan dibandingkan pada setiap lelaran. Ia biasanya ditakrifkan seperti ini:
Untuk lelaran pertama, Step = Object(Array.Quantity()/2), untuk lelaran berikutnya, Step = Object(Step/2). Itu. secara beransur-ansur langkah dikurangkan dan apabila langkah itu sama dengan 1 perbandingan terakhir akan berlaku dan tatasusunan akan diisih.
Contoh:
Diberi tatasusunan (10,5,3,1,14,2,7,12).
1. Langkah = 4.
Kami mengisih mengikut sisipan mudah setiap 4 kumpulan 2 elemen (10,14)(5,2)(3,7)(1,12)
10 ,2 ,3 ,1,14 ,5 ,7 ,12
2. Langkah = 2
Kami mengisih mengikut sisipan mudah setiap 2 kumpulan 4 elemen (10,3,14,7)(2,1,5,12)
3 ,1 ,7 ,2 ,10 ,5 ,14 ,12
3. Langkah = 1
Kami mengisih mengikut sisipan mudah setiap 1 kumpulan 8 elemen.
1,2,3,5,7,10,12,14
//Shell Sort (--- Function Shell Sort(Value Array) Step = Integer(Array.Quantity()/2); While Step > 0 Cycle i = 0; While i< (Массив.Количество() - Шаг) Цикл j = i; Пока j >= 0 DAN Tatasusunan[j] > Penggantian Gelung Tatasusunan = Tatasusunan[j]; Tatasusunan[j] = Tatasusunan; Susunan = Penggantian; j = j - 1; Jika ApplyDisplaySortThenDisplaySortChart(Array); endIf; EndCycle; i = i + 1; EndCycle; Langkah = Objek(Langkah/2); UserInterruptHandling(); EndCycle; Return Array; EndFunction //---)
8. Algoritma "Isih cepat".
Algoritma yang paling popular dan digunakan dalam amalan. Ia adalah salah satu algoritma pengisihan data yang paling berkesan.
Keseluruhan intipati algoritma adalah untuk memecahkan masalah kompleks kepada masalah kecil dan menyelesaikannya secara berasingan. Titik rujukan tertentu dipilih dan semua nilai yang kurang dibuang ke kiri, semua nilai lain ke kanan. Kemudian, untuk setiap bahagian yang diterima, lakukan perkara yang sama, sehingga bahagian tersebut tidak lagi dapat dipecahkan. Pada akhirnya kita mendapat banyak bahagian yang disusun yang hanya perlu dilekatkan menjadi satu keseluruhan.
//Algoritma "Isih Pantas" ( Prosedur b_Sort(Array, LowerLimit, UpperLimit) i = LowerLimit; j = UpperLimit; m = Array[Integr((i+j)/2)]; While True Loop While Array[i]< m Цикл i = i + 1; КонецЦикла; Пока Массив[j] >m Kitaran j = j - 1; EndCycle; Jika i > j Kemudian Batalkan; endIf; EndCycle; Jika Had Rendah< j Тогда б_Сортировка(Массив,НижнийПредел,j); КонецЕсли; Если i < ВерхнийПредел Тогда б_Сортировка(Массив,i,ВерхнийПредел); КонецЕсли; КонецПроцедуры Функция БыстраяСортировка(Массив) НижняяГраница = 0; ВерхняяГраница = Массив.ВГраница(); б_Сортировка(Массив,НижняяГраница,ВерхняяГраница); Возврат Массив; КонецФункции //---}
9. Isih tatasusunan klasik dalam 1s.
Kami menghantar tatasusunan kepada senarai nilai. Kami mengisih menggunakan kaedah "Isih" standard.
//Isih mengikut senarai nilai (--- Fungsi Isih mengikut Senarai Nilai (Value Array) mListValues = New ListValues; mListValues.LoadValues(Array); mListValues.SortByValue(SortDirection.Asc); Kembalikan mListValues.UnloadValues(); EndFunction //---)
Semua pengisihan boleh dipercepatkan dengan meletakkan kod dalam gelung 1 baris. Tetapi untuk kebolehbacaan, saya biarkan seperti itu.
Saya menulis pemprosesan yang melaksanakan semua algoritma di atas, dan juga menyokong animasi dinamik proses pengisihan (Kecuali pengisihan standard 1c) .
-Apabila pemprosesan bermula, susunan nombor rawak dari 0 hingga 100 dengan dimensi 100 elemen terbentuk secara automatik.
-Untuk mencipta tatasusunan lain, anda mesti mengklik pada butang "Buat tatasusunan RNG", anda juga boleh memilih julat yang diperlukan.
-Untuk mendayakan animasi dinamik, anda mesti menandakan kotak "Isih paparan dalam carta". Saya menasihati anda untuk menandai kotak untuk algoritma yang tidak cekap apabila saiz tatasusunan adalah sehingga 100 elemen, jika tidak, anda akan terlalu tua untuk menunggu untuk mengisih :)
Penyampaian dinamik proses pengisihan sangat mengurangkan prestasi, tetapi anda dapat melihat dengan jelas cara algoritma berfungsi.
Lambat laun, mana-mana pengaturcara perlu mengisih data daripada tatasusunan. Sama ada ia memaparkan data daripada pangkalan data dalam susunan abjad atau menyusun nama fail mengikut tarikh terakhir diubah suai, ia boleh dilakukan terima kasih kepada fungsi PHP terbina dalam untuk mengisih data tatasusunan. Dalam artikel ini saya akan menunjukkan dan menerangkan dengan contoh bagaimana fungsi seperti sort(), rsort() berfungsi.
Fungsi ; - Isih tatasusunan dalam susunan menaik dan abjad
Struktur:
($Array, $Flag);
Fungsi ini menyusun tatasusunan yang diberikan kepadanya $Array dalam tertib menaik. Fungsi ini direka untuk berfungsi dengan senarai. Senarai ialah tatasusunan biasa yang kuncinya bermula dari sifar. Fungsi ini boleh diberikan hujah pilihan $Flag, yang memanipulasi apa yang sepatutnya berlaku menyusun. Pertimbangkan perihalan hujah $Flag:
SORT_REGULAR– Fungsi isihan lalai
SORT_NUMERIC- Menyusun nombor, menaik
SORT_STRING- Menyusun rentetan, mengikut abjad
Mari kita pertimbangkan contoh: kita mempunyai tatasusunan di mana data tentang bilangan pasangan pelajar dalam tahun pengajian yang berbeza disimpan dalam bentuk huru-hara.
"; ) ?> Hasil skrip: Kursus: 1 - 72 pasang Kursus: 2 - 83 pasang Kursus: 3 - 100 pasang Jika kami tidak menggunakan fungsi tersebut, hasil kerja adalah seperti berikut: Kursus: 1 - 83 pasang Kursus: 2 - 100 pasang Kursus: 3 - 72 pasang
Isih mengikut abjad
Di bawah ialah skrip yang mengisih negara tatasusunan mereka mengikut abjad; hujah kedua fungsi ($Bendera) tidak perlu ditetapkan, kerana fungsi itu sendiri akan memahami bahawa ia perlu berfungsi dengan rentetan.
"; ) ?> Hasil kerja: Armenia Itali Rusia Jepun
Fungsi rsort() - Isih tatasusunan dalam tertib menurun
Fungsi ini tidak logik tetapi menyusun tatasusunan dalam tertib menurun. Mari lihat struktur sintaks:
($Array, $Flag);
Contoh untuk fungsi ini akan serupa dengan contoh yang diberikan di atas, kecuali satu perkara, data daripada tatasusunan akan diisih dalam tertib menurun. Kami sedang mencipta pelbagai hadiah untuk mereka yang mendapat tempat pertama, kedua dan ketiga dalam pertandingan.
"; ) ?> Keputusan pelaksanaan skrip: tempat pertama - hadiah: 2800 rubel. Tempat ke-2 - hadiah: 1200 rubel. Tempat ke-3 - hadiah: 500 rubel.
Apabila bekerja di banyak tapak, persoalan menyusun data tatasusunan dalam susunan abjad sering timbul. Ramai orang menulis tatasusunan tambahan untuk ini, bandingkan jadual besar dan ulangi setiap nama... Pilihan ini bukan yang terbaik, walaupun kami juga akan mempertimbangkannya. Dalam artikel ini saya ingin mencadangkan cara termudah dan terpendek, yang, jika anda membaca manual dengan teliti, boleh didapati dalam dokumentasi.
PHP Tatasusunan Abjad
Kaedahnya agak mudah dan terdiri daripada dua langkah: menetapkan tempat (setlocal) dan menyusun tatasusunan secara langsung. Mari lihat contoh dengan komen.kod PHP
setlocale(LC_ALL, "Russian_Russia.1251"); // tetapkan tempat untuk huruf Rusia
// contoh tatasusunan di mana perkataan TIDAK teratur
$example=array("jar","Boris","view","soal selidik","gamekeeper","Fedor","isteri","suara");
Natcasesort($example, SORT_LOCALE_STRING); // mengisih tatasusunan TANPA sensitiviti huruf besar
// UNTUK MENJADI SENSITIF KES, gunakan isihan bukannya natcasesort
// paparkan hasilnya
foreach ($contoh sebagai $key => $value)(
echo "$value "; // paparkan perkataan sahaja, tanpa indeks
}
?>
Demonstrasi Muat turun sumber
Dalam demo anda boleh melihat skrip dalam tindakan. Jika anda mahu, anda juga boleh memuat turun arkib dengan fail tersebut.
Jika pelayan anda tiada pada Windows, maka anda perlu memasang tempat lain atau beberapa sekaligus:
(LC_ALL,"ru_RU.CP1251", "rus_RUS.CP1251", "Russian_Russia.1251");!}
// Mencetak ru_RU.CP1251 untuk FreeBSD
// Mencetak rus_RUS.CP1251 untuk Linux
// Cetak Russian_Russia.1251 untuk Windows
Saya akan menjawab salah satu soalan - tempat untuk Ukraine dalam PHP kelihatan seperti ini:
Bagaimana untuk menetapkan tempat untuk pengekodan lain dalam PHP?
// Pasang tempat untuk Windows
// Pengekodan Windows-1251
setlocale(LC_ALL, "Russian_Russia.1251");
// Pengekodan KOI8-R
setlocale(LC_ALL, "Russian_Russia.20866");
// Pengekodan UTF-8 (gunakan dengan berhati-hati)
setlocale(LC_ALL, "Russian_Russia.65001");
?>
Cara kedua untuk menyusun tatasusunan dalam susunan abjad PHP
Jika kaedah ini tidak sesuai dengan anda dan anda mahu pergi dengan cara yang sukar, kemudian buat tatasusunan seperti ini:kod PHP
=> a
=> b
=> dalam
=> r
=> d
=> e
=> ё
=> w
=> s
=> dan
=> ke
=> kepada
=> l
=> m
=> n
=> o
=> hlm
=> hlm
=> dengan
=> t
=> y
=> f
=> x
=> ts
=> h
=> w
=> sch
=> ъ
=> s
=> b
=> eh
=> yu
=> Saya
Dan lelaran ke atas tatasusunan kedua dengan huruf pertama.
Huruf pertama mana-mana elemen tatasusunan dikira seperti berikut:
kod PHP
$city="Moscow"; // contohnya elemen dengan indeks 1
$first_letter = mb_substr($city,0,1,"UTF-8"); // dapatkan huruf "M"
Oleh kerana kami bekerja dengan huruf Rusia (pengekodan berbilang bait), lebih baik menggunakan fungsi tersebut mb_substr, dan pada akhirnya adalah lebih baik untuk menunjukkan dengan tepat pengekodan pembolehubah atau data tatasusunan, dalam kes kami UTF-8.
Terima kasih kerana memberi perhatian! Saya harap maklumat itu berguna. Jika anda mempunyai soalan, tulis dalam komen.
Lebih besar susunan data yang dianalisis, lebih sukar untuk menumpukan pada ciri utamanya. Untuk lebih memahami maklumat yang terkandung dalam set data, ia mesti disusun dengan betul. Untuk melakukan ini, gunakan sama ada tatasusunan tertib atau rajah batang dan daun.
Susunan tersusun
Tatasusunan tertib (tidak semestinya satu dimensi) terdiri daripada jujukan data yang disusun dalam tertib menaik. Sebagai contoh, jadual (Rajah 1) mengandungi penunjuk pulangan tahunan purata lima tahun sebanyak 158 dana. Tatasusunan tersusun membolehkan anda menentukan dengan segera nilai minimum dan maksimum, nilai biasa, serta julat yang sebahagian besar nilainya dimiliki.
nasi. 1. Tatasusunan tertib yang mengandungi data mengenai pulangan tahunan purata lima tahun sebanyak 158 dana tertumpu kepada pertumbuhan modal yang pesat untuk tempoh dari 1 Januari 1997 hingga 31 Disember 2001
Muat turun nota dalam atau format, contoh dalam format
Dapat dilihat bahawa tahap terendah pulangan tahunan purata lima tahun ialah -6.1% setahun, dan yang tertinggi mencapai 26.3%. Di samping itu, purata prestasi tahunan kebanyakan dana adalah antara 5 hingga 15%. Namun, mempersembahkan data dalam bentuk tatasusunan dua dimensi (seperti dalam Rajah 1) adalah tidak optimum, kerana ia tidak membenarkan anda membuat jadual pangsi dengan cepat dan mudah. Oleh itu, saya mengesyorkan membuat tatasusunan tertib menegak satu dimensi. Excel menyediakan beberapa pilihan untuk melakukan ini.
Mari kita pertimbangkan, sebagai contoh silang, purata suhu bulan Julai di Moscow selama 130 tahun pemerhatian (Rajah 2).
nasi. 2. Purata suhu bulanan pada bulan Julai di Moscow; data awal
Cara paling mudah untuk mengatur set data disediakan oleh pilihan Excel Isih. Pilih lajur A dan B; pergi ke menu Data → Isih (Gamb. 3). Menu akan dibuka Menyusun. Di padang Disusun mengikut pilih Purata suhu Julai, °C, di padang Pesanan – Menaik. Klik Ok.
nasi. 3. Menyusun data
Anda akan menerima senarai yang diisih (disusun) mengikut suhu (Gamb. 4). Ia serta-merta jelas bahawa purata suhu bulanan minimum pada bulan Julai direkodkan di Moscow pada 1904 - 14.6°C, dan yang tertinggi - pada 2010 - 26.1°C. Anda mungkin ingat tahun yang dahsyat ini!? Sila ambil perhatian bahawa rekod sebelumnya telah melebihi 10%.
nasi. 4. Senarai pesanan
Gambar rajah batang dan daun
Rajah batang dan daun adalah alat untuk visual mengatur set data dan menganalisis pengedarannya. Data dalam carta diedarkan mengikut nombor utama, atau batang, dan nombor belakang, atau daun. Sebagai contoh, nombor 18.9 dalam rajah batang dan daun terdiri daripada sebatang 18 dan sehelai daun 9 (Rajah 5). Malangnya, Excel tidak mencipta carta batang dan daun secara automatik. Oleh itu, kami akan menggunakan prosedur manual. Kami menggunakan bahagian integer suhu sebagai batang, dan bahagian perpuluhan sebagai daun (lihat formula pada helaian "Batang dan Daun" fail Excel; mula-mula saya menyerlahkan bahagian pecahan, kemudian memindahkan pecahan dari lajur ke baris, dan akhirnya memformatkan carta untuk menjadikannya lebih kelihatan).
nasi. 5. Gambar rajah batang dan daun
Gambar rajah batang dan daun menggambarkan sejumlah besar maklumat. Sebagai contoh, anda boleh menentukan secara langsung nilai minimum (14.6) dan maksimum (26.1) daripadanya. Ia boleh dilihat bahawa kebanyakan nilai jatuh dalam julat 16...20°C, dan nilai itu sendiri membentuk purata kira-kira 18°C. Terdapat juga ekor yang agak lebar di kawasan b O nilai yang lebih tinggi.
Tugasan ujian
- Data di bawah mengandungi bilangan cek yang dipulangkan oleh 23 bank kepada pendeposit mereka kerana kekurangan dana dalam akaun. (Amaun deposit minimum hendaklah tidak kurang daripada $100): 26 28 20 20 21 22 25 25 18 25 15 20 18 20 25 25 22 30 30 30 15 20 29.
- Bina gambar rajah batang dan daun yang mengandungi data yang diberi.
- Tentukan nilai di sekeliling pengedaran bilangan cek yang dikembalikan tertumpu.
- Data di bawah menunjukkan yuran perkhidmatan bulanan (dalam dolar) yang dikenakan oleh 26 bank kepada pelanggan mereka jika baki akaun pelanggan berada di bawah $1,500 minimum: 12 8 5 5 6 6 10 10 9 7 10 7 7 5 0 10 6 9 12 0 5 10 8 5 5 9.
- Buat tatasusunan tertib yang mengandungi data yang ditentukan.
- Bina gambar rajah batang dan daun yang mengandungi data yang diberi.
- Cara penyampaian data yang manakah lebih bermaklumat? Wajarkan jawapan anda.
- Tentukan nilai di mana pengagihan bayaran bulanan untuk perkhidmatan perbankan tertumpu.
Jawapan kepada tugasan ujian
1. Lihat helaian "Kawalan1" fail Excel dan Rajah. 6. Gambar rajah batang dan daun adalah lebih bermaklumat daripada tatasusunan tersusun kerana ia menggambarkan data dengan lebih baik. Nilai purata adalah lebih kurang 22. Helah untuk kerja ialah memilih langkah untuk nilai batang. Jika anda memilih bilangan puluh (10, 20, 30) sebagai langkah, rajah "batang dan daun" akan kehilangan kejelasannya.
Isih tatasusunan ialah proses mengagihkan semua elemen dalam susunan tertentu. Selalunya ini berguna. Contohnya, dalam peti masuk anda, e-mel dipaparkan berdasarkan masa ia diterima; e-mel baharu dianggap lebih relevan daripada yang anda terima setengah jam, sejam, dua atau sehari yang lalu; apabila anda pergi ke senarai kenalan anda, nama biasanya dalam susunan abjad kerana lebih mudah untuk mencari sesuatu. Semua kes ini melibatkan pengisihan data sebelum benar-benar mengeluarkannya.
Bagaimanakah pengisihan berfungsi?
Isih data boleh menjadikan carian dalam tatasusunan lebih cekap bukan sahaja untuk orang, tetapi juga untuk komputer. Sebagai contoh, pertimbangkan kes di mana kita perlu mengetahui sama ada nama tertentu muncul dalam senarai nama. Untuk mengetahui, kita perlu menyemak setiap elemen tatasusunan terhadap nilai kita. Mencari tatasusunan dengan banyak elemen mungkin terlalu tidak cekap (mahal).
Walau bagaimanapun, mari kita anggap bahawa tatasusunan nama kita disusun mengikut abjad. Kemudian carian kami bermula dengan huruf pertama nilai kami dan berakhir dengan huruf yang datang seterusnya dalam abjad. Dalam kes ini, jika kita sampai ke surat ini dan tidak menjumpai nama itu, maka kita pasti tahu bahawa ia tidak berada dalam tatasusunan yang lain, kerana kita telah lulus surat kita dalam susunan abjad!
Bukan rahsia lagi bahawa terdapat algoritma yang lebih baik untuk mencari dalam tatasusunan yang diisih. Menggunakan algoritma mudah, kita boleh mencari elemen tertentu dalam tatasusunan yang diisih yang mengandungi 1,000,000 elemen menggunakan hanya 20 perbandingan! Kelemahannya, tentu saja, ialah menyusun tatasusunan dengan sejumlah besar elemen adalah agak mahal, dan ia pastinya tidak dilakukan demi satu pertanyaan carian.
Dalam sesetengah kes, menyusun tatasusunan menjadikan carian tidak diperlukan. Sebagai contoh, kami sedang mencari markah terbaik pelajar dalam sesuatu ujian. Jika tatasusunan tidak diisih, maka kita perlu melihat setiap elemen tatasusunan untuk mencari skor tertinggi. Jika tatasusunan diisih, maka skor tertinggi adalah sama ada di kedudukan pertama atau yang terakhir (bergantung pada cara tatasusunan diisih: tertib menaik atau menurun), jadi kita tidak perlu mencari sama sekali!
Pengisihan biasanya dilakukan dengan membandingkan pasangan elemen tatasusunan berulang kali dan menggantikan nilai jika memenuhi kriteria tertentu. Susunan elemen ini dibandingkan bergantung pada algoritma pengisihan yang digunakan. Kriteria terdiri daripada cara tatasusunan akan diisih (contohnya, tertib menaik atau tertib menurun).
Untuk menukar dua elemen kita boleh menggunakan fungsi std::swap() daripada perpustakaan standard C++, yang ditakrifkan dalam algoritma. Dalam C++11, std::swap() telah dialihkan ke fail pengepala utiliti:
#termasuk
#termasuk #termasuk int utama() int a = 3 ; int b = 5 ; std::cout<< "Before swap: a = " << a << ", b = " << b << "\n" ; std::swap(a, b); // menukar nilai pembolehubah a dan b std::cout<< "After swap: a = " << a << ", b = " << b << "\n" ; |
Hasil daripada menjalankan program di atas:
Sebelum pertukaran: a = 3, b = 5
Selepas pertukaran: a = 5, b = 3
Selepas melakukan operasi gantian, nilai pembolehubah a dan b ditukar.
Mengisih tatasusunan menggunakan kaedah pemilihan
Terdapat banyak cara untuk mengisih tatasusunan. Pengisihan tatasusunan mengikut pemilihan mungkin adalah yang paling mudah untuk difahami, walaupun ia juga merupakan salah satu yang paling perlahan.
Untuk menyusun tatasusunan dengan memilih daripada elemen terkecil hingga terbesar langkah-langkah berikut dilakukan:
Bermula dengan elemen pada indeks 0, kami mencari nilai terkecil dalam tatasusunan.
Nilai yang ditemui ditukar dengan unsur sifar.
Kami mengulangi langkah No. 1 dan No. 2 untuk indeks seterusnya dalam tatasusunan.
Dalam erti kata lain, kita mencari elemen terkecil dalam tatasusunan dan mengalihkannya ke tempat pertama. Kemudian kita mencari elemen kedua terkecil dan memindahkannya ke tempat kedua selepas elemen terkecil pertama. Proses ini berterusan sehingga tatasusunan kehabisan elemen yang tidak diisih.
Berikut ialah contoh bagaimana algoritma ini berfungsi dalam tatasusunan dengan 5 elemen:
{ 30, 50, 20, 10, 40 }
Mula-mula kita mencari elemen terkecil, bermula pada indeks 0:
{ 30, 50, 20, 10 , 40 }
Kemudian kita menukar elemen terkecil dengan elemen pada indeks 0:
{ 10 , 50, 20, 30 , 40 }
Memandangkan elemen pertama tatasusunan diisih, kami mengabaikannya. Kami sedang mencari elemen terkecil seterusnya, tetapi bermula dari indeks 1:
{ 10 , 50, 20 , 30, 40 }
Dan tukar dengan elemen pada indeks 1:
{ 10 , 20 , 50 , 30, 40 }
Sekarang kita boleh mengabaikan dua elemen pertama. Kami mencari elemen terkecil seterusnya, bermula pada indeks 2:
{ 10 , 20 , 50, 30 , 40 }
Dan tukar dengan elemen pada indeks 2:
{ 10 , 20 , 30 , 50 , 40 }
Kami mencari elemen terkecil seterusnya, bermula pada indeks 3:
{ 10 , 20 , 30 , 50, 40 }
Dan tukar dengan elemen pada indeks 3:
{ 10 , 20 , 30 , 40 , 50 }
Kami mencari elemen terkecil seterusnya, bermula pada indeks 4:
{ 10 , 20 , 30 , 40 , 50 }
Dan kami menukarnya dengan elemen pada indeks 4 (penggantian diri dilakukan, iaitu kami tidak melakukan apa-apa):
{ 10 , 20 , 30 , 40 50 }
{ 10, 20, 30, 40, 50 }
Ambil perhatian bahawa perbandingan terakhir akan sentiasa menjadi perbandingan tunggal (iaitu penggantian diri), yang merupakan operasi yang tidak perlu, jadi sebenarnya kita boleh menghentikan isihan sebelum elemen terakhir tatasusunan.
Mengisih tatasusunan menggunakan kaedah pemilihan dalam C++
Begini cara algoritma ini dilaksanakan dalam C++:
#termasuk
#termasuk #termasuk int utama() const int panjang = 5; // Gelung melalui setiap elemen tatasusunan // (kecuali yang terakhir, ia akan diisih mengikut masa kita sampai) < length - 1 ; ++ startIndex ) // Pembolehubah SmallestIndex menyimpan indeks nilai terkecil yang kami temui dalam lelaran ini // Mulakan dengan elemen terkecil dalam lelaran ini sebagai elemen pertama (indeks 0) int smallestIndex = startIndex ; // Kemudian cari elemen yang lebih kecil dalam tatasusunan yang lain < length ; ++ currentIndex ) // Jika kita menjumpai unsur yang lebih kecil daripada unsur terkecil kita, jika (array [ currentIndex ]< array [ smallestIndex ] ) // maka ingatlah smallestIndex = currentIndex ; // smallestIndex kini merupakan elemen terkecil // Tukar nombor terkecil awal kami dengan nombor yang kami temui std::swap(array[startIndex], array[smallestIndex]); // Sekarang setelah keseluruhan tatasusunan diisih, paparkannya pada skrin untuk (int index = 0 ; index< length ; ++ index ) std::cout<< array [ index ] << " " ; pulangan 0; |
Bahagian yang paling mengelirukan dalam algoritma ini adalah di dalam gelung lain (dipanggil gelung bersarang). Gelung luar (startIndex) berulang melalui elemen satu demi satu (satu demi satu). Dalam setiap lelaran gelung luar, gelung dalam (currentIndex) digunakan untuk mencari elemen terkecil antara elemen yang kekal dalam tatasusunan (bermula pada startIndex + 1). smallestIndex menjejaki indeks unsur terkecil yang ditemui oleh gelung dalam. Kemudian smallestIndex menukar nilai daripada startIndex . Akhirnya, gelung luar (startIndex) melepasi elemen ini dan proses berulang.
Petunjuk: Jika anda menghadapi masalah memahami cara program di atas berfungsi, cuba tuliskannya pada sehelai kertas. Tulis elemen permulaan (tidak diisih) tatasusunan secara mendatar pada baris di bahagian atas lembaran kerja. Lukis anak panah yang menunjukkan elemen yang startIndex , currentIndex dan smallestIndex pada masa ini. Gelung melalui program secara manual dan lukis semula anak panah apabila indeks berubah. Selepas setiap lelaran gelung luar, lukis garisan baharu yang menunjukkan keadaan semasa tatasusunan (lokasi elemennya).
Pengisihan teks dilakukan menggunakan algoritma yang sama. Cuma tukar jenis tatasusunan daripada -a kepada dan mulakannya dengan nilai yang sesuai.
std::sort()
Oleh kerana menyusun tatasusunan adalah operasi yang sangat biasa, perpustakaan standard C++ menyediakan fungsi pengisihan terbina dalam - std::sort(). Ia terletak dalam fail pengepala algoritma dan dipanggil seperti berikut:
#termasuk
#termasuk #termasuk int utama() const int panjang = 5; int array [panjang] = (30, 50, 20, 10, 40); std::sort(array, array + length); untuk (int i = 0 ; i< length ; ++ i ) std::cout<< array [ i ] << " " ; pulangan 0; |
Ujian
Tugasan No 1
Tulis pada sekeping kertas cara mengisih tatasusunan berikut menggunakan kaedah pemilihan (seperti yang kita lakukan di atas):
{30, 60, 20, 50, 40, 10}
Jawapan #1
30 60 20 50 40 10
10
60 20 50 40 30
10 20
60
50 40 30
10 20 30
50 40 60
10 20 30 40
50
60
10 20 30 40 50
60 (penggantian diri)
10 20 30 40 50 60
(ganti diri)
Tugasan No. 2
Tulis semula kod program daripada sari kata "Isih Susunan mengikut Pemilihan dalam C++" supaya pengisihan dilakukan dalam tertib menurun (nombor terbesar hingga terkecil). Walaupun ini mungkin kelihatan rumit pada pandangan pertama, ia sebenarnya sangat mudah.
Jawapan #2
Tukar sahaja:
Jika (susun< array)
jika (array [ currentIndex ]< array [ smallestIndex ] ) |
Jika (susun > tatasusunan)
jika (array [ currentIndex ] > array [ smallestIndex ] ) |
Juga smallestIndex hendaklah dinamakan semula kepada largestIndex:
#termasuk
#termasuk #termasuk int utama() const int panjang = 5; int array [panjang] = (30, 50, 20, 10, 40); // Gelung melalui setiap elemen tatasusunan kecuali yang terakhir untuk (int startIndex = 0 ; startIndex< length - 1 ; ++ startIndex ) // largestIndex ialah indeks bagi elemen terbesar yang kami temui setakat ini int largestIndex = startIndex ; // Gelung melalui setiap elemen tatasusunan bermula dari startIndex + 1 untuk (int currentIndex = startIndex + 1 ; currentIndex< length ; ++ currentIndex ) // Jika elemen semasa lebih besar daripada elemen terbesar kita, if (array [ currentIndex ] > array [ largestIndex ] ) // maka ini ialah elemen terbesar baharu dalam lelaran ini Indeks terbesar = Indeks semasa ; // Tukar nombor permulaan kami dengan elemen terbesar yang ditemui std::swap (array [ startIndex ] , array [ largestIndex ] ); // Paparkan tatasusunan yang diisih pada skrin untuk (int index = 0 ; index< length ; ++ index ) std::cout<< array [ index ] << " " ; pulangan 0; |
Tugasan No. 3
Tugasan ini lebih sukar sedikit.
Satu lagi kaedah mudah untuk menyusun elemen ialah "isih gelembung"(atau lebih "isih gelembung"). Ideanya adalah untuk membandingkan sepasang nilai yang berdekatan, dan jika kriteria yang ditentukan dipenuhi, nilai daripada pasangan ini ditukar. Dan dengan itu elemen "gelembung" ke hujung tatasusunan. Walaupun terdapat beberapa cara untuk mengoptimumkan isihan gelembung, untuk tugasan ini kami akan menggunakan versi yang tidak dioptimumkan kerana ia lebih mudah.
Untuk versi isihan gelembung yang tidak dioptimumkan, langkah berikut dilakukan untuk: menyusun tatasusunan daripada nilai terkecil kepada nilai terbesar:
Elemen tatasusunan pada indeks 0 dibandingkan dengan elemen tatasusunan pada indeks 1. Jika elemen pada indeks 0 lebih besar daripada elemen pada indeks 1, maka nilainya ditukar.
Kami kemudian beralih ke pasangan nilai seterusnya: elemen pada indeks 1 dan elemen pada indeks 2, dan seterusnya sehingga kami mencapai penghujung tatasusunan.
Kami mengulangi langkah No. 1 dan langkah No. 2 sehingga keseluruhan tatasusunan diisih.
Tulis program yang akan mengisih tatasusunan berikut menggunakan isihan gelembung mengikut peraturan di atas:
const int panjang(9); int array = ( 7, 5, 6, 4, 9, 8, 2, 1, 3 );
const int panjang(9); |
Pada penghujung program, cetak elemen disusun tatasusunan.
Petunjuk: Jika kita hanya boleh mengisih satu elemen dalam satu lelaran, maka ini bermakna kita perlu mengulangi gelung seberapa banyak kali terdapat nombor dalam tatasusunan kami (panjangnya) untuk memastikan keseluruhan tatasusunan diisih.
Jawapan #3
#termasuk
#termasuk #termasuk int utama() const int panjang(9); int array [panjang] = (7, 5, 6, 4, 9, 8, 2, 1, 3); untuk (int lelaran = 0 ; lelaran< length - 1 ; ++ iteration ) // Gelung melalui setiap elemen tatasusunan sehingga elemen terakhir (tidak termasuk) // Elemen terakhir tidak mempunyai pasangan untuk dibandingkan untuk (int currentIndex = 0 ; currentIndex< length - 1 ; ++ Indeks semasa) { // Jika elemen semasa lebih besar daripada elemen selepasnya, maka tukarkannya jika(tatasusunan[ Indeks semasa] > tatasusunan[ Indeks semasa+ 1 ] ) std:: bertukar-tukar(tatasusunan[ Indeks semasa] , tatasusunan[ Indeks semasa+ 1 ] ) ; } } // Paparkan tatasusunan yang diisih pada skrin untuk(intindeks= 0 ; indeks< panjang; ++ indeks) std:: cout<< tatasusunan[ indeks] << " " ; kembali0 ; } |
Tugasan No. 4
Laksanakan dua penyelesaian pengoptimuman berikut untuk algoritma isihan gelembung yang anda tulis dalam tugasan sebelumnya:
Perhatikan bahawa setiap kali isihan gelembung dilakukan, nilai terbesar dalam tatasusunan "buih" hingga akhir. Selepas lelaran pertama, elemen terakhir tatasusunan sudah diisih. Selepas lelaran kedua, elemen kedua terakhir tatasusunan diisih, dan seterusnya. Dengan setiap lelaran baharu, kita tidak perlu menyemak semula elemen yang telah diisih. Ubah suai gelung anda supaya anda tidak menyemak semula elemen yang telah diisih.
