【重点】【二叉树】【DFS】剑指offer——面试题27：二叉搜索树与双向链表

力扣
理解并记忆该题思路！！！
类似题目连接：Top100：114. 二叉树展开为链表，中的头插法，值得学习！！！

Python

"""
# Definition for a Node.
class Node:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
"""
class Solution:
    pre = None
    head = None

    def treeToDoublyList(self, root: 'Node') -> 'Node':
        if not root:
            return root
        self.dfs(root)
        self.head.left = self.pre
        self.pre.right = self.head

        return self.head
    
    def dfs(self, cur):
        if not cur:
            return
        
        self.dfs(cur.left)
        if not self.head: # 记录头节点
            self.head = cur
        else:             # 修改节点指向
            self.pre.right = cur
            cur.left = self.pre
        self.pre = cur
        self.dfs(cur.right)

Java

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val,Node _left,Node _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
    Node pre, head; // 前驱节点，头结点
    public Node treeToDoublyList(Node root) {
        if (root == null) {
            return null;
        }
        dfs(root);
        head.left = pre;
        pre.right = head;
        return head;
    }

    public void dfs(Node cur) {
        if (cur == null) {
            return;
        }
        dfs(cur.left);
        if (pre != null) {
            pre.right = cur;
        } else {
            head = cur; // 头结点
        }
        cur.left = pre;
        pre = cur;
        dfs(cur.right);
    }
}

Solution1:
这是书上的代码，要理解好最近几道题，对指针的操作比较多。。。

class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree) {
        TreeNode *pLastNodeInList = NULL;
        ConvertNode(pRootOfTree, pLastNodeInList);
        //pLastNodeInList指向双链表的尾结点
        //返回头结点
        TreeNode *pHeadOfList = pLastNodeInList;
        while(pHeadOfList && pHeadOfList->left)
            pHeadOfList = pHeadOfList->left;
        return pHeadOfList;
    }
    void ConvertNode(TreeNode* pNode, TreeNode *&pLastNodeInList){ //第二个参数是指针的引用
        if(!pNode)
            return;
        TreeNode *pCurrent = pNode;  //pNode目前指向的根结点，把pCurrent初始化为指向此根节点
        if(pCurrent->left)   //如果根结点的左子树非空，则去处理左子树
            ConvertNode(pCurrent->left, pLastNodeInList);
        
        pCurrent->left = pLastNodeInList;//把左子树中值最大的结点的位置赋值给当前根结点的左指针
        if(pLastNodeInList)
            pLastNodeInList->right = pCurrent;//相应的根结点的位置赋给左子树中值最大结点的右指针
                                              //经过这两步就把当前的根结点串到双向链表中了
        pLastNodeInList = pCurrent;           //所以，这一步就更新链表中尾结点的位置，设为当前根结点的位置
        
        if(pCurrent->right)           //右子树非空，处理右子树去。。
            ConvertNode(pCurrent->right,pLastNodeInList);
    }
};