recorrido de orden usando la reconstrucción binario y preorden

prefacio

Me encontré con un problema de este tipo, y ahora sé preorden recorrido y después de la orden de recorrido de árbol binario, cómo reconstruir un árbol binario de esta información.
A primera vista, el bit ignorantes estima un poco, los datos a un análisis cuidadoso para saber, de hecho, bastante simple.

pensamiento algoritmo

Existen los siguientes datos:

Preorden recorrido: 32154879
preorden: 12345789

De acuerdo con la ley de recorrido preorden de nosotros sabemos, los primeros datos de recorrido preorden es el nodo raíz de los datos, bien que marcaron el primer bit de datos:

Preorder traversal: [3] 2.154.879
orden previo: 1 2 [3] 45 789

De acuerdo con la ley, entonces se recorre (antes, durante y después de la orden de desplazamiento se realiza de la misma), sabemos que atraviesan siempre primera sub-árbol de salida de la izquierda, y luego la salida del subárbol derecho, difieren sólo los datos de la posición de la raíz (antes, durante y después de ). Así que en el recorrido orden, los datos del nodo raíz es los datos ligados a la izquierda del subárbol izquierdo, derecho son datos subárbol derecho. A partir de este punto, podemos poner los datos en la raíz, subárbol izquierdo y subárbol derecho.

Root antes de preorden: 3 preorden: 3
delante fin subárbol izquierdo de recorrido: 21 preorden: 12
delante preorden subárbol derecho: 54879 preorden: 45789

OK, a este punto más adelante, amigo sabio debe saber cómo hacer a continuación. El subárbol izquierdo y subárbol derecho recursivamente realizan la misma operación que anteriormente, hasta que todos los datos para hacer un nodo raíz, el final de la ejecución del algoritmo.

la implementación del código

//二叉树结构体
struct Tree {
	int value;
	Tree *left;
	Tree *right;
};

//pre:前序遍历
//mid:中序遍历
//length:数组长度
Tree* Fun(const int *pre, const int *mid,const int length) {
	//当空指针或者数组长度为0时返回
	if (pre == NULL || mid == NULL || length <= 0) 
	    return NULL;

	//建立根节点
	Tree *head = new Tree();
	head->value=pre[0];

	//找到中序遍历中根节点所在位置
	int index = 0;
	while (index<length) {
		if (head->value == mid[index])
			break;
		++index;
	}

	//划分左子树
	head->left = Fun(pre + 1, mid, index);
	//划分右子树
	head->right = Fun(pre + index +1, mid + index + 1, length - index - 1);

	return head;
}

propagación

recorrido el orden y la forma de pre-orden de recorrido si después de reemplazar? La idea sigue siendo la misma, amigos interesados ​​pueden explorar por su cuenta. Boring pongo el código también se pierde aquí.

//mid:中序遍历
//back:后序遍历
//length:数组长度
Tree* Fun2(const int *mid,const int *back,const int length){
    //当空指针或者数组长度为0时返回
    if(back==NULL||mid==NULL||length<=0)
        return NULL;
    
    //建立根节点
    Tree *head=new Tree();
    head->val=back[length-1];
    head->left=head->right=NULL;
    
    //找到中序遍历中根节点所在位置
    int index=0;
    while(index<length){
        if(head->val==mid[index]){
            break;
        }
        ++index;
    }
    
    //划分左子树
    head->left=Fun2(mid,back,index);
    //划分右子树
    head->right=Fun2(mid+index+1, back+index, length-index-1);
    
    return head;
}

Si no reservarlo? recorrido orden delante y árbol orden posterior pueden caer para lanzarlo? Los interesados pueden ver otro artículo que emplee dos binaria reconstrucción recorrido de árbol .