Παράδειγμα 1: Ταξινόμηση φέτας Golang σε αύξουσα σειρά
Η συνάρτηση 'sort.Slice()' είναι η κύρια συνάρτηση στο Go που αναδιατάσσει τα στοιχεία του slice σε αύξουσα ή φθίνουσα σειρά. Λάβετε υπόψη την παρακάτω εικόνα όπου η φέτα είναι διατεταγμένη σε αύξουσα σειρά:
πακέτο κύριοςεισαγωγή (
'fmt'
'είδος'
)
func κύριος () {
evenSlice := [] ενθ { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Μη ταξινομημένη φέτα:' , evenSlice )
είδος . Φέτα ( evenSlice , func ( Εγώ , ι ενθ ) bool {
ΕΠΙΣΤΡΟΦΗ evenSlice [ Εγώ ] < evenSlice [ ι ]
})
fmt . Println ( 'Ταξινομημένη φέτα:' , evenSlice )
}
Στην αρχή της συνάρτησης main(), ορίζουμε το slice evenSlice με τις τιμές {10, 2, 8, 4, 0, 6}. Αυτό το κομμάτι αντιπροσωπεύει μια συλλογή ζυγών αριθμών που αρχικά δεν έχουν ταξινομηθεί. Για να ταξινομήσετε το κομμάτι evenSlice, χρησιμοποιείται η συνάρτηση sort.Slice() με το slice. Μέσα στη συνάρτηση sort.Slice(), παρέχεται μια συνάρτηση ταξινόμησης ως όρισμα. Αυτή η συνάρτηση καθορίζει τη σειρά ταξινόμησης συγκρίνοντας τα δύο στοιχεία της τομής στους δείκτες «i» και «j». Εάν το evenSlice[i] είναι μικρότερο από το evenSlice[j], επιστρέφει true. διαφορετικά, επιστρέφει ψευδής. Η συνάρτηση sort.Slice() χρησιμοποιεί αυτή τη συνάρτηση σύγκρισης για να αναδιατάξει τα στοιχεία της φέτας 'evenSlice' σε αύξουσα σειρά.
Τα αποτελέσματα της ταξινομημένης τομής κατά αύξουσα σειρά δημιουργούνται στην ακόλουθη οθόνη εξόδου:
Παράδειγμα 2: Ταξινόμηση Golang Part Slice
Στη συνέχεια, η ταξινόμηση εφαρμόζεται στο υποτμήμα της καθορισμένης φέτας με αύξουσα σειρά χρησιμοποιώντας τη συνάρτηση sort.Slice() στο Go.
πακέτο κύριος
εισαγωγή (
'fmt'
'είδος'
)
func κύριος () {
n := [] ενθ { 9 , 7 , 3 , 5 }
αρχή := 0
τέλος := 3
είδος . Φέτα ( n [ αρχή : τέλος ], func ( Εγώ , ι ενθ ) bool {
ΕΠΙΣΤΡΟΦΗ n [ αρχή + Εγώ ] < n [ αρχή + ι ]
})
fmt . Println ( n )
}
Αρχικά, δημιουργούμε το slice «n» με τις τιμές [9, 7, 3, 5]. Επιπλέον, δύο μεταβλητές, 'start' και 'end', ορίζονται σε 0 και 3, αντίστοιχα. Αυτές οι μεταβλητές ορίζουν το εύρος των δεικτών στο slice 'n' που θα ταξινομηθεί. Η συνάρτηση 'sort.Slice()' καλείται στη συνέχεια με το δευτερεύον τμήμα 'n[start:end]' ως πρώτο όρισμα. Αυτό το υποτμήμα περιέχει τα στοιχεία του 'n' εντός του καθορισμένου εύρους. Μετά από αυτό, δίνεται μια συνάρτηση ταξινόμησης ως το δεύτερο όρισμα μέσα στη συνάρτηση sort.Slice().
Εδώ, αυτή η συνάρτηση λαμβάνει δύο δείκτες, 'i' και 'j', που αντιπροσωπεύουν τα στοιχεία εντός του υποτμήματος. Για να συγκρίνει τα στοιχεία εντός του υποτμήματος, η συνάρτηση ταξινόμησης έχει πρόσβαση στα αντίστοιχα στοιχεία στην αρχική τομή χρησιμοποιώντας την αρχή Μετατόπιση Συγκρίνει τα n[start+i] και n[start+j] Στη συνέχεια, η συνάρτηση sort.Slice() χρησιμοποιεί την παρεχόμενη συνάρτηση ταξινόμησης για να αναδιατάξει τα στοιχεία εντός του υποτμήματος σε αύξουσα σειρά.
Η ακόλουθη έξοδος δείχνει ότι τα στοιχεία εντός του καθορισμένου εύρους (από την αρχή έως το τέλος-1) είναι ταξινομημένα και τα στοιχεία εκτός του εύρους παραμένουν αμετάβλητα:
Παράδειγμα 3: Golang Ταξινόμηση ακέραιου τεμαχίου με χρήση της συνάρτησης Sort.Ints()
Επιπλέον, η πιο βολική για την ταξινόμηση των τμημάτων των ακεραίων είναι η λειτουργία sort.Ints() χωρίς την ανάγκη εφαρμογής των προσαρμοσμένων μεθόδων ταξινόμησης. Δρα απευθείας σε φέτες ακεραίων και εκτελεί μια επιτόπια ταξινόμηση. Το παρακάτω πρόγραμμα ταξινομεί τους καθορισμένους ακέραιους αριθμούς:
πακέτο κύριοςεισαγωγή (
'fmt'
'είδος'
)
func κύριος () {
IntSlice := [] ενθ { 10 , 13 , δεκαπέντε , έντεκα , 14 , 12 }
fmt . Println ( 'Μη ταξινομημένη φέτα:' , IntSlice )
είδος . Ints ( IntSlice )
fmt . Println ( 'Ταξινομημένη φέτα:' , IntSlice )
}
Αρχικά, δηλώνουμε και αρχικοποιούμε το slice 'IntSlice' με τις τιμές [10, 13, 15, 11, 14, 12] που αντιπροσωπεύουν μια συλλογή ακεραίων αριθμών που αρχικά δεν ταξινομούνται. Στη συνέχεια, η συνάρτηση sort.Ints() καλείται με το slice 'IntSlice' ως όρισμα για την ταξινόμηση του 'IntSlice'. Η συνάρτηση sort.Ints() σε αυτήν την περίπτωση ταξινομεί εσωτερικά κάθε μέρος του slice σύμφωνα με έναν βελτιστοποιημένο αλγόριθμο ταξινόμησης. Τροποποιεί απευθείας το αρχικό κομμάτι, αναδιατάσσοντας τα στοιχεία του σε ταξινομημένη σειρά.
Η ακόλουθη έξοδος δείχνει πρώτα ότι εμφανίζεται πρώτα το μη ταξινομημένο κομμάτι, ακολουθούμενο από το ταξινομημένο κομμάτι:
Παράδειγμα 4: Φέτα χορδής ταξινόμησης Golang
Το Go προσφέρει επίσης τη συνάρτηση sort.Strings() του πακέτου ταξινόμησης που χρησιμοποιείται για την ταξινόμηση μιας φέτας συμβολοσειρών με συγκεκριμένη σειρά. Εδώ, το ακόλουθο πρόγραμμα βοηθά στην ταξινόμηση του slice των συμβολοσειρών:
πακέτο κύριοςεισαγωγή (
'fmt'
'είδος'
)
func κύριος () {
strSl := [] σειρά { 'γκολάν' , 'Πύθων' , 'Ιάβα' , 'perl' , 'δακτυλόγραφο' }
είδος . Χορδές ( strSl )
fmt . Println ( strSl )
}
Δημιουργήσαμε πρώτα το slice 'strSl' με τις τιμές ['golang', 'python', 'java', 'perl', 'typescript'] που δεν είναι ταξινομημένες. Μετά από αυτό, ταξινομούμε το slice “strSl” με τη συνάρτηση sort.Strings() που ταξινομεί τα στοιχεία του slice με λεξικογραφική σειρά. Αυτή η συνάρτηση τροποποιεί απευθείας το αρχικό slice, αναδιατάσσοντας τα στοιχεία του σε ταξινομημένη σειρά με βάση τις τιμές ASCII τους.
Η έξοδος ταξινομεί τη φέτα συμβολοσειράς με αύξοντα τρόπο, όπως φαίνεται στα ακόλουθα:
Παράδειγμα 5: Golang Check Sort Slice με χρήση της συνάρτησης IntAreSort()
Ωστόσο, με τη συνάρτηση sort.IntsAreSorted() του Go, μπορούμε να ελέγξουμε εάν μια δεδομένη φέτα ακεραίων είναι ταξινομημένη σε αύξουσα σειρά ή όχι. Εξετάστε το ακόλουθο παράδειγμα προγράμματος της συνάρτησης IntAreSort() για το δεδομένο slice:
πακέτο κύριοςεισαγωγή (
'fmt'
'είδος'
)
func κύριος () {
sl := [] ενθ { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'Φέτες:' )
fmt . Println ( 'Μη ταξινομημένη φέτα:' , sl )
αποτέλεσμα := είδος . IntsAreSorted ( sl )
fmt . Println ( ' \n Αποτέλεσμα:' )
fmt . Println ( 'Δίνεται το Slice ταξινομημένο;' , αποτέλεσμα )
}
Πρώτον, ένα μη ταξινομημένο κομμάτι τυχαίων ακεραίων ορίζεται ως 'sl'. Αυτό το κομμάτι περιέχει μια συλλογή ακεραίων αριθμών χωρίς συγκεκριμένη σειρά. Στη συνέχεια, καλούμε τη συνάρτηση sort.IntsAreSorted() και περνάμε το slice 'sl' ως όρισμα. Αυτή η συνάρτηση παρέχει ένα αποτέλεσμα Boolean που υποδεικνύει εάν η είσοδος slice είναι διατεταγμένη σε αύξουσα σειρά ή όχι. Στη συνέχεια, η συνάρτηση fmt.Println() εκτυπώνει τα αποτελέσματα που βγάζει εάν το δεδομένο slice είναι ταξινομημένο ή όχι με βάση την επιστρεφόμενη τιμή Boole.
Η έξοδος εμφανίζει false για τη σειρά ταξινόμησης μιας φέτας ακεραίων καθώς δεν είναι ταξινομημένη:
Παράδειγμα 6: Φέτα αντίστροφης ταξινόμησης Golang
Επιπλέον, χρησιμοποιώντας τις συναρτήσεις sortReverse() και sortStringSlice() από το πακέτο ταξινόμησης στο Go, μπορούμε να ταξινομήσουμε αντίστροφα ένα slice από συμβολοσειρές. Το παρακάτω πρόγραμμα δείχνει τη λειτουργία της συνάρτησης sort.Reverse():
πακέτο κύριοςεισαγωγή (
'fmt'
'είδος'
)
func κύριος () {
φωνήενΦέτα := [] σειρά { 'Είναι' , 'ένα' , 'Εγώ' , 'σε' , 'Ο' }
fmt . Println ( 'Πριν από την ταξινόμηση:' , φωνήενΦέτα )
είδος . Είδος ( είδος . ΑΝΤΙΣΤΡΟΦΗ ( είδος . StringSlice ( φωνήενΦέτα )))
fmt . Println ( 'Μετά από ταξινόμηση :' , φωνήενΦέτα )
}
Ξεκινάμε ορίζοντας ένα κομμάτι της συμβολοσειράς 'vowelSlice' που περιέχει τα φωνήεντα 'e', 'a', 'i', 'u' και 'o'. Το αρχικό περιεχόμενο της καθορισμένης φέτας συμβολοσειρών εκτυπώνεται πρώτα χρησιμοποιώντας τη λειτουργία «εκτύπωση». Στη συνέχεια, η λειτουργία ταξινόμησης εκτελείται χρησιμοποιώντας τη συνάρτηση sort.Sort() με τις συναρτήσεις sort.Reverse() και sort.StringSlice() ως ορίσματα. Εδώ, το 'sort.Reverse()' δημιουργεί έναν νέο τύπο που αντιστρέφει τη σειρά των στοιχείων. Παίρνει τον τύπο 'sort.StringSlice' ως όρισμα που μετατρέπει το vowelSlice σε ταξινομήσιμο τύπο.
Η έξοδος εδώ εμφανίζει τα φωνήεντα με αντίστροφη αλφαβητική σειρά:
συμπέρασμα
Εμβαθύναμε σε διάφορες συναρτήσεις ταξινόμησης με παραδείγματα που ταξινομούν την παρεχόμενη φέτα. Καλύψαμε επίσης την ταξινόμηση των δευτερευουσών τμημάτων και τον έλεγχο εάν μια φέτα είναι ήδη ταξινομημένη. Ως εκ τούτου, μπορούμε να αξιοποιήσουμε τις δυνατότητες του πακέτου ταξινόμησης για να αντιμετωπίσουμε ένα ευρύ φάσμα προκλήσεων ταξινόμησης στα έργα Go τους.