Exemplos de fatia de classificação de golang

Exemplos De Fatia De Classificacao De Golang



A classificação é uma operação de programação fundamental que inclui colocar os elementos em uma ordem específica. O pacote sort, disponibilizado pela biblioteca oficial do Go, inclui diversas funções para ordenar rapidamente as fatias. A classificação de fatias é uma tarefa comum em muitos aplicativos, desde a organização dos dados para apresentação até a otimização dos algoritmos de pesquisa. Este artigo explora as diferentes técnicas de classificação e demonstra seu uso em Go usando o pacote sort.

Exemplo 1: fatia de classificação de Golang em ordem crescente

A função “sort.Slice()” é a principal função em Go que reorganiza os elementos da fatia em ordem crescente ou decrescente. Considere a seguinte ilustração onde a fatia é organizada em ordem crescente:

pacote principal
importar (
'fmt'
'organizar'
)
função principal () {
fatia uniforme := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'Fatia não classificada:' , fatia uniforme )
organizar . Fatiar ( fatia uniforme , função ( eu , j int ) bool {
retornar fatia uniforme [ eu ] < mesmoSlice [ j ]
})
fmt . Println ( 'fatia ordenada:' , fatia uniforme )
}

No início da função main(), definimos a fatia evenSlice com os valores {10, 2, 8, 4, 0, 6}. Essa fatia representa uma coleção de números pares inicialmente não classificados. Para classificar a fatia evenSlice, a função sort.Slice() é empregada com a fatia. Dentro da função sort.Slice(), uma função de classificação é fornecida como um argumento. Esta função determina a ordem de classificação comparando os dois elementos da fatia nos índices “i” e “j”. Se evenSlice[i] for menor que evenSlice[j], ele retornará verdadeiro; caso contrário, retorna falso. A função sort.Slice() usa esta função de comparação para reorganizar os elementos da fatia “evenSlice” em ordem crescente.







Os resultados da fatia classificada em ordem crescente são gerados na seguinte tela de saída:





Exemplo 2: Fatia de parte de classificação de Golang

Em seguida, a classificação é aplicada à subfatia da fatia especificada em ordem crescente usando a função sort.Slice() em Go.





pacote principal
importar (
'fmt'
'organizar'
)
função principal () {
n := [] int { 9 , 7 , 3 , 5 }
começar := 0
fim := 3
organizar . Fatiar ( n [ começar : fim ], função ( eu , j int ) bool {
retornar n [ começar + eu ] < n [ começar + j ]
})
fmt . Println ( n )
}

Inicialmente, criamos a fatia “n” com os valores [9, 7, 3, 5]. Além disso, duas variáveis, “start” e “end”, são definidas como 0 e 3, respectivamente. Essas variáveis ​​definem o intervalo de índices na “n” fatia que será ordenada. A função “sort.Slice()” é então chamada com a sub-fatia “n[start:end]” como primeiro argumento. Esta sub-fatia contém os elementos de “n” dentro do intervalo especificado. Depois disso, uma função de classificação é fornecida como o segundo argumento dentro da função sort.Slice().

Aqui, essa função recebe dois índices, 'i' e 'j', que representam os elementos dentro da sub-fatia. Para comparar os elementos dentro da sub-fatia, a função de ordenação acessa os elementos correspondentes na fatia original usando o início offset. Ele compara n[início+i] e n[início+j]. Em seguida, a função sort.Slice() usa a função de classificação fornecida para reorganizar os elementos dentro da subfatia em ordem crescente.



A saída a seguir exibe que os elementos dentro do intervalo especificado (start to end-1) são classificados e os elementos fora do intervalo permanecem inalterados:

Exemplo 3: Fatia de número inteiro de classificação de Golang usando a função Sort.Ints()

Além disso, o mais conveniente para classificar as fatias de números inteiros é a função sort.Ints() sem a necessidade de implementar os métodos de classificação personalizados. Ele atua diretamente em fatias inteiras e realiza uma classificação no local. O programa a seguir classifica os inteiros especificados:

pacote principal
importar (
'fmt'
'organizar'
)
função principal () {
Fatia Int := [] int { 10 , 13 , quinze , onze , 14 , 12 }
fmt . Println ( 'Fatia não classificada:' , Fatia Int )
organizar . Ints ( Fatia Int )
fmt . Println ( 'fatia ordenada:' , Fatia Int )
}

Primeiro, declaramos e inicializamos a fatia “IntSlice” com os valores [10, 13, 15, 11, 14, 12] que representam uma coleção de inteiros inicialmente não classificados. Em seguida, a função sort.Ints() é chamada com a fatia “IntSlice” como argumento para ordenar a “IntSlice”. A função sort.Ints() neste caso classifica internamente cada parte da fatia de acordo com um algoritmo de classificação otimizado. Ele modifica a fatia original diretamente, reorganizando seus elementos em uma ordem classificada.

A saída a seguir primeiro mostra que a fatia não classificada é exibida primeiro, seguida pela fatia classificada:

Exemplo 4: fatia de string de classificação de Golang

Go também oferece a função sort.Strings() do pacote sort que é usado para classificar uma fatia de strings em uma ordem específica. Aqui, o seguinte programa ajuda a classificar a fatia de strings:

pacote principal
importar (
'fmt'
'organizar'
)
função principal () {
strSl := [] corda { 'golã' , 'Pitão' , 'Java' , 'perl' , 'datilografado' }
organizar . Cordas ( strSl )
fmt . Println ( strSl )
}

Primeiro estabelecemos a fatia “strSl” com os valores [“golang”, “python”, “java”, “perl”, “typescript”] que não são classificados. Depois disso, classificamos a fatia “strSl” com a função sort.Strings() que classifica os elementos da fatia em ordem lexicográfica. Esta função modifica a fatia original diretamente, reorganizando seus elementos em ordem de classificação com base em seus valores ASCII.

A saída classifica a fatia de string de maneira crescente, conforme exibido a seguir:

Exemplo 5: fatia de classificação de verificação de Golang usando a função IntAreSort()

No entanto, com a função sort.IntsAreSorted() de Go, podemos verificar se uma determinada fatia de inteiros está classificada em ordem crescente ou não. Considere o seguinte programa de exemplo da função IntAreSort() para a fatia fornecida:

pacote principal
importar (
'fmt'
'organizar'
)
função principal () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'fatias:' )
fmt . Println ( 'Fatia não classificada: ' , sl )
resultado := organizar . IntsAreSorted ( sl )
fmt . Println ( ' \n Resultado:' )
fmt . Println ( 'O Slice está classificado?: ' , resultado )
}

Primeiro, uma fatia não classificada de inteiros aleatórios é definida como “sl”. Esta fatia contém uma coleção de números inteiros em nenhuma ordem específica. Em seguida, chamamos a função sort.IntsAreSorted() e passamos a fatia “sl” como argumento. Esta função fornece um resultado booleano que indica se a entrada da fatia está ou não organizada em ordem crescente. Em seguida, a função fmt.Println() imprime os resultados que informam se a fatia fornecida está classificada ou não com base no valor booleano retornado.

A saída exibe falso para a ordem de classificação de uma fatia de números inteiros, pois não está classificada:

Exemplo 6: fatia de classificação reversa de Golang

Além disso, usando as funções sortReverse() e sortStringSlice() do pacote sort em Go, podemos classificar inversamente uma fatia de strings. O programa a seguir demonstra o funcionamento da função sort.Reverse():

pacote principal
importar (
'fmt'
'organizar'
)
função principal () {
vogalSlice := [] corda { 'e' , 'a' , 'eu' , 'em' , 'o' }
fmt . Println ( 'Antes de classificar:' , vogalSlice )
organizar . Organizar ( organizar . Reverter ( organizar . StringSlice ( vogalSlice )))
fmt . Println ( 'Depois de classificar:' , vogalSlice )
}

Começamos definindo uma fatia da string “vowelSlice” que contém as vogais “e”, “a”, “i”, “u” e “o”. O conteúdo inicial da fatia especificada de strings é impresso primeiro usando a função “print”. Em seguida, a operação de classificação é executada usando a função sort.Sort() com as funções sort.Reverse() e sort.StringSlice() como argumentos. Aqui, o “sort.Reverse()” cria um novo tipo que inverte a ordem dos elementos. Ele usa o tipo “sort.StringSlice” como seu argumento, que converte o vogalSlice em um tipo classificável.

A saída aqui exibe as vogais em ordem alfabética reversa:

Conclusão

Nós nos aprofundamos em várias funções de classificação com exemplos que classificam a fatia fornecida. Também abordamos a classificação de subfatias e a verificação se uma fatia já está classificada. Portanto, podemos aproveitar os recursos do pacote de classificação para enfrentar uma ampla gama de desafios de classificação em seus projetos Go.