Búsqueda y árbol binario (análisis de animación)

buscar

La búsqueda es el proceso algorítmico de encontrar un elemento específico en una colección de elementos. Por lo general, la respuesta de búsqueda es verdadera o falsa debido a la existencia del elemento. Varios métodos comunes de búsqueda: búsqueda secuencial, búsqueda binaria, búsqueda de árbol binario, búsqueda hash.

Búsqueda binaria

En primer lugar, suponga que los elementos de la tabla están dispuestos en orden ascendente , compare la clave del registro en la posición media de la tabla con la clave de búsqueda, si los dos son iguales, la búsqueda es exitosa; de lo contrario, use el medio registro de posición para dividir la tabla en la primera y segunda subtabla, si la clave del registro de la posición intermedia es mayor que la clave de búsqueda, se busca más en la subtabla anterior; de lo contrario, se busca más en la última subtabla. Repita el proceso anterior hasta que se encuentre un registro que cumpla con las condiciones y la búsqueda sea exitosa, o hasta que la subtabla no exista, la búsqueda no sea exitosa en este momento.

Análisis de algoritmos

// An highlighted block
'''递归实现，产生新的数组进行查找'''
def binary_search(alist, item):
    n=len(alist)
    if n>0:
        midpoint = n//2
        if alist[midpoint]==item:
          return True
        else:
        # 调用binary_search实现递归，再次查找
          if item<alist[midpoint]:
            return binary_search(alist[:midpoint],item)
          else:
            return binary_search(alist[midpoint+1:],item)

testlist = [5,7,11,13,20,30,65]
print("递归实现")
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))

'''非递归实现，在原本的数组中查找'''
def binary_search(alist, item):
    first = 0
    last = len(alist) - 1
    while first <= last:
        midpoint = (first + last) //2
        #按重点值左右查找
        if alist[midpoint] == item:
            return True
        elif item < alist[midpoint]:
            last = midpoint - 1
        else:
            first = midpoint + 1
    return False
testlist = [5,7,11,13,20,30,65]
print("非递归实现")
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))

La búsqueda binaria también se conoce como búsqueda binaria. Sus ventajas son menos tiempos de comparación, velocidad de búsqueda rápida y buen rendimiento promedio; sus desventajas son que la tabla a buscar debe ser una lista ordenada y la inserción y eliminación son difíciles. Por lo tanto, el método de búsqueda binaria es adecuado para buscar listas ordenadas con frecuencia que no cambian con frecuencia.

complejidad del tiempo

Complejidad de tiempo óptimo: O (1)
Peor complejidad de tiempo: O (logn)

Algoritmo de árbol y árbol

Tree (inglés: tree) es un tipo de datos abstractos (ADT) o una estructura de datos que implementa este tipo de datos abstractos y se utiliza para simular una colección de datos con la naturaleza de una estructura de árbol. Está compuesto por n (n> = 1) nodos finitos para formar una colección jerárquica.

Características:
cada nodo tiene cero o más nodos secundarios; los nodos
sin nodos principales se denominan nodos raíz;
cada nodo no raíz tiene y solo un nodo principal; a
excepción del nodo raíz, cada nodo secundario se puede dividir en varios nodos separados Subárbol

Tipo de árbol

Árbol desordenado

No existe una relación de orden entre los nodos secundarios de ningún nodo del árbol.Este tipo de árbol se llama árbol desordenado, también llamado árbol libre;

Árbol ordenado

Existe una relación de orden entre los nodos secundarios de cualquier nodo del árbol, este tipo de árbol se denomina árbol ordenado;

1. Árbol binario: un árbol con un máximo de dos subárboles por nodo se denomina árbol binario;
   árbol binario completo : para un árbol binario, suponga que su profundidad es d (d> 1). Excepto por la capa dth, el número de nodos en las otras capas ha alcanzado el máximo, y todos los nodos de la capa dth están ordenados de izquierda a derecha. Este árbol binario se llama árbol binario completo. La definición de un árbol binario completo son todas las hojas Un árbol binario completo con nodos en la parte inferior.
   
   Árbol binario completo : a excepción de los nodos de hojas, cada nodo tiene cotiledones izquierdo y derecho, y los nodos de hojas están en el nivel más bajo.
   
   Árbol binario equilibrado (árbol AVL) : si y solo si la diferencia de altura entre los dos subárboles de cualquier nodo es no mayor que 1 árbol binario.
   

Clasificación del árbol binario (árbol de búsqueda binaria (en inglés: árbol de búsqueda binaria), también conocido como árbol de búsqueda binaria, árbol binario ordenado);

2. Árbol de Huffman (utilizado para la codificación de información): el árbol binario con la ruta ponderada más corta se llama Huff Man árbol o árbol binario óptimo;
3. Árbol B: árbol de búsqueda binario autoequilibrado optimizado para operaciones de lectura y escritura, que puede mantener los datos en orden y tiene más de dos subárboles.

Árbol binario

Un árbol binario es una estructura de árbol con un máximo de dos subárboles por nodo. Por lo general, los subárboles se denominan "subárbol izquierdo" y "subárbol derecho".

Propiedades (características) de los árboles binarios

Propiedad 1: Hay como máximo 2 ^ (i-1) nodos (i> 0) en el i-ésimo nivel del árbol binario.
Propiedad 2: El árbol binario con profundidad k tiene como máximo 2 ^ k-1 nodo ( k> 0)
Propiedad 3: Para cualquier árbol binario, si el número de nodos hoja es N0, y el número total de nodos con grado 2 es N2, entonces N0 = N2 + 1;
Propiedad 4: La profundidad de un árbol binario completo con n nodos debe ser log2 (n + 1)
Propiedad 5: Para un árbol binario completo, si se numera de arriba a abajo y de izquierda a derecha, el nodo numerado i, su número secundario izquierdo debe ser 2i y su número secundario derecho debe ser 2i + 1; su número principal debe ser i / 2 (i = 1 es la raíz, excepto)

Recorrido del árbol binario

El recorrido del árbol es una operación importante del árbol. El llamado recorrido se refiere al acceso a la información de todos los nodos del árbol, es decir, visitar cada nodo del árbol una vez y sólo una vez, a este tipo de acceso a todos los nodos lo llamamos recorrido. Luego, los dos modos importantes de recorrido del árbol son el recorrido primero en profundidad y el recorrido primero en amplitud, el primero en profundidad generalmente usa recursividad y el primero en ancho generalmente usa colas. En general, la mayoría de los algoritmos que se pueden implementar de forma recursiva también se pueden implementar utilizando la pila.

Amplitud primer recorrido

Comenzando desde la raíz del árbol, atraviesa los nodos de todo el árbol de izquierda a derecha de arriba a abajo.

// An highlighted block
class Node(object):
    """节点类"""
    def __init__(self, item):
        self.elem = item
        self.lchild = None   #设为左边的孩子
        self.rchild = None   #设为右边的孩子
"""二叉树"""
class Tree(object):
    def __init__(self):
        self.root = None

    """为树添加节点"""
    def add(self, item):
        node = Node(item)            #构建节点
        #如果树是空的，则对根节点赋值
        if self.root == None:
            self.root = node
            return
        queue=[self.root]
        while queue:
            #弹出队列的第一个元素
            cur_node = queue.pop(0)
            #如果左边的孩子是否为空，为空，则进行赋值
            #判断左边的孩子是否为空，不为空，则对下一个进行判断
            if cur_node.lchild == None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
                # 如果右边的孩子是否为空，为空，则进行赋值
                # 判断右边的孩子是否为空，不为空，则对下一个进行判断
            if  cur_node.rchild == None:
                cur_node.rchild = node
                return
            else:
                #如果左右子树都不为空，加入队列继续判断
                queue.append(cur_node.rchild)
    '''广度遍历'''
    def breadth_travel(self):
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node=queue.pop(0)
            print(cur_node.elem)
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)
if __name__=="__main__":
    tree=Tree()
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.breadth_travel()

Profundidad primer recorrido

Para un árbol binario, la búsqueda en profundidad es atravesar los nodos del árbol a lo largo de la profundidad del árbol, buscando en las ramas del árbol lo más profundo posible.
Luego, hay tres métodos importantes para el recorrido de profundidad. Estos tres métodos se utilizan a menudo para acceder a los nodos del árbol, la diferencia entre ellos radica en el orden en que se accede a cada nodo. Estos tres tipos de recorridos se denominan preorden, inorden y posorden.

Recorrido de reserva

Nodo raíz -> Subárbol izquierdo -> Subárbol derecho

// An highlighted block
 """递归实现先序遍历"""
 def preorder(self, root):
        if root == None:
            return
        print(root.elem,end="\t")
        self.preorder(root.lchild)
        self.preorder(root.rchild)

Recorrido en orden

Subárbol izquierdo -> nodo raíz -> subárbol derecho

  """递归实现中序遍历"""
 def inorder(self, root):
        if root == None:
            return
        self.inorder(root.lchild)
        print(root.elem,end="\t")
        self.inorder(root.rchild)

Recorrido posterior al pedido

Subárbol izquierdo -> subárbol derecho -> nodo raíz

// An highlighted block
  """递归实现后续遍历"""
def postorder(self, root):
      if root == None:
          return
      self.postorder(root.lchild)
      self.postorder(root.rchild)
      pprint(root.elem,end="\t")

El árbol binario se determina atravesando un árbol

Recorrido de primer orden 0137849256 regla: raíz izquierda y derecha
, recorrido de orden medio 7381940526 regla: raíz izquierda derecha