Estrutura e algoritmo dos dados (implementação Golang) (27) Árvore de pesquisa binária do algoritmo de pesquisa

Árvore de pesquisa binária

A árvore de pesquisa binária, também chamada de árvore de classificação binária, árvore de pesquisa binária, é uma árvore binária com regras específicas, definidas da seguinte forma:

1. É uma árvore binária ou uma árvore vazia.
2. Os valores de todos os nós na subárvore esquerda são menores que seu nó raiz e os valores de todos os nós na subárvore direita são maiores que seu nó raiz.
3. As subárvores esquerda e direita também são uma árvore de pesquisa binária.

A característica da árvore de pesquisa binária é que procurar o filho esquerdo para o filho esquerdo pode encontrar o menor elemento e procurar o filho certo para o filho direito pode encontrar o maior elemento.

Parece que podemos usá-lo para implementar a classificação de elementos, mas usamos heap binário para implementar a classificação de heap, porque não é garantido que a árvore de pesquisa binária seja uma árvore binária equilibrada e, na pior das hipóteses, a árvore de pesquisa binária se degenerará em Uma lista vinculada, ou seja, todos os nós não têm subárvore esquerda ou subárvore direita, a hierarquia da árvore é muito profunda, resultando em um desempenho de classificação ruim.

Usando a pesquisa binária, podemos encontrar rapidamente o valor que precisamos em uma árvore de pesquisa binária.

Vamos analisar o método de adicionar, excluir e localizar elementos em uma árvore de pesquisa binária.

Primeiro, adicione elementos

A seguir, é uma representação de uma árvore de pesquisa binária:

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

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

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

Um nó representa um elemento e o Valuevalor do nó é a chave usada para a pesquisa binária.Quando o Valuevalor é repetido, aumentamos o número de vezes que o valor ocorre em Times1. O código para adicionar elementos é o seguinte:

// 添加元素
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
    }
}

Se for uma árvore vazia ao adicionar elementos, inicialize o nó raiz.

Em seguida, o valor agregado é comparado ao nó raiz para determinar se ele deve ser inserido na subárvore esquerda ou direita do nó raiz ou não.

Quando o valor é menor que o nó raiz, o elemento é inserido na subárvore esquerda do nó raiz.Quando o valor é maior que o nó raiz, o elemento é inserido na subárvore direita do nó raiz.

Em seguida, opere recursivamente as subárvores esquerda e direita do nó raiz.

Segundo, encontre o elemento máximo ou mínimo

Encontrar os valores máximo e mínimo é relativamente simples: continue procurando o filho esquerdo até o filho esquerdo para encontrar o menor elemento. Continue procurando o filho certo para o filho certo para encontrar o maior elemento.

// 找出最小值的节点
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()
}

Terceiro, encontre o elemento especificado

A técnica de pesquisa binária também é útil aqui:

// 查找节点
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)
    }
}

Se for uma árvore vazia, retorne zero, caso contrário, compare com o nó raiz.

Se for igual ao valor do nó raiz, retorne o nó; caso contrário, de acordo com a comparação de valores, continue pesquisando recursivamente a subárvore esquerda ou a árvore da palavra certa.

Quarto, encontre o pai do elemento especificado

É o mesmo que procurar o elemento especificado, exceto que o nó pai do elemento é rastreado.

// 查找指定节点的父亲
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)
        }
    }
}

O código foi ajustado de acordo para facilitar a obtenção do nó pai.

Se o nó pai retornado estiver vazio, significa que não há pai.

Cinco, excluir elementos

Existem quatro casos de exclusão de elementos:

1. No primeiro caso, o nó raiz é excluído e o nó raiz não tem filho, apenas exclua-o diretamente.
2. No segundo caso, o nó excluído possui um nó pai, mas não há subárvore, ou seja, o nó folha excluído, apenas exclua-o diretamente.
3. No terceiro caso, há duas subárvores sob o nó excluído, porque os valores da subárvore direita são maiores que a subárvore esquerda, substitua o nó excluído pelo menor elemento na subárvore direita e, em seguida, a natureza da árvore de pesquisa binária Satisfeito novamente. O menor elemento da subárvore direita pode ser encontrado desde que você continue olhando para a esquerda da subárvore direita.
4. No quarto caso, o nó excluído possui apenas uma subárvore, portanto, a subárvore pode substituir diretamente o nó excluído.

O código é implementado da seguinte maneira:

// 删除指定的元素
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
            }
        }
    }
}

Primeiro localize o nó do elemento que deseja excluir: tree.Root.Find(value)e, em seguida, localize o pai do nó :, tree.Root.FindParent(value)preencha o nó excluído de acordo com quatro situações diferentes. O principal é que, no terceiro caso, quando o nó excluído possui duas subárvores, é necessário substituir o nó excluído pelo menor na subárvore direita.

O código acima pode ser otimizado; você pode descobrir seu nó pai ao procurar o nó do elemento excluído; não é necessário consultar o nó pai separadamente; no terceiro caso, você pode removê-lo diretamente quando encontrar o nó menor da subárvore correta, Não há necessidade de usá-lo recursivamente tree.Delete(minNode.Value).

Como essa forma geral de árvore de pesquisa binária raramente é usada, a maioria dos programas usa árvores AVL ou árvores vermelho-preto.A otimização acima pode ser entendida.

Seis, travessia em ordem (para obter a classificação)

A classificação pode ser obtida usando uma árvore de pesquisa binária, desde que a árvore seja atravessada em ordem.

Primeiro, imprimimos a subárvore esquerda, depois imprimimos o valor do nó raiz e depois a subárvore direita, que é um processo 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()
}

Sete, 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()
}

Depois de executar o programa, o 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. Resumo

A árvore de pesquisa binária pode degenerar em uma lista vinculada ou pode ser uma árvore binária muito equilibrada.A complexidade do tempo de pesquisa, adição e exclusão de elementos depende da altura da árvore h.

1. Quando a árvore binária é completa, a altura da árvore é o menor, neste momento o número de nós da árvore ne altura hrelação é a seguinte: h = log(n).
2. Quando uma lista de árvore binária, o número de árvore de nodos neste momento nea altura hde relacionamento é: h = n.

Caracterizado por uma árvore de busca binária para encontrar fonte eficiente de outros pontos, a complexidade de tempo é que a altura de uma árvore binária, assim que encontrar, acrescentando tempo ea complexidade da gama é excluído log(n)~n.

Para melhorar a velocidade de pesquisa da árvore de pesquisa binária, a altura da árvore deve ser a menor possível. A árvore AVL e a árvore vermelho-preto são árvores de pesquisa binária relativamente equilibradas, devido à operação especial de balanceamento de rotação, a altura da árvore é bastante reduzida. Eles têm alta eficiência de pesquisa, e a complexidade média do tempo das operações de adição, exclusão e pesquisa são todas log(n), e são frequentemente usadas em vários programas.

A árvore de pesquisa binária é a base da árvore AVL da estrutura de dados avançada, árvore vermelha-preta, a ser aprendida posteriormente.

Artigo da série

Eu sou a estrela Chen, Bem-vindo eu ter escrito, pessoalmente, estruturas de dados e algoritmos (golang conseguir) , a partir do artigo para ler mais amigável GitBook .

• Estrutura de dados e algoritmo (implementação Golang) (1) Uma introdução simples ao Golang-Prefácio
• Estruturas e algoritmos de dados (implementação Golang) (2) Uma introdução simples aos pacotes, variáveis ​​e funções Golang
• Estrutura de dados e algoritmo (implementação de Golang) (3) Uma introdução simples à declaração de controle de fluxo de Golang
• Estruturas de dados e algoritmos (implementação de Golang) (4) Uma introdução simples às estruturas e métodos de Golang
• Estrutura e algoritmo de dados (implementação Golang) (5) Uma introdução simples à interface Golang
• Estrutura e algoritmo de dados (implementação Golang) (6) Uma introdução simples à simultaneidade, corotinas e canais de Golang
• Estrutura e algoritmo de dados (implementação Golang) (7) Uma introdução simples à biblioteca padrão Golang
• Estrutura de dados e algoritmo (implementação de Golang) (8.1) Conhecimento básico-Prefácio
• Estrutura de dados e algoritmo (implementação de Golang) (8.2) Conhecimento básico - divisão, conquista e recursão
• Estrutura e algoritmo dos dados (implementação Golang) (9) Complexidade básica do algoritmo do conhecimento e símbolo progressivo
• Estrutura de dados e algoritmo (implementação de Golang) (10) Conhecimento básico - o principal método de complexidade de algoritmos
• Estruturas de dados e algoritmos (implementação de Golang) (11) Estruturas de dados comuns - Prefácio
• Estruturas e algoritmos de dados (implementação Golang) (12) Listas comuns vinculadas a estruturas de dados
• Estruturas e algoritmos de dados (implementação Golang) (13) Matrizes comuns de estruturas de comprimento variável
• Estruturas e algoritmos de dados (implementação de Golang) (14) Estruturas de dados comuns - pilha e fila
• Estruturas de dados e algoritmos (implementação de Golang) (15) Lista comum de estruturas de dados
• Estruturas de dados e algoritmos (implementação de Golang) (16) Dicionário de estruturas de dados comum
• Estruturas e algoritmos de dados (implementação de Golang) (17)
• Estrutura de dados e algoritmo (implementação de Golang) (18) Algoritmo de classificação-Prefácio
• Estrutura e algoritmo de dados (implementação Golang) (19) Classificação de algoritmos de classificação por bolhas
• Estrutura de dados e algoritmo (implementação Golang) (20) Classificação de seleção de algoritmo de classificação
• Estrutura e algoritmo de dados (implementação Golang) (21) Classificação de inserção de algoritmo de classificação
• Estrutura de dados e algoritmo (implementação de Golang) (22) Algoritmo de classificação-Classificação de Hill
• Estrutura e algoritmo de dados (implementação Golang) (23) Classificação de algoritmo de mesclagem
• Estrutura e algoritmo de dados (implementação Golang) (24) Classificação da fila de prioridade do algoritmo e classificação da pilha
• Estrutura e algoritmo de dados (implementação Golang) (25) Classificação rápida por algoritmo de classificação
• Estrutura de dados e algoritmo (implementação de Golang) (26) Tabela de algoritmos e hash de pesquisa
• Estrutura e algoritmo dos dados (implementação Golang) (27) Árvore de pesquisa binária do algoritmo de pesquisa
• Estrutura e algoritmo dos dados (implementação Golang) (28) Árvore de algoritmo de pesquisa-AVL
• Estrutura e algoritmo de dados (implementação de Golang) (29) Localização da árvore do algoritmo-2-3 e da árvore vermelha e preta inclinada para a esquerda
• Estrutura e algoritmo de dados (implementado por Golang) (30) Localização da árvore do algoritmo-2-3-4 e da árvore comum de vermelho-preto