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

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <sstream>
#include <queue>
using namespace std;
/*
问题:
Follow up for problem "Populating Next Right Pointers in Each Node".

What if the given tree could be any binary tree? Would your previous solution still work?

Note:

You may only use constant extra space.
For example,
Given the following binary tree,
1
/  \
2    3
/ \    \
4   5    7
After calling your function, the tree should look like:
1 -> NULL
/  \
2 -> 3 -> NULL
/ \    \
4-> 5 -> 7 -> NULL

关键:
分析:此题和之前的题目不同在于给定的是任意二叉树，也就是说可能存在
某些结点没有孩子或者只有1个孩子。这种情况最好就是用层序遍历来做，如果用之前的递归来做
会存在可能两个结点中间有多个结点都没有，这样就无法连接。
用层序遍历。遍历每一层的结点，然后将同一层的结点放在一起，然后设置结点指向
*/

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;
}

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 levelVisit(TreeLinkNode* root)
{
if(!root)
{
return;
}
queue<TreeLinkNode*> nodes;
nodes.push(root);
int size = 1;
int nextSize = 0;
TreeLinkNode* node;
vector<TreeLinkNode*> result;
vector< vector<TreeLinkNode*> > results;
//先找到每一层的起始结点，也就是size=0的结点，然后对每个起始结点遍历即可
while(!nodes.empty())
{
node = nodes.front();
nodes.pop();
result.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;
vector<TreeLinkNode*> tempResult(result);
results.push_back(tempResult);
result.clear();
}
}
if(results.empty())
{
return;
}
int len = results.size();
TreeLinkNode* head = NULL;
vector<string> strResult;
for(int i = 0 ; i < len ; i++)
{
size = results.at(i).size();
//stringstream stream;
//stream << results.at(i).at(0)->val << "->";
for(int j = 1 ; j < size ; j++)
{
results.at(i).at(j-1)->next = results.at(i).at(j);
//stream << results.at(i).at(j)->val << "->";
}
//stream << "NULL";
//strResult.push_back(stream.str());
}
//print(strResult);
}

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

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 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);
}
}

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