La estructura de datos se convierte en Dios Capítulo 4: Árbol (Parte 2)

Árbol de búsqueda binaria: un árbol binario, que puede estar vacío, si no está vacío, satisface las siguientes propiedades:
1. Todos los valores clave del subárbol izquierdo no vacío son menores que los valores clave de su raíz nodo.
2. Todos los valores clave del subárbol derecho no vacío son mayores que los valores clave de su nodo raíz.
3. Los subárboles izquierdo y derecho son árboles de búsqueda binarios.

2. Función de operación

Position Find(ElementType X, BinTree BST): Buscar
elemento La dirección del punto;
Position FindMax(BinTree BST): Encuentra y devuelve la dirección del nodo donde se encuentra el elemento más grande del árbol de búsqueda binario BST.
P Insertar BinTree (ElementType X, BinTree BST)
P BinTree Eliminar (ElementType X, BinTree BST)

1. Encuentra

La búsqueda comienza desde el nodo raíz, si el árbol está vacío, se devuelve NULL.

Si el árbol de búsqueda no está vacío, la clave del nodo raíz se compara con X y se realiza un procesamiento diferente:
① Si el valor de la clave, continúa buscando en el subárbol derecho;
③ Si el resultado de la comparación entre los dos es igual, la búsqueda se completa y Se devuelve el puntero a este nodo. .

Código:

Recursión de cola:

Posi tion Find( ElementType X，BinTree BST )
{   
    if.(!BST)returnNULL;/*如果为空，返回NULL*/
    if.(X.>BST->Data)
        return FindT X, BST->Right ) ; /*在右子树中继续查找*,
    else if( X< BST->Data )
        return Find( x, BST->left ) ; /*在左子树中继续查找*/
    else     /* X == BST->Data */
        return BST; /*查找成功，返回结点的找到结点的地址*/
}

Función iterativa: debido a la alta eficiencia de ejecución de las funciones no recursivas, la función "recursiva de cola" se puede cambiar a una función iterativa

Position IterFind( E1ementType X, BinTree BST )
{    
    while( BST ) {
        if( X > BST->Data )
            BST = BST->Right; /*向右子树中移动，继续查找*/
        else if( X < BST->Data )
            BST = BST->Ieft; /*向左子树中移动，继续查找*/
        else /* X == BST->Data */
            return BST; /*查找成功，返回结点的找到结点的地址*/
    }
    return NULL; /*查找失败*/
}

Encuentre los elementos más grandes y más pequeños
1) El elemento más grande debe estar en el nodo final de la rama más a la derecha del árbol
2) El elemento más pequeño debe estar en el nodo final de la rama más a la izquierda del árbol

Encuentra el elemento más pequeño:

Position FindMin( BinTree BST )
{
    if( !BST )     return NULL; /*空的二叉搜索树，返回NULL*/
    else if( !BST-> Left )
        return BST; / *找到最左叶结点并返回*/
    else
        return FindMin( BST->Left ) ; /*沿左分支继续查找*/
}

Encuentra el elemento más grande:

Position FindMax( BinTree BST )
{
    if (BST )
        while ( BST-> >Right )
            BST = BST->Right ;
                /*沿右分支继续查找， 直到最右叶结点*/
    return BST ;
}

2. Insertar

BinTree Insert( E1ementType X，BinTree BST )
{
    if( !BST ) {
        /*若原树为空， 生成并返回一个结点的二叉搜索树*/
        BST = malloc(sizeof (struct TreeNode) ) ;
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    }else / *开始找要插入元素的位置*/
        if( X < BST->Data )
            BST->Left = Insert( X，BST-> Left) ;
                /*递归插入左子树*/
        else if( X > BST->Data )
            BST->Right = Insert( X, BST->Right) ;
                        /*递归插入右子树*/ .
        /* else x已经存在，什么都不做*/
    return BST ;
}

3. eliminar (eliminar)

1) Eliminar nodos hoja:

Lo que desea eliminar es el nodo hoja: elimínelo directamente y luego modifique el puntero del nodo principal; configúrelo en NULL.

2) El nodo que se va a eliminar tiene solo un nodo hijo: apunte el puntero de su nodo padre al nodo hijo del nodo que se va a eliminar.

3) El nodo a eliminar tiene dos subárboles, izquierdo y derecho:

Reemplace el nodo eliminado con otro nodo: el elemento más pequeño del subárbol derecho o el elemento más grande del subárbol izquierdo

Código:

BinTree Delete ( E1ementType X，BinTree BST )
{    
    Position Tmp;
    if( !BST ) printf ("要删除的元素未找到") ;
    else if ( X < BST->Data )
        BST->Left = Delete( x，BST->Ieft) ; /*左子树递归删除*/
    else if( X > BST->Data )
        BST->Right = Delete( X，BST->Right) ; /*右子树递归删除*/
    else / *找到要删除的结点*/
        if( BST->Left && BST->Right ) { /*被删除结点有左右两个子结点*/
            Tmp = FindMin( BST->Right ) ;
                /*在右子树中找最小的元素填充删除结点*/
            BST->Data = Tmp->Data;
            BST->Right = Delete( BST->Data， BST->Right) ;
                /*在删除结点的右子树中删除最小元素*/
        } else { /*被删除结点有一个或无子结点*/
            Tmp=BST;
            if( !BST->Ieft ) /* 有右孩子或无子结点*/
                BST = BST- >Right;
            else if( !BST->Right ) /*有左孩子或无子结点*/
                BST = BST->Left;
            free( Tmp ) ;
    return BST ;
}

Árbol binario equilibrado:

1. ¿Qué es un árbol binario equilibrado?

Factor de equilibrio (BF): BF(T)= hL-hR, donde hL y hR son las alturas de los subárboles izquierdo y derecho de T respectivamente.

El árbol binario equilibrado (árbol AVL)
es un árbol vacío, o
el valor absoluto de la diferencia de altura entre los subárboles izquierdo y derecho de cualquier nodo no excede 1, es decir, |BF(T)|S 1

¿Puede la altura de un árbol binario equilibrado alcanzar log2n?
Sea nh altura el número mínimo de nodos de un árbol binario equilibrado de h. Cuando el número de nodos es mínimo:

2. Ajuste del árbol binario equilibrado.

Algunas operaciones en el árbol binario provocarán un desequilibrio en su equilibrio, por lo que debemos realizarle ajustes.

1. Rotación única derecha

2. Rotación única izquierda

3. Rotación única hacia izquierda y derecha.

4, rotación derecha e izquierda

Montón:

Cola de prioridad: una "cola" especial. El orden en que se eliminan los elementos se basa en la prioridad (palabra clave) de los elementos , en lugar del orden en que los elementos ingresan a la cola.

1. Pregunta: ¿Cómo organizar la cola prioritaria?

¿Matriz general o lista enlazada?, ¿
matriz ordenada o lista enlazada?,
¿árbol de búsqueda binaria?, ¿árbol AVL?

2. ¿Es posible utilizar una estructura de almacenamiento de árbol binario?

¿Árbol de búsqueda binaria?
Si se utiliza una estructura de árbol binario, ¿deberíamos prestar más atención a la inserción o eliminación?
➢ ¿Cómo organizar el orden de los nodos del árbol?
➢ ¿Cómo es la estructura del árbol?

➢Dos características del montón : Estructural: un árbol binario completo
representado por una matriz ; ordenado: la clave de cualquier nodo es el valor máximo (o valor mínimo) de todos los nodos en su subárbol

Max Heap", también conocido como "Big Top Heap": el valor máximo.
Maximum Heap (MinHeap)", también conocido como "Little Top Heap": el valor mínimo.

1. Descripción del tipo de datos abstracto del montón

Nombre del tipo: Max Heap
Conjunto de objetos de datos: árbol binario completo , el valor del elemento de cada nodo no es menor que el valor del elemento de su nodo secundario
Conjunto de operaciones: Max heap H∈MaxHeap, elemento item∈ElementType, las operaciones principales son:
● MaxHeap Create (int MaxSize): crea un montón máximo vacío.
●Boolean IsFull(MaxHeap H): determina si el montón máximo H está lleno.
●Insertar (MaxHeap H, elemento ElementType): inserta el elemento en el montón máximo H.
●Boolean IsEmpty(MaxHeap H); determina si el montón máximo H está vacío.
●ElementType DeleteMax(MaxHeap H): Devuelve el elemento más grande en H (prioridad alta).

1. Creación del montón más grande:

typedef struct HeapStruct *MaxHeap;
struct HeapStruct {
    ElementType *Elements; /* 存储堆元素首地址*/
    int Size;/*堆的当前元素个数*/
    int Capacity;/*堆的最大容量/
};

MaxHeap Create ( int MaxSize )
{
    /*创建容量为MaxSize的空的最大堆*/
    MaxHeap H = malloc( sizeof( struct HeapStruct ) ) ;
    H->Elements = mal1oc( (MaxSize+1) * sizeof (ElementType) ) ;
    H->Size = 0 ;
    H- >Capacity = MaxSize;
    H->Elements[0] = MaxData ;
        /*定义“哨兵”为大于堆中所有可能元素的值，便于以后更快操作*/
    return H ;
}

2. Inserción en el montón máximo:

Inserte el nuevo nodo en la secuencia ordenada desde su nodo padre hasta el nodo raíz

void Insert( MaxHeap H，ElementType item )
{ /*将元素item插入最大堆H，其中H->Elements[0]已经定义为哨兵*/
    int i;
    if ( IsFu11(H) ) {
        printf ("最大堆已满") ;
        return;
    }
    i = ++H->Size; /* i指向插入后堆中的最后一个元素的位置*/
    for ( ; H->E1ements[i/2] < item ; i/=2 )
        H->E1ements[i] = H->Elements[i/2]; /*向下过滤结点*/
        H->E1ements[i] = item; /*将item插入*/
}

El papel del centinela: i>1

T(norte)=O(lognorte)

3. Eliminación del montón más grande:

Saque el elemento del nodo raíz (valor máximo) y elimine un nodo en el montón.

ElementType DeleteMax( MaxHeap H )
{ /*从最大堆8中取出键值为最大的元素，并删除-一个结点*/
    int Parent， Child;
    E1ementType MaxItem，temp ;
    if ( IsEmpty (H) ) {
        printf ("最大堆已为空") ;
        return ;
    }
    MaxItem = H->E1ements[1]; /*取出根结点最大值*/
        /*用最大堆中最后一个元素从根结点开始向上过滤下层结点*/
    temp = H- > Elements[H->Size--] ;
    for( Parent=1; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent ★2 ;
        if( (Child!= H->Size)&&(H->Elements [Chi1d] < H->Elements [Chi1d+1]) )
            Child++; /* Child指向左右子结点的较大者*/
        if( temp >= H-> Elements [Chi1d] ) break ;
        else /*移动temp元素到下一层*/
            H->Elements [Parent] = H->Elements [Child] ;
    }
    H->Elements [Parent] = temp ; 
    return MaxItem :
}

4. Creación del montón máximo:

Cree un montón máximo: almacene los N elementos existentes en una matriz unidimensional de acuerdo con los requisitos del montón máximo

Método 1: mediante la operación de inserción, se insertan N elementos uno tras otro en un montón inicialmente vacío y el costo de tiempo máximo es O (N logN).
Método 2: crear un montón máximo con complejidad de tiempo lineal.
(1) Almacene N elementos en el orden de entrada, primero satisfaciendo las características estructurales de un árbol binario completo
(2) Ajuste la posición de cada nodo para satisfacer las características ordenadas del montón máximo.

Árbol de Huffman y codificación de Huffman

1. Definición del árbol de Huffman

Longitud de ruta ponderada (WPL): suponga que el árbol binario tiene n nodos de hoja, cada nodo de hoja tiene un peso Wk; la longitud desde el nodo raíz hasta cada nodo de hoja es Ik, entonces la longitud de cada nodo de hoja La suma de las longitudes de ruta ponderadas es:

Árbol binario óptimo o árbol de Huffman: árbol binario mínimo WPL

2. La estructura del árbol de Huffman.

Fusionar los dos subárboles con el peso más pequeño cada vez

typedef struct TreeNode * Huf fmanTree ;
struct TreeNode {
    int Weight;
    HuffmanTree Left, Right;
}
Huf fmanTree Huffman( MinHeap H )
{     /*假设H->Size个权值已经存在H->Elements []->Weight里*/
    inti;
    Huf fmanTree T ;
    BuildMinHeap(H) ; /*将H->Elements []按权值调整为最小堆*/
    for(i = 1; i < H->Size; i++) { /*做H->Size-1次合并*/
        T = malloc( sizeof( struct TreeNode) ) ; /*建立新结点*/
        T->Left = DeleteMin(H) ;
            /*从最小堆中删除-一个结点， 作为新T的左子结点*/
        T->Right = DeleteMin(H) ;
            /*从最小堆中删除-一个结点，作为新T的右子结点*/
        T->Weight = T->Left->Weight+T->Right->Weight ;
            /*计算新权值*/
        Insert( H，T ) ; /*将新T插入最小堆*/
    }
    T =DeleteMin(H) ;
        //整体复杂度为O(N logN)
    returnT;
}

3. Características del árbol de Huffman

No hay ningún nodo con grado 1;
un árbol de Huffman con n nodos de hoja tiene un total de 2n-1 nodos; los
subárboles izquierdo y derecho de cualquier nodo que no sea de hoja del árbol de Huffman siguen siendo árboles de Huffman después del intercambio;
por lo mismo un conjunto de pesos {w1, W2, .... wn}, ¿hay dos árboles de Huffman que no son homogéneos
?
Para un conjunto de pesos {1, 2, 3, 3}, ¿hay dos árboles de Huffman que no son homogéneos? Hombre Shu:

4. Codificación Huffman

Dada una cadena, ¿cómo codificar los caracteres para minimizar el espacio de almacenamiento de codificación de la cadena?

[Ejemplo] Supongamos que hay un texto que contiene 58 caracteres y está compuesto por los siguientes 7 caracteres: a, e, i, s, t, espacio (sp), nueva línea (nl); el número de apariciones de estos 7 caracteres es diferente. ¿Cómo codificar estos 7 caracteres para minimizar el espacio total de codificación?

[Análisis] (1) Utilice codificación ASCII de igual longitud: 58 X8 = 464 bits
; (2) Utilice codificación de 3 bits de igual longitud: 58 ¿Los caracteres más cortos y menos frecuentes se pueden codificar por más tiempo?

¿Cómo realizar una codificación de longitud desigual? ¿
Cómo evitar la ambigüedad?
⑨ Código de prefijo: la codificación de cualquier carácter no es el prefijo de otra codificación de caracteres
◆ Se puede decodificar sin ambigüedad

Se utilizan árboles binarios
para codificar. Se utilizan árboles binarios para codificar:
(1) Ramas izquierda y derecha: 0, 1
(2) Los caracteres están solo en los nodos hoja