Estructura de datos y algoritmo (implementación de Golang) (27) Árbol de búsqueda binario de algoritmo de búsqueda

Árbol de búsqueda binaria

El árbol de búsqueda binaria, también llamado árbol de clasificación binaria, árbol de búsqueda binaria, es un árbol binario con reglas específicas, definidas de la siguiente manera:

1. Es un árbol binario, o un árbol vacío.
2. Los valores de todos los nodos en el subárbol izquierdo son menores que su nodo raíz, y los valores de todos los nodos en el subárbol derecho son mayores que su nodo raíz.
3. Los subárboles izquierdo y derecho también son un árbol de búsqueda binario.

La característica del árbol de búsqueda binario es que buscar el hijo izquierdo hacia el hijo izquierdo puede encontrar el elemento más pequeño, y buscar el hijo derecho al hijo derecho puede encontrar el elemento más grande.

Parece que podemos usarlo para implementar la ordenación de elementos, pero usamos el montón binario para implementar la ordenación del montón, porque no se garantiza que el árbol de búsqueda binario sea un árbol binario equilibrado. En el peor de los casos, el árbol de búsqueda binario se degenerará en Una lista vinculada, es decir, todos los nodos no tienen subárbol izquierdo o subárbol derecho, la jerarquía del árbol es demasiado profunda, lo que resulta en un rendimiento de clasificación deficiente.

Mediante la búsqueda binaria, podemos encontrar rápidamente el valor que necesitamos en un árbol de búsqueda binaria.

Analicemos el método de agregar, eliminar y encontrar elementos en un árbol de búsqueda binario.

Primero, agregue elementos

La siguiente es una representación de un árbol de búsqueda binario:

// 二叉查找树
type BinarySearchTree struct {
    Root *BinarySearchTreeNode // 树根节点
}

// 二叉查找树节点
type BinarySearchTreeNode struct {
    Value int64                 // 值
    Times int64                 // 值出现的次数
    Left  *BinarySearchTreeNode // 左子树
    Right *BinarySearchTreeNode // 右字树
}

// 初始化一个二叉查找树
func NewBinarySearchTree() *BinarySearchTree {
    return new(BinarySearchTree)
}

Un nodo representa un elemento, y el Valuevalor del nodo es la clave utilizada para la búsqueda binaria. Cuando el Valuevalor se repite, aumentamos el número de veces que el valor ocurre en Times1. El código para agregar elementos es el siguiente:

// 添加元素
func (tree *BinarySearchTree) Add(value int64) {
    // 如果没有树根，证明是颗空树，添加树根后返回
    if tree.Root == nil {
        tree.Root = &BinarySearchTreeNode{Value: value}
        return
    }

    // 将值添加进去
    tree.Root.Add(value)
}

func (node *BinarySearchTreeNode) Add(value int64) {
    if value < node.Value {
        // 如果插入的值比节点的值小，那么要插入到该节点的左子树中
        // 如果左子树为空，直接添加
        if node.Left == nil {
            node.Left = &BinarySearchTreeNode{Value: value}
        } else {
            // 否则递归
            node.Left.Add(value)
        }
    } else if value > node.Value {
        // 如果插入的值比节点的值大，那么要插入到该节点的右子树中
        // 如果右子树为空，直接添加
        if node.Right == nil {
            node.Right = &BinarySearchTreeNode{Value: value}
        } else {
            // 否则递归
            node.Right.Add(value)
        }
    } else {
        // 值相同，不需要添加，值出现的次数加1即可
        node.Times = node.Times + 1
    }
}

Si se trata de un árbol vacío al agregar elementos, inicialice el nodo raíz.

Luego, el valor agregado se compara con el nodo raíz para determinar si debe insertarse en el subárbol izquierdo o derecho del nodo raíz, o no insertarse.

Cuando el valor es menor que el nodo raíz, el elemento se inserta en el subárbol izquierdo del nodo raíz. Cuando el valor es mayor que el nodo raíz, el elemento se inserta en el subárbol derecho del nodo raíz.

Luego, recursivamente, opere los subárboles izquierdo y derecho del nodo raíz.

Segundo, encuentre el elemento máximo o mínimo

Encontrar los valores máximos y mínimos es relativamente simple. Siga buscando al hijo izquierdo hasta el hijo izquierdo para encontrar el elemento más pequeño. Siga buscando el hijo correcto al hijo correcto para encontrar el elemento más grande.

// 找出最小值的节点
func (tree *BinarySearchTree) FindMinValue() *BinarySearchTreeNode {
    if tree.Root == nil {
        // 如果是空树，返回空
        return nil
    }

    return tree.Root.FindMinValue()
}

func (node *BinarySearchTreeNode) FindMinValue() *BinarySearchTreeNode {
    // 左子树为空，表面已经是最左的节点了，该值就是最小值
    if node.Left == nil {
        return node
    }

    // 一直左子树递归
    return node.Left.FindMinValue()
}

// 找出最大值的节点
func (tree *BinarySearchTree) FindMaxValue() *BinarySearchTreeNode {
    if tree.Root == nil {
        // 如果是空树，返回空
        return nil
    }

    return tree.Root.FindMaxValue()
}

func (node *BinarySearchTreeNode) FindMaxValue() *BinarySearchTreeNode {
    // 右子树为空，表面已经是最右的节点了，该值就是最大值
    if node.Right == nil {
        return node
    }

    // 一直右子树递归
    return node.Right.FindMaxValue()
}

Tercero, encuentre el elemento especificado

La técnica de búsqueda binaria también es útil aquí:

// 查找节点
func (tree *BinarySearchTree) Find(value int64) *BinarySearchTreeNode {
    if tree.Root == nil {
        // 如果是空树，返回空
        return nil
    }

    return tree.Root.Find(value)
}

func (node *BinarySearchTreeNode) Find(value int64) *BinarySearchTreeNode {
    if value == node.Value {
        // 如果该节点刚刚等于该值，那么返回该节点
        return node
    } else if value < node.Value {
        // 如果查找的值小于节点值，从节点的左子树开始找
        if node.Left == nil {
            // 左子树为空，表示找不到该值了，返回nil
            return nil
        }
        return node.Left.Find(value)
    } else {
        // 如果查找的值大于节点值，从节点的右子树开始找
        if node.Right == nil {
            // 右子树为空，表示找不到该值了，返回nil
            return nil
        }
        return node.Right.Find(value)
    }
}

Si es un árbol vacío, devuelva nil, de lo contrario compare con el nodo raíz.

Si es igual al valor del nodo raíz, devuelva el nodo, de lo contrario, de acuerdo con la comparación de valores, continúe buscando recursivamente el subárbol izquierdo o el árbol de palabras derecho.

Cuarto, encontrar el padre del elemento especificado.

Es lo mismo que buscar el elemento especificado, excepto que se rastrea el nodo padre del elemento.

// 查找指定节点的父亲
func (tree *BinarySearchTree) FindParent(value int64) *BinarySearchTreeNode {
    if tree.Root == nil {
        // 如果是空树，返回空
        return nil
    }

    // 如果根节点等于该值，根节点其没有父节点，返回nil
    if tree.Root.Value == value {
        return nil
    }
    return tree.Root.FindParent(value)
}

func (node *BinarySearchTreeNode) FindParent(value int64) *BinarySearchTreeNode {
    // 外层没有值相等的判定，因为在内层已经判定完毕后返回父亲节点。

    if value < node.Value {
        // 如果查找的值小于节点值，从节点的左子树开始找
        leftTree := node.Left
        if leftTree == nil {
            // 左子树为空，表示找不到该值了，返回nil
            return nil
        }

        // 左子树的根节点的值刚好等于该值，那么父亲就是现在的node，返回
        if leftTree.Value == value {
            return node
        } else {
            return leftTree.FindParent(value)
        }
    } else {
        // 如果查找的值大于节点值，从节点的右子树开始找
        rightTree := node.Right
        if rightTree == nil {
            // 右子树为空，表示找不到该值了，返回nil
            return nil
        }

        // 右子树的根节点的值刚好等于该值，那么父亲就是现在的node，返回
        if rightTree.Value == value {
            return node
        } else {
            return rightTree.FindParent(value)
        }
    }
}

El código se ha ajustado en consecuencia para facilitar la obtención del nodo primario.

Si el nodo padre devuelto está vacío, significa que no hay padre.

Cinco, eliminar elementos

Hay cuatro casos de eliminación de elementos:

1. En el primer caso, el nodo raíz se elimina y el nodo raíz no tiene hijo, simplemente elimínelo directamente.
2. En el segundo caso, el nodo eliminado tiene un nodo padre, pero no hay un subárbol, es decir, el nodo hoja eliminado, simplemente elimínelo directamente.
3. En el tercer caso, hay dos subárboles debajo del nodo eliminado, porque los valores del subárbol derecho son más grandes que el subárbol izquierdo, luego reemplace el nodo eliminado con el elemento más pequeño en el subárbol derecho, luego la naturaleza del árbol de búsqueda binario Satisfecho de nuevo. El elemento más pequeño del subárbol derecho se puede encontrar siempre que siga buscando a la izquierda del subárbol derecho.
4. En el cuarto caso, el nodo eliminado solo tiene un subárbol, por lo que el subárbol puede reemplazar directamente al nodo eliminado.

El código se implementa de la siguiente manera:

// 删除指定的元素
func (tree *BinarySearchTree) Delete(value int64) {
    if tree.Root == nil {
        // 如果是空树，直接返回
        return
    }

    // 查找该值是否存在
    node := tree.Root.Find(value)
    if node == nil {
        // 不存在该值，直接返回
        return
    }

    // 查找该值的父亲节点
    parent := tree.Root.FindParent(value)

    // 第一种情况，删除的是根节点，且根节点没有儿子
    if parent == nil && node.Left == nil && node.Right == nil {
        // 置空后直接返回
        tree.Root = nil
        return
    } else if node.Left == nil && node.Right == nil {
        // 第二种情况，删除的节点有父亲节点，但没有子树

        // 如果删除的是节点是父亲的左儿子，直接将该值删除即可
        if parent.Left != nil && value == parent.Left.Value {
            parent.Left = nil
        } else {
            // 删除的原来是父亲的右儿子，直接将该值删除即可
            parent.Right = nil
        }
        return
    } else if node.Left != nil && node.Right != nil {
        // 第三种情况，删除的节点下有两个子树，因为右子树的值都比左子树大，那么用右子树中的最小元素来替换删除的节点。
        // 右子树的最小元素，只要一直往右子树的左边一直找一直找就可以找到，替换后二叉查找树的性质又满足了。

        // 找右子树中最小的值，一直往右子树的左边找
        minNode := node.Right
        for minNode.Left != nil {
            minNode = minNode.Left
        }
        // 把最小的节点删掉
        tree.Delete(minNode.Value)

        // 最小值的节点替换被删除节点
        node.Value = minNode.Value
        node.Times = minNode.Times
    } else {
        // 第四种情况，只有一个子树，那么该子树直接替换被删除的节点即可

        // 父亲为空，表示删除的是根节点，替换树根
        if parent == nil {
            if node.Left != nil {
                tree.Root = node.Left
            } else {
                tree.Root = node.Right
            }
            return
        }
        // 左子树不为空
        if node.Left != nil {
            // 如果删除的是节点是父亲的左儿子，让删除的节点的左子树接班
            if parent.Left != nil && value == parent.Left.Value {
                parent.Left = node.Left
            } else {
                parent.Right = node.Left
            }
        } else {
            // 如果删除的是节点是父亲的左儿子，让删除的节点的右子树接班
            if parent.Left != nil && value == parent.Left.Value {
                parent.Left = node.Right
            } else {
                parent.Right = node.Right
            }
        }
    }
}

Primero encuentre el nodo del elemento que desea eliminar :, tree.Root.Find(value)y luego encuentre el padre del nodo :, tree.Root.FindParent(value)llene el nodo eliminado de acuerdo con cuatro situaciones diferentes. El núcleo reside en que en el tercer caso, cuando el nodo eliminado tiene dos subárboles, es necesario reemplazar el nodo eliminado con el nodo más pequeño en el subárbol derecho.

El código anterior se puede optimizar, puede encontrar su nodo principal al buscar el nodo del elemento eliminado, no es necesario consultar por separado el nodo principal, en el tercer caso, puede eliminarlo directamente cuando encuentre el nodo más pequeño del subárbol derecho, No hay necesidad de usarlo de forma recursiva tree.Delete(minNode.Value).

Debido a que esta forma general de árbol de búsqueda binaria rara vez se usa, la mayoría de los programas usan árboles AVL o árboles rojo-negros. La optimización anterior se puede entender.

Seis, transversal en orden (para lograr la clasificación)

La clasificación se puede lograr utilizando un árbol de búsqueda binario, siempre que el árbol se recorra en orden.

Primero imprimimos el subárbol izquierdo, luego imprimimos el valor del nodo raíz y luego imprimimos el subárbol derecho. Este es un proceso recursivo.

// 中序遍历
func (tree *BinarySearchTree) MidOrder() {
    tree.Root.MidOrder()
}

func (node *BinarySearchTreeNode) MidOrder() {
    if node == nil {
        return
    }

    // 先打印左子树
    node.Left.MidOrder()

    // 按照次数打印根节点
    for i := 0; i <= int(node.Times); i++ {
        fmt.Println(node.Value)
    }

    // 打印右子树
    node.Right.MidOrder()
}

Siete, código completo

package main

import (
    "fmt"
)

// 二叉查找树节点
type BinarySearchTree struct {
    Root *BinarySearchTreeNode // 树根节点
}

// 二叉查找树节点
type BinarySearchTreeNode struct {
    Value int64                 // 值
    Times int64                 // 值出现的次数
    Left  *BinarySearchTreeNode // 左子树
    Right *BinarySearchTreeNode // 右字树
}

// 初始化一个二叉查找树
func NewBinarySearchTree() *BinarySearchTree {
    return new(BinarySearchTree)
}

// 添加元素
func (tree *BinarySearchTree) Add(value int64) {
    // 如果没有树根，证明是颗空树，添加树根后返回
    if tree.Root == nil {
        tree.Root = &BinarySearchTreeNode{Value: value}
        return
    }

    // 将值添加进去
    tree.Root.Add(value)
}

func (node *BinarySearchTreeNode) Add(value int64) {
    if value < node.Value {
        // 如果插入的值比节点的值小，那么要插入到该节点的左子树中
        // 如果左子树为空，直接添加
        if node.Left == nil {
            node.Left = &BinarySearchTreeNode{Value: value}
        } else {
            // 否则递归
            node.Left.Add(value)
        }
    } else if value > node.Value {
        // 如果插入的值比节点的值大，那么要插入到该节点的右子树中
        // 如果右子树为空，直接添加
        if node.Right == nil {
            node.Right = &BinarySearchTreeNode{Value: value}
        } else {
            // 否则递归
            node.Right.Add(value)
        }
    } else {
        // 值相同，不需要添加，值出现的次数加1即可
        node.Times = node.Times + 1
    }
}

// 找出最小值的节点
func (tree *BinarySearchTree) FindMinValue() *BinarySearchTreeNode {
    if tree.Root == nil {
        // 如果是空树，返回空
        return nil
    }

    return tree.Root.FindMinValue()
}

func (node *BinarySearchTreeNode) FindMinValue() *BinarySearchTreeNode {
    // 左子树为空，表面已经是最左的节点了，该值就是最小值
    if node.Left == nil {
        return node
    }

    // 一直左子树递归
    return node.Left.FindMinValue()
}

// 找出最大值的节点
func (tree *BinarySearchTree) FindMaxValue() *BinarySearchTreeNode {
    if tree.Root == nil {
        // 如果是空树，返回空
        return nil
    }

    return tree.Root.FindMaxValue()
}

func (node *BinarySearchTreeNode) FindMaxValue() *BinarySearchTreeNode {
    // 右子树为空，表面已经是最右的节点了，该值就是最大值
    if node.Right == nil {
        return node
    }

    // 一直右子树递归
    return node.Right.FindMaxValue()
}

// 查找指定节点
func (tree *BinarySearchTree) Find(value int64) *BinarySearchTreeNode {
    if tree.Root == nil {
        // 如果是空树，返回空
        return nil
    }

    return tree.Root.Find(value)
}

func (node *BinarySearchTreeNode) Find(value int64) *BinarySearchTreeNode {
    if value == node.Value {
        // 如果该节点刚刚等于该值，那么返回该节点
        return node
    } else if value < node.Value {
        // 如果查找的值小于节点值，从节点的左子树开始找
        if node.Left == nil {
            // 左子树为空，表示找不到该值了，返回nil
            return nil
        }
        return node.Left.Find(value)
    } else {
        // 如果查找的值大于节点值，从节点的右子树开始找
        if node.Right == nil {
            // 右子树为空，表示找不到该值了，返回nil
            return nil
        }
        return node.Right.Find(value)
    }
}

// 查找指定节点的父亲
func (tree *BinarySearchTree) FindParent(value int64) *BinarySearchTreeNode {
    if tree.Root == nil {
        // 如果是空树，返回空
        return nil
    }

    // 如果根节点等于该值，根节点其没有父节点，返回nil
    if tree.Root.Value == value {
        return nil
    }
    return tree.Root.FindParent(value)
}

func (node *BinarySearchTreeNode) FindParent(value int64) *BinarySearchTreeNode {
    // 外层没有值相等的判定，因为在内层已经判定完毕后返回父亲节点。

    if value < node.Value {
        // 如果查找的值小于节点值，从节点的左子树开始找
        leftTree := node.Left
        if leftTree == nil {
            // 左子树为空，表示找不到该值了，返回nil
            return nil
        }

        // 左子树的根节点的值刚好等于该值，那么父亲就是现在的node，返回
        if leftTree.Value == value {
            return node
        } else {
            return leftTree.FindParent(value)
        }
    } else {
        // 如果查找的值大于节点值，从节点的右子树开始找
        rightTree := node.Right
        if rightTree == nil {
            // 右子树为空，表示找不到该值了，返回nil
            return nil
        }

        // 右子树的根节点的值刚好等于该值，那么父亲就是现在的node，返回
        if rightTree.Value == value {
            return node
        } else {
            return rightTree.FindParent(value)
        }
    }
}

// 删除指定的元素
func (tree *BinarySearchTree) Delete(value int64) {
    if tree.Root == nil {
        // 如果是空树，直接返回
        return
    }

    // 查找该值是否存在
    node := tree.Root.Find(value)
    if node == nil {
        // 不存在该值，直接返回
        return
    }

    // 查找该值的父亲节点
    parent := tree.Root.FindParent(value)

    // 第一种情况，删除的是根节点，且根节点没有儿子
    if parent == nil && node.Left == nil && node.Right == nil {
        // 置空后直接返回
        tree.Root = nil
        return
    } else if node.Left == nil && node.Right == nil {
        //  第二种情况，删除的节点有父亲节点，但没有子树

        // 如果删除的是节点是父亲的左儿子，直接将该值删除即可
        if parent.Left != nil && value == parent.Left.Value {
            parent.Left = nil
        } else {
            // 删除的原来是父亲的右儿子，直接将该值删除即可
            parent.Right = nil
        }
        return
    } else if node.Left != nil && node.Right != nil {
        // 第三种情况，删除的节点下有两个子树，因为右子树的值都比左子树大，那么用右子树中的最小元素来替换删除的节点，这时二叉查找树的性质又满足了。

        // 找右子树中最小的值，一直往右子树的左边找
        minNode := node.Right
        for minNode.Left != nil {
            minNode = minNode.Left
        }
        // 把最小的节点删掉
        tree.Delete(minNode.Value)

        // 最小值的节点替换被删除节点
        node.Value = minNode.Value
        node.Times = minNode.Times
    } else {
        // 第四种情况，只有一个子树，那么该子树直接替换被删除的节点即可

        // 父亲为空，表示删除的是根节点，替换树根
        if parent == nil {
            if node.Left != nil {
                tree.Root = node.Left
            } else {
                tree.Root = node.Right
            }
            return
        }
        // 左子树不为空
        if node.Left != nil {
            // 如果删除的是节点是父亲的左儿子，让删除的节点的左子树接班
            if parent.Left != nil && value == parent.Left.Value {
                parent.Left = node.Left
            } else {
                parent.Right = node.Left
            }
        } else {
            // 如果删除的是节点是父亲的左儿子，让删除的节点的右子树接班
            if parent.Left != nil && value == parent.Left.Value {
                parent.Left = node.Right
            } else {
                parent.Right = node.Right
            }
        }
    }
}

// 中序遍历
func (tree *BinarySearchTree) MidOrder() {
    tree.Root.MidOrder()
}

func (node *BinarySearchTreeNode) MidOrder() {
    if node == nil {
        return
    }

    // 先打印左子树
    node.Left.MidOrder()

    // 按照次数打印根节点
    for i := 0; i <= int(node.Times); i++ {
        fmt.Println(node.Value)
    }

    // 打印右子树
    node.Right.MidOrder()
}

func main() {
    values := []int64{3, 6, 8, 20, 9, 2, 6, 8, 9, 3, 5, 40, 7, 9, 13, 6, 8}

    // 初始化二叉查找树并添加元素
    tree := NewBinarySearchTree()
    for _, v := range values {
        tree.Add(v)
    }

    // 找到最大值或最小值的节点
    fmt.Println("find min value:", tree.FindMinValue())
    fmt.Println("find max value:", tree.FindMaxValue())

    // 查找不存在的99
    node := tree.Find(99)
    if node != nil {
        fmt.Println("find it 99!")
    } else {
        fmt.Println("not find it 99!")
    }

    // 查找存在的9
    node = tree.Find(9)
    if node != nil {
        fmt.Println("find it 9!")
    } else {
        fmt.Println("not find it 9!")
    }

    // 删除存在的9后，再查找9
    tree.Delete(9)
    node = tree.Find(9)
    if node != nil {
        fmt.Println("find it 9!")
    } else {
        fmt.Println("not find it 9!")
    }

    // 中序遍历，实现排序
    tree.MidOrder()
}

Después de ejecutar el programa, el resultado:

find min value: &{2 0 <nil> <nil>}
find max value: &{40 0 <nil> <nil>}
not find it 99!
find it 9!
not find it 9!
2
3
3
5
6
6
6
7
8
8
8
13
20
40

8. Resumen

El árbol de búsqueda binario puede degenerar en una lista vinculada, o puede ser un árbol binario muy equilibrado. La complejidad temporal de buscar, agregar y eliminar elementos depende de la altura del árbol h.

1. Cuando el árbol binario está lleno, la altura del árbol es el más pequeño, en este momento el número de nodos del árbol ny la altura de hla relación es la siguiente: h = log(n).
2. Cuando una lista de árbol binario, el número de nodos de árbol en este momento ny la altura hrelación es: h = n.

La eficiencia del árbol de búsqueda binaria se deriva de las características de su búsqueda binaria. La complejidad del tiempo radica en la altura del árbol binario, por lo que el rango de complejidad del tiempo de búsqueda, adición y eliminación es log(n)~n.

Para mejorar la velocidad de búsqueda del árbol de búsqueda binario, la altura del árbol debe ser lo más pequeña posible. El árbol AVL y el árbol rojo-negro son árboles de búsqueda binarios relativamente equilibrados, debido a la operación especial de equilibrio de rotación, la altura del árbol se reduce considerablemente. Tienen una alta eficiencia de búsqueda, y la complejidad de tiempo promedio de las operaciones de agregar, eliminar y buscar son todas log(n), y a menudo se usan en varios programas.

El árbol de búsqueda binario es la base del árbol AVL de estructura de datos avanzada, árbol rojo-negro que se aprenderá más adelante.

Entrada de artículo de serie

Soy la estrella Chen, bienvenido he escrito personalmente estructuras de datos y algoritmos (Golang lograr) , comenzando en el artículo para leer más amigable GitBook .

• Estructura de datos y algoritmo (implementación de Golang) (1) Una introducción simple a Golang-Prefacio
• Estructuras de datos y algoritmos (implementación de Golang) (2) Una introducción simple a los paquetes, variables y funciones de Golang
• Estructura de datos y algoritmo (implementación de Golang) (3) Una introducción simple a la declaración de control de flujo de Golang
• Estructuras de datos y algoritmos (implementación de Golang) (4) Una introducción simple a las estructuras y métodos de Golang
• Estructura de datos y algoritmo (implementación de Golang) (5) Una introducción simple a la interfaz de Golang
• Estructura de datos y algoritmo (implementación de Golang) (6) Una introducción simple a la concurrencia, las rutinas y los canales de Golang
• Estructura de datos y algoritmo (implementación de Golang) (7) Una introducción simple a la biblioteca estándar de Golang
• Estructura de datos y algoritmo (implementación de Golang) (8.1) Conocimientos básicos-Prefacio
• Estructura de datos y algoritmo (implementación de Golang) (8.2) Conocimiento básico: dividir y conquistar y recurrir
• Estructura y algoritmo de datos (implementación de Golang) (9) Complejidad del algoritmo de conocimiento básico y símbolo progresivo
• Estructura de datos y algoritmo (implementación de Golang) (10) Conocimientos básicos: el método principal de complejidad del algoritmo
• Estructuras de datos y algoritmos (implementación de Golang) (11) Estructuras de datos comunes-Prefacio
• Estructuras de datos y algoritmos (implementación de Golang) (12) Listas enlazadas de estructuras de datos comunes
• Estructuras de datos y algoritmos (implementación de Golang) (13) Estructuras de datos comunes: matrices de longitud variable
• Estructuras de datos y algoritmos (implementación de Golang) (14) Estructuras de datos comunes: pila y cola
• Estructuras de datos y algoritmos (implementación de Golang) (15) Lista de estructuras de datos comunes
• Estructuras de datos y algoritmos (implementación de Golang) (16) Estructuras de datos comunes-Diccionario
• Estructuras de datos y algoritmos (implementación de Golang) (17) Estructuras de datos comunes: árboles
• Estructura de datos y algoritmo (implementación de Golang) (18) Algoritmo de clasificación-Prefacio
• Estructura de datos y algoritmo (implementación de Golang) (19) Algoritmo de clasificación-clasificación de burbujas
• Estructura de datos y algoritmo (implementación de Golang) (20) Clasificación de algoritmos de selección
• Estructura de datos y algoritmo (implementación de Golang) (21) Clasificación de algoritmo de inserción
• Estructura de datos y algoritmo (implementación de Golang) (22) Algoritmo de clasificación-Clasificación de Hill
• Estructura de datos y algoritmo (implementación de Golang) (23) Clasificación de algoritmo de fusión
• Estructura de datos y algoritmo (implementación de Golang) (24) Algoritmo de clasificación prioritario y clasificación de montón
• Estructura de datos y algoritmo (implementación de Golang) (25) Algoritmo de clasificación: clasificación rápida
• Estructura de datos y algoritmo (implementación de Golang) (26) Tabla de algoritmo de búsqueda de hash
• Estructura de datos y algoritmo (implementación de Golang) (27) Árbol de búsqueda binario de algoritmo de búsqueda
• Estructura y algoritmo de datos (implementación de Golang) (28) Árbol de algoritmo de búsqueda-AVL
• Estructura de datos y algoritmo (implementación de Golang) (29) Árbol de algoritmo de búsqueda-2-3 y árbol rojo-negro inclinado a la izquierda
• Estructura de datos y algoritmo (implementado por Golang) (30) Árbol de algoritmo de búsqueda-2-3-4 y árbol rojo-negro ordinario