二叉树 level order 遍历问题汇总

一 如何确定层结束？

1 维护一个levelEnd，如果当前结点等于level end，更新levelEnd 为queue.back()，注意先判断queue是否empty，（最后一层结束后，queue就空了）。

2 维护一个curLevelNum 和 一个nextLevelNum，当curLevelNum count down 到0时候，更新curLevelNum 为 nextLevelNum，同时nextLevelNum清零

3 遍历完一层的时候，队列里存着的就是下一层的所有结点，int levelSize = queue.size()，就是下一层要取的个数

public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
    ArrayList result = new ArrayList();

    if (root == null)
        return result;

    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.offer(root);

    while (!queue.isEmpty()) {
        ArrayList<Integer> level = new ArrayList<Integer>(); // important
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode head = queue.poll();
            level.add(head.val);
            if (head.left != null)
                queue.offer(head.left);
            if (head.right != null)
                queue.offer(head.right);
        }
        result.add(level); // important
    }

    return result;
}

二 还有一种基于DFS + level号 的层次遍历方式

只是最终结果是按层次保存在vector<vector<int>>的，过程是dfs的。vector<vector<int>>第一维就是层，下标就是层号，第二维是每层的结点。dfs加一个维护递归深度的参数，访问到结点append到对应的层vector。

vector<vector<int> > levelOrder(TreeNode *root) {
        vector<vector<int>> res;
        dfs(root, 0, res);
        return res;
    }
    void dfs(TreeNode* root, int level, vector<vector<int>> &res) {
        if (!root) return;
        if (level == res.size()) res.push_back(vector<int>());
        res[level].push_back(root -> val);
        dfs(root -> left, level + 1, res);
        dfs(root -> right, level + 1, res);
    }

三 序列化二叉树

标准层次遍历的框架， “访问结点”的逻辑是，如果为空，append ”#“ '到结果集， 如果不为空，append 结点值到结果集，把左右子树入队（不管是不是NULL)。

最后要把trailing 的 ”#“ 去掉。或者维护队列里非空结点的个数，while (!q.empty() && numOfNotNull > 0)，这样就不会添加不必要的“＃”了

vector<string> serializeTree(TreeNode* root) {
	vector<string> res;
	if (root == NULL) return res;
	queue<TreeNode*> q;
	for (q.push(root); !q.empty(); ) {
		auto root = q.front(); q.pop();
		res.push_back(root ? to_string(root->val) : "#");
		if (root) {
			q.push(root->left);
			q.push(root->right);
		}
	}
	while(res.back() =="#") res.pop_back();
	return res;
}

三 反序列化二叉树

1）单独读取序列第一个，作为root，同时root 入队。

2）输入序列还有值：出队一个结点parent，（将为这个结点添加左、右孩子），从序列中读一个值，如果不是'#'，创建一个新结点作为parent的左孩子，并加进队列，再读一个值（如果有的话），如果不是’#‘，创建一个新结点作为parent的右孩子，加进队列。是''#"的情况对应孩子域应为NULL，因为是默认值，所以不必处理。

def deserialize(self, data):
        # write your code here
        if len(data) == 0: return None
        root = TreeNode(data.pop(0))
        q , i = [], 0
        q.append(root)
        while i < len(data):
            node = q.pop(0)
            val, i = data[i], i + 1
            if val != '#': 
                node.left = TreeNode(int(val))
                q.append(node.left)
            if i < len(data):
                val, i = data[i], i + 1
                if val != '#':
                    node.right = TreeNode(int(val))
                    q.append(node.right)
        return root

TreeNode* deserializeLevelOrder(vector<string> &A) {
	if (A.empty()) return nullptr;
	queue<TreeNode*> q;
	auto root = new TreeNode(stoi(A[0]));
	q.push(root);
	for (int i = 1; i < A.size(); ++i) {
		auto node = q.front(); q.pop();
		if (A[i] != "#") {
			node->left = new TreeNode(stoi(A[i]));
			q.push(node->left);
		}
		if (++i < A.size() && A[i] != "#") {
			node->right = new TreeNode(stoi(A[i]));
			q.push(node->right);
		}
	}
	return root;
}

四 添加sibling 指针 

 1 dfs + levelTail 向量

dfs 加一个 维护递归深度的参数level，用一个level indexed vector  levelTail  保存每一层的尾。如果level == sevelTail.size() 则说明第一次到达该层，当前结点是level层的第一个结点，push_back 该结点。否则，levelTail[level] 指向当前结点，当前结点为新的level tail

void connect(TreeLinkNode *root, vector<TreeLinkNode*> &levelTail, int level){
	if (!root) return;
	if (level==levelTail.size()) levelTail.push_back(root);
	else{
		levelTail[level]->next = root;
		levelTail[level] = root;
	}
	connect(root->left, levelTail, level + 1);
	connect(root->right, levelTail, level + 1);
}

 2 层次遍历，利用已经添加好sibling指针的上一层作为队列

循环不变式是，当前层已经是一个表头为head的链表，下一层链表头为dummy，遍历当前链表，把下一层结点依次添加到下一层链表尾部，遍历结束后当前层链表头head更新为下一层的头 dummy.next

void connect(TreeLinkNode *root) {
        auto head = root;
        while (head ) {
            TreeLinkNode dummy(-1);
            for (TreeLinkNode *p = head, *prev = &dummy; p; p = p->next) {
                if (p->left) {
                    prev->next = p->left;
                    prev = prev->next;
                }
                if (p->right) {
                    prev->next = p->right;
                    prev = prev->next;
                }
            }
            head = dummy.next;
        }
    }