Ví dụ 1: Sắp xếp Golang Slice theo thứ tự tăng dần
Hàm “sort.Slice()” là hàm quan trọng nhất trong Go giúp sắp xếp lại các phần tử của lát cắt theo thứ tự tăng dần hoặc giảm dần. Hãy tính đến hình minh họa sau trong đó lát cắt được sắp xếp theo thứ tự tăng dần:
bưu kiện chủ yếunhập khẩu (
'fmt'
'loại'
)
chức năng chủ yếu () {
thậm chíSlice := [] int { 10 , 2 , số 8 , 4 , 0 , 6 }
fmt . Println ( 'Lát cắt chưa được sắp xếp:' , thậm chíSlice )
loại . Lát cắt ( thậm chíSlice , chức năng ( Tôi , j int ) bool {
trở lại thậm chíSlice [ Tôi ] < EvenSlice [ j ]
})
fmt . Println ( 'Lát đã sắp xếp:' , thậm chíSlice )
}
Khi bắt đầu hàm main(), chúng tôi xác định lát cắt chẵn với các giá trị {10, 2, 8, 4, 0, 6}. Lát cắt này đại diện cho một tập hợp các số chẵn ban đầu chưa được sắp xếp. Để sắp xếp lát cắt evenSlice, hàm sort.Slice() được sử dụng với lát cắt. Bên trong hàm sort.Slice(), một hàm sắp xếp được cung cấp dưới dạng đối số. Hàm này xác định thứ tự sắp xếp bằng cách so sánh hai phần tử của lát cắt tại các chỉ số “i” và “j”. Nếu evenSlice[i] nhỏ hơn evenSlice[j], nó sẽ trả về true; ngược lại, nó trả về false. Hàm sort.Slice() sử dụng hàm so sánh này để sắp xếp lại các phần tử của lát cắt “evenSlice” theo thứ tự tăng dần.
Kết quả của lát cắt được sắp xếp theo thứ tự tăng dần được tạo trong màn hình đầu ra sau:
Ví dụ 2: Golang Sort Part Slice
Tiếp theo, việc sắp xếp được áp dụng cho lát cắt con của lát cắt đã chỉ định theo thứ tự tăng dần bằng cách sử dụng hàm sort.Slice() trong Go.
bưu kiện chủ yếu
nhập khẩu (
'fmt'
'loại'
)
chức năng chủ yếu () {
N := [] int { 9 , 7 , 3 , 5 }
bắt đầu := 0
kết thúc := 3
loại . Lát cắt ( N [ bắt đầu : kết thúc ], chức năng ( Tôi , j int ) bool {
trở lại N [ bắt đầu + Tôi ] < n [ bắt đầu + j ]
})
fmt . Println ( N )
}
Ban đầu, chúng tôi tạo lát cắt “n” với các giá trị [9, 7, 3, 5]. Ngoài ra, hai biến, “bắt đầu” và “kết thúc”, được đặt lần lượt là 0 và 3. Các biến này xác định phạm vi chỉ số trong lát “n” sẽ được sắp xếp. Hàm “sort.Slice()” sau đó được gọi với lát cắt con “n[start:end]” làm đối số đầu tiên. Lát con này chứa các phần tử của “n” trong phạm vi đã chỉ định. Sau đó, một hàm sắp xếp được đưa ra làm đối số thứ hai bên trong hàm sort.Slice().
Tại đây, hàm đó nhận hai chỉ số, “i' và “j”, đại diện cho các phần tử trong lát cắt con. Để so sánh các phần tử trong lát cắt con, hàm sắp xếp truy cập các phần tử tương ứng trong lát cắt ban đầu bằng lệnh bắt đầu offset. Nó so sánh n[start+i] và n[start+j]. Tiếp theo, hàm sort.Slice() sử dụng hàm sắp xếp được cung cấp để sắp xếp lại các phần tử trong lát cắt con theo thứ tự tăng dần.
Đầu ra sau hiển thị rằng các phần tử trong phạm vi đã chỉ định (bắt đầu đến cuối-1) được sắp xếp và các phần tử bên ngoài phạm vi không thay đổi:
Ví dụ 3: Golang Sort Integer Slice sử dụng hàm Sort.Ints()
Ngoài ra, cách thuận tiện nhất để sắp xếp các lát của số nguyên là hàm sort.Ints() mà không cần triển khai các phương pháp sắp xếp tùy chỉnh. Nó hoạt động trực tiếp trên các lát số nguyên và thực hiện sắp xếp tại chỗ. Chương trình sau đây sắp xếp các số nguyên được chỉ định:
bưu kiện chủ yếunhập khẩu (
'fmt'
'loại'
)
chức năng chủ yếu () {
IntSlice := [] int { 10 , 13 , mười lăm , mười một , 14 , 12 }
fmt . Println ( 'Lát cắt chưa được sắp xếp:' , IntSlice )
loại . số nguyên ( IntSlice )
fmt . Println ( 'Lát đã sắp xếp:' , IntSlice )
}
Đầu tiên, chúng tôi khai báo và khởi tạo lát cắt “IntSlice” với các giá trị [10, 13, 15, 11, 14, 12] đại diện cho một tập hợp các số nguyên ban đầu chưa được sắp xếp. Sau đó, hàm sort.Ints() được gọi với lát “IntSlice” làm đối số để sắp xếp “IntSlice”. Hàm sort.Ints() trong trường hợp này sắp xếp bên trong mọi phần của lát cắt theo thuật toán sắp xếp được tối ưu hóa. Nó trực tiếp sửa đổi lát ban đầu, sắp xếp lại các phần tử của nó thành một thứ tự được sắp xếp.
Đầu ra sau đây cho thấy lát cắt chưa sắp xếp được hiển thị trước, tiếp theo là lát cắt đã sắp xếp:
Ví dụ 4: Lát chuỗi sắp xếp Golang
Go cũng cung cấp hàm sort.Strings() của gói sắp xếp được sử dụng để sắp xếp một lát chuỗi theo một thứ tự cụ thể. Ở đây, chương trình sau hỗ trợ sắp xếp lát chuỗi:
bưu kiện chủ yếunhập khẩu (
'fmt'
'loại'
)
chức năng chủ yếu () {
strSl := [] sợi dây { 'golan' , 'trăn' , 'java' , 'perl' , 'bản đánh máy' }
loại . Dây ( strSl )
fmt . Println ( strSl )
}
Trước tiên, chúng tôi thiết lập lát cắt “strSl” với các giá trị [“golang”, “python”, “java”, “perl”, “typescript”] không được sắp xếp. Sau đó, chúng tôi sắp xếp lát cắt “strSl” bằng hàm sort.Strings() để sắp xếp các thành phần của lát cắt theo thứ tự từ điển. Hàm này trực tiếp sửa đổi lát ban đầu, sắp xếp lại các phần tử của nó thành thứ tự được sắp xếp dựa trên các giá trị ASCII của chúng.
Đầu ra sắp xếp lát chuỗi theo cách tăng dần như được hiển thị trong phần sau:
Ví dụ 5: Golang Check Sort Slice Sử dụng Hàm IntAreSort()
Tuy nhiên, với hàm sort.IntsAreSorted() của Go, chúng ta có thể kiểm tra xem một lát số nguyên đã cho có được sắp xếp theo thứ tự tăng dần hay không. Hãy xem xét chương trình ví dụ sau của hàm IntAreSort() cho lát đã cho:
bưu kiện chủ yếunhập khẩu (
'fmt'
'loại'
)
chức năng chủ yếu () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Miếng lát:' )
fmt . Println ( 'Lát chưa phân loại:' , sl )
kết quả := loại . Số nguyên được sắp xếp ( sl )
fmt . Println ( ' \N Kết quả:' )
fmt . Println ( 'Slice đưa ra đã được sắp xếp chưa?:' , kết quả )
}
Đầu tiên, một phần số nguyên ngẫu nhiên chưa được sắp xếp được định nghĩa là “sl”. Lát này chứa một tập hợp các số nguyên không theo thứ tự cụ thể. Tiếp theo, chúng ta gọi hàm sort.IntsAreSorted() và chuyển lát “sl” làm đối số. Hàm này cung cấp kết quả Boolean cho biết đầu vào lát có được sắp xếp theo thứ tự tăng dần hay không. Sau đó, hàm fmt.Println() in kết quả xuất ra liệu lát đã cho có được sắp xếp hay không dựa trên giá trị Boolean được trả về.
Đầu ra hiển thị sai đối với thứ tự sắp xếp của một lát số nguyên khi nó chưa được sắp xếp:
Ví dụ 6: Golang Reverse Sort Slice
Ngoài ra, bằng cách sử dụng các hàm sortReverse() và sortStringSlice() từ gói sắp xếp trong Go, chúng ta có thể sắp xếp đảo ngược một lát chuỗi. Chương trình sau minh họa hoạt động của hàm sort.Reverse():
bưu kiện chủ yếunhập khẩu (
'fmt'
'loại'
)
chức năng chủ yếu () {
nguyên âm := [] sợi dây { 'Nó là' , 'Một' , 'Tôi' , 'TRONG' , 'Ô' }
fmt . Println ( 'Trước khi phân loại:' , nguyên âm )
loại . Loại ( loại . Đảo ngược ( loại . ChuỗiSlice ( nguyên âm )))
fmt . Println ( 'Sau khi sắp xếp:' , nguyên âm )
}
Chúng tôi bắt đầu bằng cách xác định một lát cắt của chuỗi 'nguyên âm' có chứa các nguyên âm 'e', 'a', 'i', 'u' và 'o'. Nội dung ban đầu của lát chuỗi đã chỉ định được in trước bằng cách sử dụng chức năng “in”. Tiếp theo, thao tác sắp xếp được thực hiện bằng hàm sort.Sort() với các hàm sort.Reverse() và sort.StringSlice() làm đối số. Ở đây, “sort.Reverse()” tạo một kiểu mới đảo ngược thứ tự của các phần tử. Nó lấy loại “sort.StringSlice” làm đối số để chuyển đổi nguyên âmSlice thành một loại có thể sắp xếp.
Đầu ra ở đây hiển thị các nguyên âm theo thứ tự bảng chữ cái đảo ngược:
Phần kết luận
Chúng tôi đã đi sâu vào các chức năng sắp xếp khác nhau với các ví dụ sắp xếp lát được cung cấp. Chúng tôi cũng đề cập đến việc sắp xếp các lát cắt phụ và kiểm tra xem một lát cắt đã được sắp xếp chưa. Do đó, chúng ta có thể tận dụng các khả năng của gói sắp xếp để giải quyết nhiều thách thức về sắp xếp trong các dự án Go của họ.