leecode 解题总结：116. Populating Next Right Pointers in Each Node

#include <iostream>
#include <stdio.h>
#include <vector>
#include <queue>
#include <sstream>
using namespace std;
/*
问题:
Given a binary tree

struct TreeLinkNode {
TreeLinkNode *left;
TreeLinkNode *right;
TreeLinkNode *next;
}
Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Note:

You may only use constant extra space.
You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).
For example,
Given the following perfect binary tree,
1
/  \
2    3
/ \  / \
4  5  6  7
After calling your function, the tree should look like:
1 -> NULL
/  \
2 -> 3 -> NULL
/ \  / \
4->5->6->7 -> NULL

分析:给定一颗二叉树，填充结点的next指针来指向它的下一个右边的结点。如果没有下一个
右侧的结点，下一个指针应该被设置为空。初始化，所有下一个指针都是被设置为NULL。
注意：
1】只能使用常量空间
2】可以假设这颗二叉树是一个完全二叉树，所有的叶子结点都是在同一层
每个父节点都有两个孩子结点。

根节点的next为空，从根节点往下，最左边的孩子结点都会指向右边的指针。
假设当前结点为root，
root->left->next = root->right;
root->right->next = NULL;
这个类似之前做的判断一棵树是不是对称，递归的输入一定是当前结点的左右孩子结点

输入:
7
1 2 3 4 5 6 7
15
-1 0 1 2 3 4 5 6 7 8 9 10 11 12 13
输出:
1 NULL 2 3 NULL 4 5 6 7 NULL
-1 NULL,0 1 NULL, 2 3 4 5 NULL, 6 7 8 9 10 11 12 13 NULL
报错:原因是中间有两个结点忘记连接了
Input:
{-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13}
Output:
{-1,#,0,1,#,2,3,4,5,#,6,7,8,9,#}
Expected:
{-1,#,0,1,#,2,3,4,5,#,6,7,8,9,10,11,12,13,#}
-1
0				1
2		3		4		5
6	   7   8  9   10  11   12  13

关键:
1 这个类似之前做的判断一棵树是不是对称，递归的输入一定是当前结点的左右孩子结点
//下面是左右孩子都非空的，让左孩子的next指向右孩子，右孩子的next指向空
leftNode->next = rightNode;
rightNode->next = NULL;
//处理各自的左右孩子结点
connectHelper(leftNode->left , leftNode->right);
//别忘记中间需要连接,但是这一组却不需要递归；也是需要递归的，否则会遗漏中间连接的部分，
connectHelper(leftNode->right , rightNode->left);
connectHelper(rightNode->left , rightNode->right);
}
*/

struct TreeLinkNode {
int val;
TreeLinkNode *left, *right, *next;
TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
TreeLinkNode() : left(NULL), right(NULL), next(NULL) {}
};

class Solution {
public:
//由于是完全二叉树，那么一棵树的左右孩子结点要么全部为空，要么全部都不空
void connectHelper(TreeLinkNode* leftNode , TreeLinkNode* rightNode )
{
//当前结点的孩子结点都为空，无需连接
if(NULL == leftNode && NULL == rightNode)
{
return;
}
//只有一个为空，不符合题目条件，不处理
if(NULL == leftNode || NULL == rightNode)
{
return;
}

//下面是左右孩子都非空的，让左孩子的next指向右孩子，右孩子的next指向空
leftNode->next = rightNode;
rightNode->next = NULL;
//处理各自的左右孩子结点
connectHelper(leftNode->left , leftNode->right);
//别忘记中间需要连接,但是这一组却不需要递归；也是需要递归的，否则会遗漏中间连接的部分，
connectHelper(leftNode->right , rightNode->left);
connectHelper(rightNode->left , rightNode->right);
}

void connect(TreeLinkNode *root) {
//根节点为空，不需要处理
if(!root)
{
return;
}
//接下来设置根节点自己的next指针为null
root->next = NULL;
//递归处理孩子结点
connectHelper(root->left , root->right );
}
};

const int MAXSIZE = 1000;
TreeLinkNode gNodeArr[MAXSIZE];
int gIndex;
TreeLinkNode* createNode(int value)
{
++gIndex;
gNodeArr[gIndex].val = value;
return &gNodeArr[gIndex];
}

//构建二叉树，这里默认首个元素为二叉树根节点，然后接下来按照作为每个结点的左右孩子的顺序遍历
TreeLinkNode* buildBinaryTree(vector<int>& nums)
{
if(nums.empty())
{
return NULL;
}
TreeLinkNode* root;
int size = nums.size();
int j = 0;
//结点i的孩子结点是2i,2i+1
for(int i = 0 ; i < size ; i++)
{
if(i)
{
createNode(nums.at(i));
}
else
{
root = createNode(nums.at(i));
}
}
//设定孩子结点指向,
for(int i = 1 ; i <= size ; i++)
{
if(2 * i <= size)
{
gNodeArr[i].left = &gNodeArr[2*i];
}
if(2*i + 1 <= size)
{
gNodeArr[i].right = &gNodeArr[2*i + 1];
}
}
//设定完了之后，返回根节点
return root;
}

//层序遍历
void levelVisit(TreeLinkNode* root, vector< string >& result)
{
if(!root)
{
return;
}
queue<TreeLinkNode*> nodes;
nodes.push(root);
int size = 1;
int nextSize = 0;
TreeLinkNode* node;
vector<TreeLinkNode*> beginNodes;
//先找到每一层的起始结点，也就是size=0的结点，然后对每个起始结点遍历即可
while(!nodes.empty())
{
node = nodes.front();
nodes.pop();

//将每一层的起始结点存储起来
if(0 == nextSize)
{
beginNodes.push_back(node);
}
if(node->left)
{
nodes.push(node->left);
nextSize++;
}
if(node->right)
{
nodes.push(node->right);
nextSize++;
}
size--;
if(0 == size)
{
size = nextSize;
nextSize = 0;
}
}
if(beginNodes.empty())
{
return;
}
int len = beginNodes.size();
TreeLinkNode* head = NULL;
for(int i = 0 ; i < len ; i++)
{
head = beginNodes.at(i);
stringstream stream;
while(head)
{
stream << head->val << "->";
head = head->next;
}
stream << "NULL";
result.push_back(stream.str());
}
}

void print(vector<string>& result)
{
if(result.empty())
{
cout << "no result" << endl;
return;
}
int size = result.size();
for(int i = 0 ; i < size ; i++)
{
cout << result.at(i) << " " ;
}
cout << endl;
}

void process()
{
vector<int> nums;
int value;
int num;
Solution solution;
vector<string> result;
while(cin >> num )
{
nums.clear();
result.clear();
for(int i = 0 ; i < num ; i++)
{
cin >> value;
nums.push_back(value);
}
TreeLinkNode* root = buildBinaryTree(nums);
solution.connect(root);
levelVisit(root, result);
print(result);
}
}

int main(int argc , char* argv[])
{
process();
getchar();
return 0;
}