leetcode99. Restaurar el árbol de búsqueda binaria / recorrido en orden

Problema: dos nodos en el árbol de búsqueda binaria se intercambian incorrectamente.

Restaure este árbol sin cambiar su estructura.

Ejemplo 1:

输入: [1,3,null,null,2]

   1
  /
 3
  \
   2

输出: [3,1,null,null,2]

   3
  /
 1
  \
   2

Ejemplo 2:

输入: [3,1,4,null,null,2]

  3
 / \
1   4
   /
  2

输出: [2,1,4,null,null,3]

  2
 / \
1   4
   /
  3

Avanzado:

• La solución que utiliza la complejidad del espacio O (n) es fácil de implementar.
• ¿Puedes pensar en una solución que use solo espacio constante?

Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/recover-binary-search-tree Los
derechos de autor son propiedad de LeetCode . Para reimpresiones comerciales, comuníquese con la autorización oficial. Para reimpresiones no comerciales, indique la fuente.

Idea básica 1: recorrido en orden

El resultado del recorrido en orden del árbol de búsqueda binaria debe ser una secuencia ascendente, por lo que la secuencia en el recorrido de orden medio en esta pregunta se convierte en una secuencia ascendente después de intercambiar dos elementos.

• Primero, realice un recorrido en orden del árbol binario y guarde la secuencia de resultados del recorrido en orden
• Encuentre el elemento pre antes del primer elemento invertido en la secuencia de resultados
• Busque desde el elemento anterior a la parte posterior. Cuando se encuentra una temperatura de elemento mayor que el elemento, la publicación del elemento anterior a la temperatura es el elemento que debe intercambiarse
• Intercambia los dos elementos de pre y post

La complejidad del espacio es O (n).
Defina una matriz para guardar el orden de recorrido en orden

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    
    
public:
    vector<TreeNode*> vec;
    void recoverTree(TreeNode* root) {
    
    
        inorder(root);
        int pre = 0, i;
        for(i = 1; i < vec.size(); ++i){
    
    
            if(vec[i]->val > vec[pre]->val)
                ++pre;
            else
                break;
        }
        
        for(; i < vec.size(); ++i){
    
    
            if(vec[i]->val > vec[pre]-> val)
                break;
        }
        --i;
        int t = vec[i]->val;
        vec[i]->val = vec[pre]->val;
        vec[pre]->val = t;
        
    }
    void inorder(TreeNode* root){
    
    
        if(root == NULL)
            return;
        inorder(root->left);
        vec.push_back(root);
        inorder(root->right);
    }
};

La complejidad del espacio es O (1):
defina dos variables para guardar los dos nodos en orden inverso

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    
    
public:
    
    void recoverTree(TreeNode* root) {
    
    
        TreeNode* pre1 = NULL, *pre2 = NULL;
        inorder(root, pre1, pre2);
        int t = pre1->val;
        pre1->val = pre2->val;
        pre2->val = t;
    }
    void inorder(TreeNode* root, TreeNode* &pre1, TreeNode* &pre2){
    
    
        if(root == NULL)
            return;
        inorder(root->left, pre1, pre2);
        if(pre1 == NULL){
    
    //root是根节点的情况
            pre1 = root;
        }
        else{
    
    
            if(root->val > pre1->val && (!pre2 || root->val < pre2->val)){
    
    
                pre1 = root;
            }
            else if(pre2 == NULL){
    
    //此时找到了第一个需要交换的节点，保存在pre2中
                pre2 = pre1;
                pre1 = root;
            }
            if((root->val < pre1->val) && (pre2) && (pre2->val > root->val)){
    
    //此时找到了第二个需要交换的节点保存在pre1中
                pre1 = root;
            }
        }
        inorder(root->right, pre1, pre2);
    }
};