1. Classificação de Bolhas
Dois números são comparados em tamanho e trocados em pares, como bolhas na água, o número maior afunda e o menor aparece.
Descrição do algoritmo :
1. Compare elementos adjacentes. Se o primeiro for maior que o segundo, troque os dois;
2. Faça o mesmo trabalho para cada par de elementos adjacentes, desde o primeiro par no início até o último par no final, de modo que o último elemento seja o maior número;
3. Repita os passos acima para todos os elementos, exceto o último;
4. Repita as etapas 1 a 3 até que a classificação seja concluída.
Diagrama de demonstração da animação:
código oc :
- (NSArray*)bubbleSort:(NSArray*)temArr{
NSMutableArray *arr = [NSMutableArray arrayWithArray: temArr];
Contagem NSInteger = arr.count;
for (int i = 0; i < count; i++) { // número de loops
for (int j = 0; j < count - 1 - i; j++) { // tempos de comparação
if ([arr[j] intValue] > [arr[j+1] intValue]) {
NSNumber *temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
retornar arr;
}
Código Swift:
func bubbleSort(temArr: [Int] ) -> [Int] {
if temArr.count == 0 {
retornar []
}
var arr = temArray
let count = arr.count
for i in 0..<count { // número de loops
for j in 0..<count - 1 - i { // número de comparações
if (arr[j] > arr[j + 1] ) {
deixe temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
retorno arr
}
2. Classificação rápida
1. Escolha um elemento da sequência como referência.
2. Reorganize a sequência numérica, coloque todos os menores que o benchmark na frente do benchmark e vice-versa (o mesmo tamanho pode estar em qualquer um dos lados) Após a conclusão, o benchmark fica no meio da partição.
3. Classifique as subsequências menores que o elemento de referência e o elemento de referência de chuva forte por meio de chamadas recursivas
Diagrama do processo do algoritmo:
código oc :
// matriz de dados
NSArray *temArr = @[@30,@40, @60, @10, @20, @50];
NSMutableArray *arr = [NSMutableArray arrayWithArray:temArr];
[self quickSort:arr baixo:0 hight: arr.count - 1];
NSLog(@"%@",arr);
- (void)quickSort:(NSMutableArray*)temArr baixo: (NSInteger)baixo alto: (NSInteger)alto{
if (baixo >= alto) {
retornar;
}
NSInteiro i = baixo;
NSInteiro j = altura;
id key = temArr[i]; // base de referência
enquanto (i < j) {
while (i < j && [temArr[j] intValue] >= [key intValue]) { // j dígitos à direita são maiores que o número base e a posição permanece inalterada
j--;
}
if (i == j) { // As posições de i e j coincidem para finalizar este ciclo Quando a chave for o menor número no momento, aparecerá a situação de i=j.
quebrar;
}
temArr[i] = temArr[j]; //O dígito j à direita é menor que a posição base e a troca do dígito i
while (i < j && [temArr[i] intValue] <= [chave intValue]) {
i++;
}
if (i == j) { // Quando a chave for o maior número (antes de m[j]), i=j aparecerá
quebrar;
}
temArr[j] = temArr[i];
}
temArr[i] = key; // Quando i e j coincidem, o ciclo atual termina e a chave é colocada na posição de i (o número à esquerda é menor que a chave e o número à direita é maior do que a chave)
// Os lados esquerdo e direito da chave são respectivamente classificados rapidamente
[self quickSort:temArr low:low hight:i - 1]; // recursão à esquerda
[self quickSort:temArr low:i + 1 hight:hight]; // recursão à direita
}
Código rápido :
var array = [30,40,60,10,20,50]
quickSort(arr: &array, baixo: 0, hight: array.count - 1 )
imprimir(array)
func quickSort(arr: inout [Int], baixo: Int, alto: Int ) {
if baixo >= alto { // condição final recursiva
retornar
}
var i = baixo;
var j = altura;
let key = arr[i] // base
enquanto i < j{
// Inicia a comparação pela direita, a posição do número maior que a chave permanece inalterada
enquanto i < j && arr[j] >= tecla {
j -= 1
}
// Enquanto houver um número menor que key, coloque este número na posição de i à esquerda
arr[i] = arr[j]
// Inicia a comparação pela esquerda, a posição do número menor que a chave permanece inalterada
enquanto i < j && arr[i] <= tecla {
eu += 1
}
// Enquanto houver um número maior que a chave, coloque esse número na posição j à direita
arr[j] = arr[i]
}
arr[i] = chave // Quando i e j coincidem, o ciclo atual termina e a chave é colocada na posição de i (os números à esquerda são menores que a chave e os números à direita são maiores que a chave)
// Os lados esquerdo e direito da chave são respectivamente classificados rapidamente
quickSort(arr: &arr, low: low, hight: i - 1) // esquerda recursiva
quickSort(arr: &arr, low: i + 1, hight: hight) // recursão à direita
}
3. Ordenação por Inserção
1. A partir do primeiro elemento, pode-se considerar que o elemento foi ordenado;
2. Retire o próximo elemento e digitalize de trás para a frente na sequência de elementos classificados;
3. Se o elemento (ordenado) for maior que o novo elemento, mova o elemento para a próxima posição;
4. Repita a etapa 3 até encontrar a posição em que o elemento classificado é menor ou igual ao novo elemento;
5. Após inserir o novo elemento na posição;
6. Repita as etapas 2 a 5.
Diagrama de demonstração da animação:
Código OC:
- (NSArray*)insertionSort:(NSArray*)temArr{
NSMutableArray *arr = [NSMutableArray arrayWithArray: temArr];
Contagem NSInteger = arr.count;
for (int i = 0; i < count; i++) { // número de loops
// Encontre a posição apropriada de arr[i] da parte classificada para inserir
for (int j = i; j > 0; j--) { // loop interno
if ([arr[j-1] intValue] > [arr[j] intValue]) {
NSNumber *temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
} outro {
// Como a frente está classificada, o loop interno pode ser encerrado quando a condição de comparação não for atendida (deve ser maior que o valor anterior)
quebrar;
}
}
}
retornar arr;
}
Código Swift:
func insertSort(temArr: [Int] ) -> [Int] {
if temArr.count == 0 {
retornar []
}
var arr = temArray
let count = arr.count
for i in 0..<count { // número de trocas
// Encontre a posição apropriada de arr[i] da parte classificada para inserir
era j = eu
enquanto (j > 0) {
if (arr[j-1] > arr[j] ) {
deixe temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
} outro {
//Como a frente está classificada, o loop interno pode terminar enquanto a condição de comparação não for atendida, se for definitivamente maior que o valor anterior
quebrar;
}
j-=1;
}
}
retorno arr
}
4. Classificação de shell (classificação de shell)
A classificação de Hill também é uma classificação por inserção, que é uma versão mais eficiente da classificação por inserção simples aprimorada, também conhecida como classificação incremental de redução, e esse algoritmo é um dos primeiros algoritmos a romper O(n2). Difere da classificação por inserção porque compara primeiro os elementos que estão mais distantes
Descrição do algoritmo :
1. Selecione uma sequência incremental t1, t2, ..., tk, onde ti>tj, tk=1;
2. De acordo com o número de sequência incremental k, ordene a sequência k vezes;
3. Para cada ordenação, de acordo com o correspondente incremento ti, a coluna a ser ordenada é dividida em várias subsequências de comprimento m, e ordenação por inserção direta é realizada em cada subtabela. Somente quando o fator de incremento é 1, toda a sequência é tratada como uma tabela e o comprimento da tabela é o comprimento de toda a sequência.
Diagrama de demonstração de animação :
Código OC:
- (NSArray*)shellSort:(NSArray*)temArr{
NSMutableArray *arr = [NSMutableArray arrayWithArray: temArr];
NSInteger count = arr.count; NSInteger gap = count / 2; //Coeficiente de intervalo
while(gap > 0) { // o papel de if
for (NSInteger i = gap; i < count; i++) { // Número de passes -- agrupamento
NSNumber *temp = arr[i];
NSInteger preIndex = i - lacuna;
while (preIndex >= 0 && [arr[preIndex] intValue] > [temp intValue]) { // determina a troca de posição
arr[pré-índice + gap] = arr[pré-índice];
preÍndice -= intervalo;
}
arr[preIndex + gap] = temp;
}
intervalo /= 2;
}
retornar arr;
}
Código Swift:
func shellSort(temArr: [Int] ) -> [Int] {
if temArr.count == 0 {
retornar []
}
var arr = temArray
let count = arr.count
var gap = count / 2 // Coeficiente de gap
while gap > 0 { // o papel de if
for i in gap..<count { // número de vezes -- agrupamento
let temp = arr[i]
var preIndex = i - intervalo
while preIndex >= 0 && arr[preIndex] > temp { // determina a troca de posição
arr[pré-índice + gap] = arr[pré-índice]
preÍndice -= intervalo
}
arr[preIndex + gap] = temp
}
lacuna /= 2
}
retorno arr
}
5. Selecione Classificar
A classificação por seleção é um método de classificação intuitivo, que encontra o maior (ou menor) valor desde o início e transpõe os elementos classificados. Os elementos não classificados continuam a repetir a operação de classificação. até ser classificado. A complexidade do tempo de loop duplo é O(n^2)
Diagrama de demonstração da animação:
Diagrama do processo do algoritmo:
Código OC:
// matriz de dados
NSArray *arr = @[@3,@44, @38, @5, @47, @15, @36, @26, @27, @2, @46, @4, @19, @50, @48 ];
// chamada de método
NSArray *sortArray = [self selectSort:arr];
NSLog(@"%@",sortArray);
// seleciona o código de classificação
- (NSArray *)selectSort:(NSArray*)temArr{
NSMutableArray *arr = [NSMutableArray arrayWithArray: temArr];
Contagem NSInteger = arr.count;
for (int i = 0; i < count; i++) { // número de trocas
// Primeiro assuma que o índice do menor número é i em cada loop
int minIndex = i; // cada elemento é comparado com os demais elementos não classificados
for (int j = i + 1; j < contagem; j++) {
if ([arr[minIndex] intValue] > [arr[j] intValue]) { //encontra o número mínimo
minIndex = j; //salva o índice mínimo
}
}
//Após uma rodada de loops, você pode encontrar o índice do primeiro valor mínimo e, em seguida, colocar o valor mínimo na posição de i
NSNumber *temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
retornar arr;
}
Código Swift:
// array a ser ordenado
var temArray = [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]
// chama o método
let sortArray = selectSort(temArr: temArray)
// Define o método de ordenação da seleção
func selectSort2(temArr: [Int] ) -> [Int] {
if temArr.count == 0 {
retornar []
}
var arr = temArray
let count = arr.count
para i em 0..<count {
// número de trocas
// Primeiro assuma que o índice do menor número é i em cada loop
var minIndex = i // cada elemento é comparado com os demais elementos não classificados
para j em i+1..<count {
if arr[minIndex] > arr[j] { //encontra o número mínimo
minIndex = j // salva o índice mínimo
}
}
//Após uma rodada de loops, você pode encontrar o índice do primeiro valor mínimo e, em seguida, colocar o valor mínimo na posição de i
let temp = arr[i]
arr[i] = arr[minIndex]
arr[minIndex] = temp
}
retorno arr
}
6. Classificação de heap
Análise de ideias:
O heap é uma árvore binária completa com as seguintes propriedades: o valor de cada nó é maior ou igual ao valor de seus nós filho esquerdo e direito, chamados de big top heap; ou o valor de cada nó é menor ou igual ao valor de seus nós filhos esquerdo e direito, conhecido como pequena pilha superior
Grande pilha superior: arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
Heap superior pequeno: arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]
A ideia básica da ordenação do heap é : construir a sequência a ser ordenada em um grande heap superior, neste momento, o valor máximo de toda a sequência é o nó raiz no topo do heap. Troque-o com o elemento final e o final é o valor máximo. Em seguida, reconstrua os n-1 elementos restantes em uma pilha, de modo que o segundo menor valor de n elementos seja obtido. Então, execução repetida, você pode obter uma sequência ordenada
Exibição de animação:
Código OC:
- (void)heapSort:(NSMutableArray*)arr{
//1. Construa uma grande pilha superior
for (NSInteger i = arr.count/2 -1 ; i >= 0; i--) {
//Ajusta a estrutura do primeiro nó não folha de baixo para cima, da direita para a esquerda
[auto-ajusteHeap:arr i:i comprimento:arr.count];
}
//2. Ajuste a estrutura da pilha + troque o elemento superior e o elemento final da pilha
for (NSInteger j = arr.count - 1; j > 0; j--) {
//Troca o elemento superior do heap pelo elemento final
NSNumber *temp = arr[0];
arr[0] = arr[j];
arr[j] = temperatura;
// reajusta a pilha
[auto-ajusteHeap:arr i:0 comprimento:j];
}
}
/** Ajuste do big top heap (somente o processo de ajuste, baseado na construção do big top heap) */
- (void)adjustHeap:(NSMutableArray*)arr i: (NSInteger)i comprimento: (NSInteger)comprimento{
NSNumber *temp = arr[i];
for (NSInteger k = i*2+1; k < comprimento; k = k*2+1) {
//Se o filho certo for maior que o filho do, aponte para o filho certo
if (k+1 < comprimento && [arr[k] intValue]< [arr[k + 1] intValue]) {
k++;
}
//Se o filho maior for maior que o nó atual, atribua o filho mais velho ao nó atual, modifique o nó atual para ser o nó filho mais velho e, em seguida, desça.
if ([arr[k] intValue] > [temp intValue]) {
arr[i] = arr[k];
i = k;
} outro {
quebrar;
}
}
//Coloque a temperatura na posição final
arr[i] = temperatura;
}