Contoh Hiris Isih Golang

Contoh Hiris Isih Golang



Isih ialah operasi pengaturcaraan asas yang termasuk meletakkan elemen dalam susunan tertentu. Pakej isihan, yang disediakan oleh perpustakaan rasmi Go, termasuk beberapa fungsi untuk mengisih kepingan dengan cepat. Mengisih hirisan adalah tugas biasa dalam banyak aplikasi, daripada menyusun data untuk pembentangan kepada mengoptimumkan algoritma carian. Artikel ini meneroka teknik pengisihan yang berbeza dan menunjukkan penggunaannya dalam Go menggunakan pakej isihan.

Contoh 1: Hiris Isih Golang dalam Tertib Menaik

Fungsi 'sort.Slice()' ialah fungsi utama dalam Go yang menyusun semula elemen hirisan dalam tertib menaik atau tertib menurun. Ambil kira ilustrasi berikut di mana kepingan itu disusun dalam tertib menaik:

pakej utama
import (
'fmt'
'isih'
)
fungsi utama () {
evenSlice := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Kepingan tidak diisih:' , evenSlice )
menyusun . potong ( evenSlice , fungsi ( i , j int ) bool {
kembali evenSlice [ i ] < genapSlice [ j ]
})
fmt . Println ( 'Kepingan diisih:' , evenSlice )
}

Pada permulaan fungsi main(), kami mentakrifkan kepingan evenSlice dengan nilai {10, 2, 8, 4, 0, 6}. Potongan ini mewakili koleksi nombor genap yang pada mulanya tidak diisih. Untuk mengisih kepingan evenSlice, fungsi sort.Slice() digunakan dengan kepingan. Di dalam fungsi sort.Slice(), fungsi isihan disediakan sebagai hujah. Fungsi ini menentukan susunan pengisihan dengan membandingkan dua elemen hirisan pada indeks “i” dan “j”. Jika evenSlice[i] kurang daripada evenSlice[j], ia mengembalikan true; jika tidak, ia kembali palsu. Fungsi sort.Slice() menggunakan fungsi perbandingan ini untuk menyusun semula elemen hirisan 'evenSlice' dalam tertib menaik.







Keputusan hirisan yang diisih dalam susunan menaik dijana dalam skrin output berikut:





Contoh 2: Potongan Bahagian Isih Golang

Seterusnya, pengisihan digunakan pada sub-slice bagi kepingan yang ditentukan dalam tertib menaik menggunakan fungsi sort.Slice() dalam Go.





pakej utama
import (
'fmt'
'isih'
)
fungsi utama () {
n := [] int { 9 , 7 , 3 , 5 }
mulakan := 0
tamat := 3
menyusun . potong ( n [ mulakan : tamat ], fungsi ( i , j int ) bool {
kembali n [ mulakan + i ] < n [ mulakan + j ]
})
fmt . Println ( n )
}

Pada mulanya, kami mencipta kepingan 'n' dengan nilai [9, 7, 3, 5]. Selain itu, dua pembolehubah, 'mula' dan 'akhir', masing-masing ditetapkan kepada 0 dan 3. Pembolehubah ini mentakrifkan julat indeks dalam kepingan 'n' yang akan diisih. Fungsi “sort.Slice()” kemudiannya dipanggil dengan sub-slice “n[start:end]” sebagai hujah pertama. Sub-slice ini mengandungi unsur 'n' dalam julat yang ditentukan. Selepas itu, fungsi pengisihan diberikan sebagai hujah kedua di dalam fungsi sort.Slice().

Di sini, fungsi itu menerima dua indeks, 'i' dan 'j', yang mewakili unsur-unsur dalam sub-kepingan. Untuk membandingkan unsur-unsur dalam sub-kepingan, fungsi pengisihan mengakses elemen yang sepadan dalam kepingan asal menggunakan permulaan offset. Ia membandingkan n[start+i] dan n[start+j]. Seterusnya, fungsi sort.Slice() menggunakan fungsi isihan yang disediakan untuk menyusun semula elemen dalam sub-slice dalam tertib menaik.



Output berikut memaparkan bahawa unsur-unsur dalam julat yang ditentukan (mula hingga akhir-1) diisih dan unsur-unsur di luar julat kekal tidak berubah:

Contoh 3: Golang Isih Integer Slice Menggunakan Fungsi Sort.Ints().

Selain itu, yang paling mudah untuk mengisih kepingan integer ialah fungsi sort.Ints() tanpa perlu melaksanakan kaedah pengisihan tersuai. Ia bertindak secara langsung pada kepingan integer dan melakukan pengisihan di tempat. Program berikut mengisih integer yang ditentukan:

pakej utama
import (
'fmt'
'isih'
)
fungsi utama () {
IntSlice := [] int { 10 , 13 , lima belas , sebelas , 14 , 12 }
fmt . Println ( 'Kepingan tidak diisih:' , IntSlice )
menyusun . Ints ( IntSlice )
fmt . Println ( 'Kepingan diisih:' , IntSlice )
}

Mula-mula, kami mengisytiharkan dan memulakan hirisan 'IntSlice' dengan nilai [10, 13, 15, 11, 14, 12] yang mewakili koleksi integer yang pada mulanya tidak diisih. Kemudian, fungsi sort.Ints() dipanggil dengan kepingan 'IntSlice' sebagai hujah untuk mengisih 'IntSlice'. Fungsi sort.Ints() dalam kes ini mengisih setiap bahagian hirisan secara dalaman mengikut algoritma pengisihan yang dioptimumkan. Ia mengubah suai hirisan asal secara langsung, menyusun semula elemennya ke dalam susunan yang diisih.

Output berikut mula-mula menunjukkan bahawa kepingan yang tidak diisih dipaparkan dahulu, diikuti oleh kepingan yang diisih:

Contoh 4: Hirisan Rentetan Isih Golang

Go juga menawarkan fungsi sort.Strings() bagi pakej sort yang digunakan untuk mengisih kepingan rentetan dalam susunan tertentu. Di sini, program berikut membantu untuk mengisih kepingan rentetan:

pakej utama
import (
'fmt'
'isih'
)
fungsi utama () {
strSl := [] tali { 'golan' , 'python' , 'java' , 'perl' , 'skrip taip' }
menyusun . rentetan ( strSl )
fmt . Println ( strSl )
}

Kami mula-mula menubuhkan kepingan 'strSl' dengan nilai ['golang', 'python', 'java', 'perl', 'typescript'] yang tidak diisih. Selepas itu, kami mengisih hirisan 'strSl' dengan fungsi sort.Strings() yang mengisih unsur-unsur hirisan dalam susunan leksikografi. Fungsi ini mengubah suai hirisan asal secara langsung, menyusun semula elemennya ke dalam tertib diisih berdasarkan nilai ASCIInya.

Output menyusun kepingan rentetan dalam cara menaik seperti yang dipaparkan dalam yang berikut:

Contoh 5: Slice Isih Semak Golang Menggunakan Fungsi IntAreSort().

Walau bagaimanapun, dengan fungsi sort.IntsAreSorted() Go, kita boleh menyemak sama ada kepingan integer tertentu diisih dalam tertib menaik atau tidak. Pertimbangkan contoh program fungsi IntAreSort() berikut untuk kepingan yang diberikan:

pakej utama
import (
'fmt'
'isih'
)
fungsi utama () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Kepingan:' )
fmt . Println ( 'Kepingan Tidak Diisih: ' , sl )
hasil := menyusun . IntsAreSorted ( sl )
fmt . Println ( ' \n Keputusan:' )
fmt . Println ( 'Adakah diberi Slice disusun?: ' , hasil )
}

Pertama, kepingan integer rawak yang tidak diisih ditakrifkan sebagai 'sl'. Potongan ini mengandungi koleksi integer tanpa susunan tertentu. Seterusnya, kami memanggil fungsi sort.IntsAreSorted() dan lulus hirisan 'sl' sebagai hujah. Fungsi ini menyediakan hasil Boolean yang menunjukkan sama ada input hirisan disusun dalam tertib menaik atau tidak. Kemudian, fungsi fmt.Println() mencetak hasil yang mengeluarkan sama ada kepingan yang diberikan diisih atau tidak berdasarkan nilai Boolean yang dikembalikan.

Output memaparkan palsu untuk susunan pengisihan sepotong integer kerana ia tidak diisih:

Contoh 6: Hiris Isih Terbalik Golang

Selanjutnya, menggunakan fungsi sortReverse() dan sortStringSlice() daripada pakej isihan dalam Go, kita boleh membalikkan-isih sepotong rentetan. Atur cara berikut menunjukkan kerja jenis.Reverse() fungsi:

pakej utama
import (
'fmt'
'isih'
)
fungsi utama () {
vokalSlice := [] tali { 'Ia adalah' , 'a' , 'saya' , 'dalam' , 'O' }
fmt . Println ( 'Sebelum menyusun :' , vokalSlice )
menyusun . Isih ( menyusun . terbalik ( menyusun . StringSlice ( vokalSlice )))
fmt . Println ( 'Selepas  mengisih :' , vokalSlice )
}

Kita mulakan dengan mentakrifkan sepotong rentetan 'vowelSlice' yang mengandungi vokal 'e', 'a', 'i', 'u', dan 'o'. Kandungan awal hirisan rentetan yang ditentukan dicetak terlebih dahulu menggunakan fungsi 'cetak'. Seterusnya, operasi pengisihan dilakukan menggunakan fungsi sort.Sort() dengan sort.Reverse() dan sort.StringSlice() berfungsi sebagai argumen. Di sini, 'sort.Reverse()' mencipta jenis baharu yang membalikkan susunan unsur. Ia mengambil jenis 'sort.StringSlice' sebagai hujahnya yang menukarkan vowelSlice menjadi jenis boleh diisih.

Output di sini memaparkan vokal dalam susunan abjad terbalik:

Kesimpulan

Kami menyelidiki pelbagai fungsi pengisihan dengan contoh yang menyusun kepingan yang disediakan. Kami juga membincangkan tentang pengisihan sub-keping dan menyemak sama ada hirisan sudah diisih. Oleh itu, kami boleh memanfaatkan keupayaan pakej isihan untuk menangani pelbagai cabaran pengisihan dalam projek Go mereka.