¿Cómo funciona una ordenación de inserción para una matriz BST?

Question

¿Cómo funciona una ordenación de inserción para una matriz BST?

votos

1

Intenté hacerlo de forma recursiva ... El número entero parental varable sería como yo, conforme a la fórmula, 2*i +1para leftChild's y 2*i +2para la derecha.

void BST::insert(const data &aData)
{
    if ( items[Parent].empty ) 
    {
        items[Parent].theData = aData;
        items[Parent].empty = false;
    }
    else if ( aData < items[Parent].theData )
    {
        Parent = 2 * Parent + 1;
        if ( Parent >= maxSize ) this->reallocate();
        this->insert(aData);
    }
    else
    {
        Parent = (2 * rightChild++)+ 2;
        if ( Parent >= maxSize ) this->reallocate();
        this->insert(aData);
    }
}

Funciona bien al insertar elementos que son menos que el original ... Pero cuando encuentro algo más grande, todo se estropea: x

void BST::reallocate()
{
    item *new_array = new item[maxSize*2];

    for ( int array_index = 0; array_index < maxSize; array_index++ ) 
    {
        if ( ! items[array_index].empty )
        {
            new_array[array_index].theData = items[array_index].theData;
        }
    }
    maxSize *= 2;
    delete [] items;

    items = NULL;
    items = new_array;
}

Aquí está mi código para que nadie se sienta confundido, entonces estoy:

BST::BST(int capacity) : items(new item[capacity]), size(0), Parent(0),
leftChild(0), rightChild(0)
{
    items->empty = true;
    maxSize = capacity;
}
private:
    int size;  // size of the ever growing/expanding tree :)
    int Parent;
    int maxSize;    
    int leftChild;
    int rightChild;
    struct item
    {
        bool empty;
        data theData;
    };
    item *items;    // The tree array

La función de inserción anterior es en realidad la mejor que puedo obtener ..

                                 R
                                / \
                               /   \
                              /     \
                             L       X
                            / \     / \
                           J   V   K   T   <--The only out of place node.
                          / \   \
                         / NULL  \
                        G        /
                                P

Al insertar: R, L, J, G, X, K, V, P, Ten ese orden

c++binary-search-tree

Publicado el 18/11/2009 a las 01:44
fuente por usuario user40120

En otros idiomas...

1 respuestas

sdtom · Answer 1 · 2009-11-24 01:08

Sospecho que tu problema está en esta línea:

    Parent = (2 * rightChild++)+ 2;

¿Por qué estás usando rightChild aquí en lugar de (2 * Parent) + 2?

Para hacer las cosas más claras, es posible que desee agregar algunas funciones simples en línea a su clase para calcular los índices de los hijos izquierdo / derecho y el padre, dado un índice:

inline int getLeftChildIndex(int nodeNdx) { return (nodeNdx * 2) + 1; }
inline int getRightChildIndex(int nodeNdx) { ... }
inline int getParentIndex(int nodeNdx) { ... }

También puede considerar usar las clases search()o el find()método (supongo que tiene uno) para determinar dónde insertar un nuevo nodo. La función de búsqueda debe devolver el índice de un nodo existente (depende de usted decidir cómo manejar la inserción de valores duplicados) o el índice de dónde debe insertarse el nuevo valor.