【LeetCode】 236. El ancestro común más cercano del árbol binario, árbol de búsqueda binaria JZ36 y lista doblemente enlazada

 Autor: Xiao Lu

 

Columna: "Leetcode"

Palabras favoritas: El mundo es más hermoso gracias a los jóvenes que se ponen de pie. —— "Diario del Pueblo"

---

 236. Ancestro común más cercano del árbol binario

236. Ancestro común más cercano del árbol binario

Descripción del Título:

Dado un árbol binario, encuentre el ancestro común más cercano de dos nodos específicos en el árbol.

La definición del ancestro común más cercano en la Enciclopedia Baidu es: "Para dos nodos pyq de un árbol enraizado T, el ancestro común más cercano se expresa como un nodo x, satisfaciendo que x es el ancestro de pyq y la profundidad de x es lo más grande posible (un nodo A también puede ser su propio ancestro)".

Ejemplo:

Ideas:

Aquí usamos dos pilas para almacenar las rutas de p y q, de modo que el problema pueda convertirse en un problema de intersección de listas enlazadas.

Deje que el grande dé el paso de diferencia primero y luego camine al mismo tiempo para encontrar el mismo nodo y regresar.

código:

class Solution {
public:
        bool GetPath(TreeNode*root,TreeNode*x,stack<TreeNode*>&Path)
        {
            if(root==nullptr)
            return false;
            Path.push(root);
            if(x==root)
            return true;
            
            if(GetPath(root->left,x,Path))
                return true;
            if(GetPath(root->right,x,Path))
                return true;
            Path.pop();
            return false;

        }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        stack<TreeNode*>pPath,qPath;
        GetPath(root,p,pPath);
        GetPath(root,q,qPath);
        while(pPath.size()!=qPath.size())
        {
            if(pPath.size()>qPath.size())
            pPath.pop();
            else
            qPath.pop();
        }
        while(pPath.top()!=qPath.top())
        {
            pPath.pop();
            qPath.pop();
        }
        return pPath.top();
    }
};

 Árbol de búsqueda binaria JZ36 y lista doblemente enlazada

Documento de desarrollo de árbol de búsqueda binaria y lista doblemente enlazada

 Descripción del Título:

Ingrese un árbol de búsqueda binario y convierta el árbol de búsqueda binario en una lista doblemente enlazada ordenada. Como se muestra abajo

Requisitos: complejidad espacial O (1) (es decir, operar en el árbol original), complejidad temporal O (n)

Aviso:

1. Es necesario que no se puedan crear nuevos nodos, solo se puede ajustar la orientación de los punteros de los nodos en el árbol. Una vez completada la transformación, el puntero izquierdo del nodo en el árbol debe apuntar al predecesor y el puntero derecho del nodo en el árbol debe apuntar al sucesor 2. Devuelva el puntero al primer nodo en el
enlace lista
3. El TreeNode devuelto por la función tiene punteros izquierdo y derecho, que de hecho se pueden ver en una estructura de datos de una lista doblemente enlazada.

4. No necesita generar la lista doblemente enlazada, el programa la imprimirá automáticamente de acuerdo con su valor de retorno.

Ejemplo:

Ideas:

Utilice el recorrido en orden para cambiar la orientación de los nodos

código:

class Solution {
public:
    void _Convert(TreeNode*&prev,TreeNode*cur)
	{
		if(cur==nullptr)
		return ;
		
		_Convert(prev,cur->left);
		//root
			cur->left=prev;
			if(prev)
		    prev->right=cur;
			prev=cur;
		
		_Convert(prev,cur->right);
	} 

    TreeNode* Convert(TreeNode* pRootOfTree) {
        TreeNode*prev=nullptr;
		TreeNode*cur=pRootOfTree;
		
		_Convert(prev,cur);
		TreeNode*head=pRootOfTree;
		while(head&&head->left)
		{
			head=head->left;
		}
		return head;
    }
};