Mesclar ordenação – Wikipedia, um livro de léxico Bitcoin go

T (n) = {Θ (1), n ​​= 1 2 T (n / 2) + Θ (n), n > 1 {\ displaystyle T (n) = {\ início {caso} \ theta (1),&{\ Text {Se}} n {\ Text {= 1}} \\ 2T (n / 2) + \ theta (n),&{\ text {se}} n>{\ text {1}} \ end {cases}}} Complexidade [editar | Editar código de ferro fundido]

T (n) = 1 T 2 (n 2 1) + 1 n T (n) 2 = 1 (2 T (n 2 2) + n 2) + n = 2 T 2 (n 2 2) + 2 n T (n) = 2 2 (T 2 (n 2 3) n + 4) + 2 n = 2 3. T (n 2 3) n + 3 T (n) = 2 h – 1 (T 2 (n 2 h) hn + 2 – 1) + h. n = 2 h. T (N2H) + h. n {\ display {\ begin {tabela} {l} T (n) = 2 ^ {{1}}. T \ left ({\ frac {n} {2 ^ {1}}} à direita) +1. \\ n T (n) = 2 ^ {{1}}. \ Esquerda ({2.T \ left ({\ frac {n} {2 ^ {2}}} \ right) + {\ frac {n} {2}}} \ right) + n = 2 ^ {{2 }}. T \ left ({\ frac {n} {2 ^ {2}}} \ right) + 2.n \\ T (n) = {2 ^ {2}}. Esquerda \ ({2.T \ left ({\ frac {n} {2 ^ {3}}} \ right) + {\ frac {n} {4}}} \ right) + 2.n = 2 ^ { {3}}. T \ left ({\ frac {n} {2 ^ {3}}} \ right) + 3.n \\\ quad \\ vdots T (n) = {2 {^ h-1}}. \ Esquerda ({2.T \ left ({\ frac {n} {2 ^ {h}}} \ right) + {\ frac {n} {2 {^ h-1}}}} direita) + hn = {2 ^ {h}}. T \ links ({\ frac {n} {2 ^ {h}}} \ right) + hn \ end {array}}}


T (n) = 2 h. T (n 2 h) + n H = n T (nn) + n Lg n = n T (1) + n Lg nn = n Θ (1) + n = Lg n = Θ (ng lg n) {\ Exibe o estilo T (n) = {2 ^ {h}}. T \ left ({\ frac {n} {2 ^ {h}}} direita) + nh = nT \ left ({\ frac {n} {n}} \ right) + n. \ N = nT \ left ( 1 \ right) + n. \ Ng n = n. \ Theta (1) + n. \ N \ n \ theta (barra de ferro fundido)

Comparação em Outros de algoritmos e Divisão conquista, Como classificar rapidamente o fusion apresenta um complexo MESMA. Já e comparado com algoritmos, mas Básicos de ordenação por concha comparativo e superior (bolha, inserção e regra de rastreio), o E merge mas Rápido Eficiente when utilizada uma grande quantidade de excrementos. Para entradas pequenas, os algoritmos de ordenação por comparação, mas são são adequados.

Obs. O Classificar bolha apresenta Melhor Caso Como o (n) algoritmo Porque o formato PODE Ser modificado de tal modo que quando Ordenada lista Já estiver, Basta APENAS UMA verificação básica esta Custa O (n). O quick vagem atingir um Tempo de O (N 2) para o Caso in when Específico particionamento E desequilibrado. Observações [editar Editar código de ferro fundido]

Um vácuo de fusão (int Vetor [], int Comeco, int do meio, int FIM) {int = 2 Comeco COM1, COM2 Meio = + 1, 0 = comAux, tam = FIM – Comeco + 1; 3 int * vetAux; 4 vetAux = (int *) malloc (tam * sizeof (int)); 5 6 durante (com1 <= Meio && com2 <= fim) {7 se (vetor [com1] < vetor [com2]) {8 vetAux [comAux] = vetor [com1]; 9 com1 ++; 10} mais {11 vetAux [comAux] = vetor [com2]; 12 com2 ++; 13} 14 comAux ++; 15} 16 17 enquanto (com1 <= meio) {//} [1] [1] 19 comAux ++; Com1 ++; 21} 22 23 durante (com2 <= fim) {// Caso a aja tenha elementos na segunde metade 24 vetAux [comAux] = vetor [com2]; 25 comAux ++; 26 com2 ++; 27} 28 29 para (comAux = comeco; comAux <= fim; comAux ++) {// Move os elementos de volta para vetor original 30 vetor [comAux] = vetAux [comAux – comeco]; 31} 32 33 livre (vetAux); 34} 35 36 void mergeSort (int veterano [], int comeco, int fim) {37 if (comeco < fim) {38 int meio = (fim + comeco) / 2; 39 40 mergeSort (vetor, comeco, meio); 41 mergeSort (vetor, meio + 1, fim); 42 fundir (vetor, comeco, meio, fim); 43} 44} Implementação em C ++ [editar | Editar código de ferro fundido]

Classe pública WikiMerge >{/ * ** Método obtido em uma matriz de inteiros e inteiros referentes Início e Fim da série Desse * ordenação AO AO o o Poder nosso fiador Escolher Uma Faixa fazer array * ordenado para ser. * * * @ Param @param array indiceInicio * @param indiceFim * Ordena (T [] array, int indiceInicio, indiceFim int) vazio / public {// Condicional que Verifica parâmetro lista Passados ​​Validade volta. if (Array! = null && indexInicio = 0 && indiceFim < Tabela. comprimento && Tabela. Comprimento! = 0) {int Meio = ((indiceFim indiceInicio +) / 2); Ordena (array, indiceInicio, meio); Ordena (array, meio + 1, indiceFim); mesclar (array, indiceInicio, meio, indiceFim); }} / ** * O JUNCAO mesclado de duas listas já ordenadas call. * Para a tabela auxiliar dos EUA. * * * @ Param @ param matriz indiceInicio * @ param Meio * @ param indiceFim * / void fusão (T [] matriz, int indiceInicio, Meio, int indiceFim) {T [] = auxiliar (T []) novo comparáveis [tabela. comprimento]; Copie // a lista de destinatários para (int i = indiceInicio; <= indexFim; i ++) {auxiliar [i] = array [i]; } // índices de ajuda int i = indexInicio; int j = meio + 1; int k = indexInnicio; // Junção das listas ordenadas durante (i <= Meio && j <= indexFim) {if (auxiliar [i]. compareTo (auxiliar [j]) < 0) {matriz [k] = auxiliar [i]; i ++; } else {array [k] = auxiliar [j]; j ++; } k ++; } // Adicionar nomes que você ainda não conhece Junção enquanto (i <= meio) {matriz [k] = auxiliar [i]; i ++; k ++; } // Adicione os dados de inicialização para usar o Junção while (j <= indexFim) {array [k] = auxiliar [j]; j ++; k ++; }}} Código em Python [edit | Editar código de ferro fundido]