8.25 二叉树中等 114 Flatten Binary Tree to Linked List 116 Populating Next Right Pointers in Each Node

114 Flatten Binary Tree to Linked List

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void flatten(TreeNode* root) {
        //将二叉树转换为“链表”
        //链表形式：右指针指向下一个结点
        //下一个结点时先序遍历的结果
        if(!root) return;
        //先序遍历
        stack<TreeNode*> curr;
        
        if(root->right)curr.push(root->right);
        if(root->left)curr.push(root->left);       

        TreeNode* write = root;

        while(!curr.empty()){
            TreeNode* read = curr.top();curr.pop();

            //访问节点
            write->right = read;
            write->left = nullptr;
            write = write->right;

            if(read->right)curr.push(read->right);
            if(read->left)curr.push(read->left);       
        }        
    }
};

c++代码review：先序遍历

void preorder(TreeNode* root){
	if(!root) return;
	stack<TreeNode*> stk;
	while(!stk.empty()){
		TreeNode* node = stk.top();stk.pop();

		if(node->right) stk.push(node->right);
		if(node->left)stk.push(node->left);
	}
}

116 Populating Next Right Pointers in Each Node

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

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        //next指向它的右侧兄弟
        //层次遍历, 然后按顺序遍历就好
        if(!root) return root;
        queue<Node*> que;
        que.push(root);

        Node* node = root;
        while(!que.empty()){
            //遍历一层
            int n = que.size();
            for(int i = 0 ; i < n-1 ; i++){
                node = que.front();
                que.pop();
                node->next = que.front();                

                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            //每层最后一个结点入队
            node = que.front();
            que.pop();
            //node->next = nullptr;
            if(node->left)que.push(node->left);
            if(node->right)que.push(node->right);
        }
        return root;


    }
};

c++代码review：层次遍历

vector<vector<int>> levelorder(TreeNode* root){
	if(!root) return {};
	
	queue<TreeNode*> que;
	que.push(root);
	
	vector<vector<int>> res;

	while(!que.empty()){
		vector<int> prev = {};
		int n = que.size();
		for(int i = 0 ; i < n ;i ++){
			TreeNode* node = que.front();
			que.pop();
			prev.push_back(node->val);
			//左右孩子入队
			if(node->left)que.push(node->left);
			if(node->right)que.push(node->right);
		}
		res.push_back(prev);
	}
	
}