offer一直不来，一直在往后拖，池子越来越大，秋招形势恶化小黑深感绝望也在向前的leetcode之旅:114. 二叉树展开为链表（恭喜中老黑第一次约会）

小黑做法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        if not root:
            return None
        head = TreeNode()   
        node = head
        # 初始化栈
        q = [root]
        while q:
            top = q.pop()
            # 加入先序遍历
            node.right = top
            if top.right:
                q.append(top.right)
            if top.left:
                q.append(top.left)
            top.right = None
            top.left = None
            node = node.right
        return head.right

前序遍历法(python)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        if not root:
            return None
        # 初始化栈与Node结点
        q = []
        node = root
        # 初始化前序遍历序列
        display = []
        while q or node:
            while node:
                q.append(node)
                display.append(node)
                node = node.left
            top = q.pop()
            node = top.right
        # 开始进行关联操作
        for t in range(len(display)-1):
            display[t].right = display[t+1]
            display[t].left = None

前序遍历法(java)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        List<TreeNode> list = new ArrayList<TreeNode>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = root;
        while(node != null || !stack.isEmpty()){
            while(node != null){
                // 入栈，遍历
                stack.push(node);
                list.add(node);
                node = node.left;
            }
            TreeNode top = stack.pop();
            node = top.right;
        }
        for(int i = 0;i < list.size()-1;i++){
            list.get(i).right = list.get(i+1);
            list.get(i).left = null;
        }
    }
}

寻找前驱结点法(python)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        curr = root

        while curr:
            if curr.left:
                next_ = curr.left
                processor = next_
                # 寻找curr.left的最右结点,将其关联到curr.right
                while next_.right:
                    next_ = next_.right
                next_.right = curr.right
                # 左变成右
                curr.right = curr.left
                curr.left = None
            curr = curr.right
        return root    

寻找前驱结点法(java)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        TreeNode curr = root;

        while(curr != null){
            if(curr.left != null){
                TreeNode next = curr.left;
                TreeNode processor = next;
                while(next.right != null){
                    next = next.right;
                }
                next.right = curr.right;
                curr.left = null;
                curr.right = processor;
            }
            curr = curr.right;
        }
    }
}

小黑生活

秋招形势的恶化（人太多了）

既然无法改变环境，那就尝试改变自己吧，让每一天都比昨天更强，做最坏的打算，时刻学习!!

恭喜中老黑第一次约会，期待他正式的送花仪式

学校生活碎片

膝盖疼的这段日子就跑少点儿，跑慢点儿

今日清淡饮食第一天，继续保持，明天去拿中药继续调理！