[Estructura de datos del algoritmo de clasificación de árbol binario]

El árbol binario es una estructura de árbol muy importante, su estructura de almacenamiento y sus operaciones son relativamente simples, y el árbol también es fácil de convertir en un árbol binario, este artículo analiza principalmente el recorrido de un árbol binario, que se divide en tres tipos de recorrido : Preorder, Middle Order y Postorder Way, usar la recursividad para recorrer la introducción del código es fácil de entender. Lo siguiente primero presenta el recorrido recursivo de preorden y el recorrido no recursivo de orden medio y posterior a la orden.

La definición de recorrido de árbol binario

  1. Atravesar primero.
    Si el árbol binario está vacío, entonces no hay operación; de lo contrario, realice las siguientes operaciones en secuencia.
  • Visita el nodo raíz
  • Primero atraviesa el subárbol izquierdo del nodo raíz
  • Primero atraviesa el subárbol derecho del nodo raíz
  1. Recorrido en orden
    Si el árbol binario está vacío, entonces no hay operación; de lo contrario, realice las siguientes operaciones en secuencia.
  • Atraviesa el subárbol izquierdo del nodo raíz en orden medio
  • Visita el nodo raíz
  • Atraviesa el subárbol derecho del nodo raíz en orden medio
  1. Traslado posterior a la orden
    Si el árbol binario está vacío, no hay operación; de lo contrario, realice las siguientes operaciones en secuencia.
  • La orden posterior atraviesa el subárbol izquierdo del nodo raíz
  • La orden posterior atraviesa el subárbol derecho del nodo raíz
  • Visita el nodo raíz

El diagrama de ejemplo de árbol binario
no coincide con el tipo definido en este artículo.

Descripción de tipo de árbol binario

typedef struct BTNode
{
    
    
	int elem;
	struct BTNode *left,*right;
}*BinTree;

【Recorrido de pedido anticipado】

void PreOrder(BinTree root)
{
    
    
	if(root!=NULL)
	{
    
    
		printf("%4d",root->elem);  /*访问根结点*/
		PreOrder(root->left);      /*先序遍历根结点的左子树*/
		PreOrder(root->right);     /*先序遍历根结点的右子树*/
	}
}

Recorrido en orden y recorrido recursivo posterior
Sin demasiada introducción aquí, comencemos con recorrido no recursivo.

[Recorrido en orden no recursivo]
La idea principal del algoritmo no recursivo del recorrido en orden de árbol binario es hacer que la raíz de la variable sea un puntero al nodo raíz y atravesar desde el nodo raíz. Obviamente, no se accede al nodo raíz la primera vez que se encuentra, sino que se inserta en la pila, porque en este momento aún no se ha accedido al nodo raíz apuntado por raíz y su subárbol derecho, por lo que la raíz debe guardarse en el archivo. stack para que se pueda acceder después del subárbol izquierdo, tome la raíz de la pila y acceda al nodo raíz y su subárbol derecho. Después de que root ingresa a la pila, atraviesa su subárbol izquierdo en el orden medio, es decir, asigna el hijo izquierdo de root a root y camina por la cadena izquierda hasta que la cadena izquierda está vacía y el subárbol izquierdo se atraviesa y el nodo sale . Asignar el elemento de pila a la raíz. Esta es la segunda vez que se encuentra el nodo. En este momento, se ha accedido al subárbol izquierdo. De acuerdo con la definición del recorrido de orden medio, visite el nodo raíz (imprima la información del nodo), y luego el orden medio Atraviesa su subárbol derecho, es decir, asigna el hijo derecho de root a root y repite el proceso anterior hasta que root sea una pila vacía.
Se resume a grandes rasgos como:

  1. Compruebe el lado izquierdo después de apilar. Compruebe el lado derecho después de desapilarlo.
  2. La característica del recorrido en orden no recursivo es el nodo raíz de la pila avanzada, y luego se juzga si hay un nodo izquierdo
  3. Si continúa empujando la pila, si está vacía, saque la pila, después de hacer estallar la pila, juzgue si hay un nodo correcto
  4. Si hay un nodo derecho en la pila. Y así. La acción de empujar hacia la pila es continua (siempre que haya un nodo izquierdo, continuará empujándose hacia la pila), y
    la acción de hacer estallar es solo una vez. Porque después de hacer estallar la pila, se juzgará si hay un nodo correcto, si lo hay y el nodo no está vacío, se repetirá el proceso anterior, si la estallido continúa.

Definir la pila

#define MaxSize
typedef struct
{
    
    
	BinTree elem[MaxSize];
	int top;
}SeqStack;

La descripción del algoritmo de la realización no recursiva del recorrido de orden medio:

void InOrder(BinTree root)
{
    
    
	SeqStack s;
	s.top=-1;
	do
	{
    
    
		while(root!=NULL)
		{
    
    
			s.top++;
			if(s.top>=MaxSize-1)
			{
    
    
				printf("栈已经满了!\n");
				return ;
			}
			else
			{
    
    
				s.elem[s.top]=root;
				root=root->left;
			}
		}
		if(s.top!=-1)
		{
    
    
			root=s.elem[s.top];
			s.top--;
			printf("\n%4d",root->elem);
			root=root->right;
		}
	}while((s.top!=-1)||(root!=NULL));
	
}

[Recorrido posterior no recursivo]

  1. Establezca la parte superior de la pila en -1. Cuando el nodo raíz no esté vacío, empuje a la pila y establezca el número de visitas del nodo en cero, y juzgue nuevamente si hay un elemento a la izquierda, y si lo hay, continúe para empujar la pila. (El elemento de la izquierda es el extremo vacío)
  2. Haga estallar la pila, después de salir, determine si la pila está vacía y saque el elemento superior de la pila cuando no esté vacía. Determine si hay un niño adecuado o si el número de visitas es cero.
  3. Si no hay un niño adecuado y el número de visitas es 1, la pila se abrirá. De lo contrario (es decir, cuando hay un hijo correcto y el número de visitas es cero), establezca el número de visitas del nodo en 1. Luego asigne la dirección del hijo correcto al nodo.
  4. Determina si el nodo está vacío. Cuando no esté vacío, empuje la pila y establezca el número de visitas del nodo en cero. Accede al elemento de la izquierda. Ciclo a su vez (código combinado)
void PostOrder(BinTree root)
{
    
    
	SeqStack s;
	s.top=-1;
	while(root!=NULL)
	{
    
    
		s.top++;
		if(s.top==MaxSize-1)
		{
    
    
			printf("栈已经满了!\n");
			printf("Error");
		}
		else
		{
    
    
			root->count=0;
			s.elem[s.top]=root;
			root=root->left;
		}
	}
	while(s.top!=-1)
	{
    
    
		root=s.elem[s.top];
		if(root->right==NULL||root->count==1)
		{
    
    
			printf("\n%c",root->elem);
			s.top--;
		}
		else if(root->right!=NULL&&root->count!=1)
		{
    
    
			root->count=1;
			root=root->right;
			while(root!=NULL)
			{
    
    
				s.top++;
				s.elem[s.top]=root;
				root->count=0;
				root=root->left;
			}
		}
	}
}

Traversal
de preorden: ABDECF Traversal
de orden medio: DBEAFC Traversal de postorden: DEBFCA

Supongo que te gusta

Origin blog.csdn.net/qq_37640410/article/details/108196564
Recomendado
Clasificación