leecode 解题总结：101. Symmetric Tree

#include <iostream>
#include <stdio.h>
#include <vector>
#include <queue>
using namespace std;
/*
问题:
Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree [1,2,2,3,4,4,3] is symmetric:

    1
   / \
  2   2
 / \ / \
3  4 4  3
But the following [1,2,2,null,3,null,3] is not:
    1
   / \
  2   2
   \   \
   3    3
Note:
Bonus points if you could solve it both recursively and iteratively.

分析:给定一颗二叉树，判定该二叉树是否是对称二叉树。所谓的对称二叉树应该是
当前结点的左子树和右子树是对称的。设当前结点的左孩子为leftNode,右孩子为rightNode
还是没有明白镜像如果用递归定义。

leecode解法:https://leetcode.com/problems/symmetric-tree/?tab=Solutions
仍然是基于结点的左右孩子是否相等的判定
实际就是对(left , right)进行递归判断，如果left或者right中有一个非空，那么比较
left是否等于right,不等返回false。
如果left和right都不空，就需要对两者的值判定，如果值不等，肯定不等
【最关键】:判定(left->left,right->right) 和(left->right , right->left)是否相等
我之所以未能解答出来：尝试对(root)进行递归，而没有对两个结点递归

输入:
7
1 2 2 3 4 4 3
输出:
true

关键:
1 仍然是基于结点的左右孩子是否相等的判定
实际就是对(left , right)进行递归判断，如果left或者right中有一个非空，那么比较
left是否等于right,不等返回false。
如果left和right都不空，就需要对两者的值判定，如果值不等，肯定不等
【最关键】:判定(left->left,right->right) 和(left->right , right->left)是否相等
我之所以未能解答出来：尝试对(root)进行递归，而没有对两个结点递归

2注意树的问题如果不用递归，一般都需要用栈来解决。但是考虑到这是类似层序遍历的问题
因此，用队列来做。
	//分别将自己的左右孩子压入到队列中
	//如果孩子为空就不压入，直接判断
	if(left->left)
	{
		if(NULL == right->right)
		{
			return false;
		}
		nodes1.push(left->left);
		nodes2.push(right->right);
	}
	//漏了一个判断
	else if(right->right)
	{
		return false;
	}
*/

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

class Solution {
public:
	//检查一个结点的左右孩子结点是否对称
	bool check(TreeNode* leftNode , TreeNode* rightNode)
	{
		//牛逼，直接比较，因为如果一个为NULL就能直接比较
		if(NULL == leftNode || NULL == rightNode)
		{
			return leftNode == rightNode;
		}
		if(leftNode->val != rightNode->val)
		{
			return false;
		}
		//递归比较
		return check(leftNode->left , rightNode->right) && check(leftNode->right , rightNode->left);
	}
    bool isSymmetric2(TreeNode* root) {
		if(!root)
		{
			return true;
		}
		bool isOk = check(root->left , root->right);
		return isOk;
    }

    bool isSymmetric(TreeNode* root) {
		if(!root)
		{
			return true;
		}
		queue<TreeNode*> nodes1;
		queue<TreeNode*> nodes2;
		if(root->left)
		{
			if(NULL == root->right)
			{
				return false;
			}
			nodes1.push(root->left);
			nodes2.push(root->right);
		}
		//如果左孩子为空，右孩子不空，返回false
		else if(root->right)
		{
			return false;
		}
		TreeNode* left;
		TreeNode* right;
		//确保队列里面任意两个结点都是非空的，便于进行比较；空的部分，直接提前比较
		while((!nodes1.empty()) && !(nodes2.empty()))
		{
			left = nodes1.front();
			right = nodes2.front();
			nodes1.pop();
			nodes2.pop();
			if(left->val != right->val)
			{
				return false;
			}
			//分别将自己的左右孩子压入到队列中
			//如果孩子为空就不压入，直接判断
			if(left->left)
			{
				if(NULL == right->right)
				{
					return false;
				}
				nodes1.push(left->left);
				nodes2.push(right->right);
			}
			//漏了一个判断
			else if(right->right)
			{
				return false;
			}
			if(left->right)
			{
				if(NULL == right->left)
				{
					return false;
				}
				nodes1.push(left->right);
				nodes2.push(right->left);
			}
			else if(right->left)
			{
				return false;
			}
		}
		//如果其中某个队列还有元素剩余，不行
		if(nodes1.empty() && nodes2.empty())
		{
			return true;
		}
		else
		{
			return false;
		}
    }
};

//采用递归的方式构建二叉树,确定根节点，需要后面明确左孩子和右孩子，当前结点为i,左孩子为2*i,右孩子为2*i+1，默认i从1开始
TreeNode* buildTree(vector<int>& nums , int pos ,int len , vector<TreeNode*>& nodes)
{
	if(nums.empty())
	{
		return NULL;
	}
	//判断是否遍历结束
	if(pos > len)
	{
		if(!nodes.empty())
		{
			return nodes.at(0);
		}
		else
		{
			return NULL;
		}
	}
	//构建根节点
	if(nodes.empty())
	{
		TreeNode* root = new TreeNode(nums.at(0));
		nodes.push_back(root);
	}
	//取出当前结点
	TreeNode* current = NULL;
	if(0 <= pos - 1 && pos - 1 <= nodes.size() - 1)
	{
		current = nodes.at(pos - 1);
	}
	//构建当前结点的左右孩子结点,
	int j = 2 * pos;
	if(j <= len)
	{
		TreeNode* left = new TreeNode(nums.at(j-1));
		nodes.push_back(left);
		if(current)
		{
			current->left = left;
		}
	}
	if(j + 1 <= len)
	{
		TreeNode* right = new TreeNode(nums.at(j));
		nodes.push_back(right);
		if(current)
		{
			current->right = right;
		}
	}
	buildTree(nums , pos + 1 , len , nodes);
	return nodes.at(0);
}

void deleteTree(TreeNode* root)
{
	if(!root)
	{
		return;
	}
	if(NULL == root->left && NULL == root->right)
	{
		delete root;
		root = NULL;
	}
	if(root)
	{
		deleteTree(root->left);
		deleteTree(root->right);
	}
}

void print(vector<int>& 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<TreeNode*> nodes;
	 while(cin >> num )
	 {
		 nums.clear();
		 nodes.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> value;
			 nums.push_back(value);
		 }
		 //初始pos从1开始
		 TreeNode* root = buildTree(nums , 1, nums.size() , nodes);
		 bool isSym = solution.isSymmetric(root);
		 if(isSym)
		 {
			 cout << "true" << endl;
		 }
		 else
		 {
			 cout << "false" << endl;
		 }
		 //删除二叉树
		 deleteTree(root);
	 }
}

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