Podemos fazer melhor do que

Estou (tolamente, ao que parece) confiante de que a resposta a esta pergunta é não. Então, por que estou perguntando?

Porque o Dr. Aleksandar Prokopec da EPFL em seu curso de programação paralela introduz uma estrutura de dados para a qual ele afirma várias propriedades. Se essas propriedades se mantiverem, parece -me que deve ser possível construir uma árvore binária equilibrada em um tempo melhor que .$O(n\log n)$

Eu não acredito nisso, então estou me perguntando onde está a falha no meu pensamento.

A estrutura de dados é a lista de árvores conc . Em sua forma padrão, parece uma árvore binária normal e vem com uma concatoperação que garante a invariante de que as subárvores esquerda e direita de qualquer nó nunca diferem na altura em mais de um. Como esperado, concattem complexidade .$O(\log n)$

Mas há uma variante de construtor da lista de árvores de concha chamada Appendlista. Essa variante permite diferenças temporárias de altura em subárvores de mais de um. Amortizado$O(1)$ os anexos de tempo são reivindicados para esta variante.

Então parece anexar $n$ elementos devem ter uma complexidade de $O(n)$.

No entanto, é uma característica dessa variante que sempre que $n$é uma potência de dois e termina com uma árvore binária equilibrada completa (contendo todos os elementos inseridos até o momento). Assim, enquanto desequilíbrios temporários são permitidos, a árvore fica equilibrada a cada potência de 2 inserções.

Nesta variante, uma nova classe de nós, denominada Appendnós, é introduzida e são esses nós cujas subárvores são permitidas diferem em altura em mais de um. No entanto, cada$2^k$ inserções todos esses nós temporários são eliminados.

A página da página da Wikipedia descreve o algoritmo de forma bastante sucinta (veja a descrição da estrutura de dados básica e o appendmétodo em particular).

Então quando $n$ é uma potência de dois o nosso custo para a inserção de elementos é $O(n)$e construímos uma árvore binária equilibrada. Ou assim parece.

Em uma pergunta separada, perguntei efetivamente "se posso indicar o número de etapas de um algoritmo para determinados valores de$n$por exemplo, para $n = 2^k$, Onde $k$ é um número inteiro, isso é suficiente para permitir que eu indique a complexidade de todos os valores de $n$? "

Vejo pela resposta de Yuval Filmus que a resposta é não, mas que "em muitos casos, esperaríamos$T$ ser monótono em $n$. Nesse caso, a dedução é válida. "

Parece-me que, neste caso, se inserir $n$ elementos tem complexidade $O(n)$ e todo $2^k$ Se eu tiver uma árvore binária balanceada, o custo de construir árvores binárias balanceadas com essa abordagem de variante de árvore de concha deve ser $O(n)$.

Então, o que há de errado aqui? Para ser sincero, não vejo o valor amortizado$O(1)$acrescentar tempo reivindicado para esta variante. Percebo que muitas vezes as inserções custam$O(1)$mas quando se olha o que está acontecendo com os Appendnós temporários , o custo total de inserção parece ser amortizado$O(\log n)$.

Se esse for o caso, a construção de nossa árvore binária equilibrada tem uma surpresa $O(n\log n)$ custo.

Desculpe por uma pergunta tão longa e desculpe por não entrar em detalhes sobre o algoritmo em questão - ao invés disso, você pode procurar na Wikipedia.

Se eu entendi sua pergunta corretamente, sim, é claro que você pode criar uma árvore binária balanceada em $O(n)$Tempo. Aqui está um pseudocódigo simples:

L = [2, 4, 1, 3, 5, 6, 8]
q = Queue()
node root{value = L[0]}
q.add(root)
k = 1
while !q.isEmpty:
  n = q.pop
  if k < L.size:
     n.left = node{value=L[k]}
     k++
     q.add(n.left)
  if k < L.size:
     n.right = node{value=L[k]}
     k++
     q.add(n.right)

Não é difícil ver que esse código é executado em tempo linear e cria uma árvore binária equilibrada.

O que você não pode fazer é criar uma árvore de pesquisa binária equilibrada (ordenada) no$O(n)$tempo (usando apenas comparações nos valores). O algoritmo acima não garante que o valor na raiz seja maior ou igual a todo valor na subárvore esquerda e seja menor ou igual a todo valor na subárvore direita, para cada subárvore.

O algoritmo acima não garante isso, nem a conc-tree (usando anexos e prefixos). Na página da wikipedia, apenas garante$O(1)$tempo amortizado para Anexa e prepends . Para pastilhas, isso só pode garantir$O(\log n)$ Tempo.

Adicionando à resposta de aelguindy: você simplesmente não pode colocar n itens não classificados em nenhum tipo de estrutura de dados e depois enumerá-los em ordem classificada, em tempo melhor que O (n log n) tempo total - porque, se pudesse, poderia classificar uma matriz em tempo melhor que O (n log n).

Se definirmos uma estrutura de dados "classificada" como qualquer estrutura de dados que possa ser enumerada na ordem classificada em O (n), não poderemos criar nenhuma estrutura de dados classificada mais rapidamente do que em O (n log n). Isso incluiria árvores classificadas, equilibradas e desequilibradas.