Criando uma árvore binária com pedido automático

Eu tenho uma atribuição na qual preciso usar uma árvore de pesquisa binária e alterá-la para se auto-ordenar, de modo que os itens mais acessados ​​(tenham uma prioridade mais alta) estejam no topo da árvore, a raiz sendo o nó mais acessado .

O professor me deu o BST e a estrutura do nó para trabalhar, mas tentar entender o algoritmo para atualizar a árvore conforme as coisas estão sendo inseridas está me confundindo.

Sei que, à medida que a inserção está acontecendo, ele verifica se os dados do nó atual são menores ou maiores que o nó atual e depois recursivamente segue na direção correta até encontrar um ponteiro nulo e se inserir lá. e depois de inserido, aumenta a prioridade em 1.

template <class Type>
void BinarySearchTree<Type> ::  insert( const Type & x, BinaryNode<Type> * & t )
{
    if( t == NULL )
        t = new BinaryNode<Type>( x, NULL, NULL );
    else if( x < t->element )
        insert( x, t->left );
    else if( t->element < x )
        insert( x, t->right );
    else
        t->priority++;  // Duplicate; do nothing for right now
}

Agora eu preciso descobrir quando o nó é igual, como reordenar a árvore para que o nó atual (que é igual a um nó já existente) encontre o nó existente, aumente a prioridade desse nó e a mude se o raiz é uma prioridade mais baixa.

Acho que tenho a ideia de que a lógica do AVL funcionaria e, quando ocorresse uma mudança, seria uma rotação única para a direita ou uma única rotação para a esquerda.

Aqui é onde estou confuso, realmente não sei por onde começar com a criação de um algoritmo para resolver o problema. Como o algoritmo AVL trabalha para acompanhar o equilíbrio de uma árvore e, em seguida, girar os nós para a esquerda ou direita, essa árvore não precisa se preocupar em ser equilibrada, apenas para que os nós com a prioridade mais alta não tenham filhos com prioridade mais alta. .

Apenas duas dicas:

1. Se você realmente deseja combinar as idéias de filas prioritárias e árvores de pesquisa binária, pense em combinar heap e BST em uma estrutura.
2. Existe o conceito de listas auto-organizadas . A idéia é mover o elemento acessado recentemente para (ou para a frente), a fim de acelerar acessos futuros ao mesmo elemento, assim "aprendendo" a distribuição do elemento ao longo do tempo (com a qualidade dependendo da implementação específica). Talvez você possa adaptar isso às árvores?

Spoiler: Siga os links abaixo apenas se você não conseguir criar algo sozinho.

1. Isso é chamado de treap .
2. As árvores espalhadas implementam essa ideia.

Dê uma olhada nas árvores espalhadas, elas são realmente o que você precisa. Você precisaria modificar a função splay, não para mover cada nó acessado até a árvore, mas lentamente para cima