LeetCode--Symmetric Tree

        对于本题，想到一个中序遍历后，判别是否为回文串的方法，却WA多次

class Solution {
public:
    vector<int> vectorValue;
    void inOrder(TreeNode* root)
    {
        if(root!=NULL)
        {
            inOrder(root->left);
            vectorValue.push_back(root->val);
            inOrder(root->right);
        }
    }

    bool isSymmetric(TreeNode *root) {
        
        if(root==NULL)return true;
        vectorValue.clear();
        inOrder(root);
        int length=vectorValue.size();
        for(int i=0;i<length/2;i++)
        {
            if(vectorValue[i]!=vectorValue[length-1-i])
                return false;
        }
        return true;
    }
};

      后来，查了资料才知道－－ 产生错误的原因：回文串丢失了层次，位置信息。参考别人方法

    一种笨方法解决了这个问题，那便是逐层检查逐层扩展，检查每一层的节点是否互相对称。

[java]  view plain copy print ?

1. import java.util.ArrayList;  
2. import java.util.List;  
3.   
4. public class Solution {  
5.     class ExtTreeNode {  
6.         TreeNode node;  
7.         long pos;  
8.   
9.         ExtTreeNode(TreeNode node, long pos) {  
10.             this.node = node;  
11.             this.pos = pos;  
12.         }  
13.     }  
14.   
15.     public boolean isSymmetric(TreeNode root) {  
16.         if (root == null) {  
17.             return true;  
18.         }  
19.         List<ExtTreeNode> lNodes, rNodes, lTempNodes, rTempNodes;  
20.         lNodes = new ArrayList<ExtTreeNode>();  
21.         rNodes = new ArrayList<ExtTreeNode>();  
22.         if (root.left != null) {  
23.             lNodes.add(new ExtTreeNode(root.left, 1));  
24.         }  
25.         if (root.right != null) {  
26.             rNodes.add(new ExtTreeNode(root.right, 2));  
27.         }  
28.         int count = 2;  
29.         while (lNodes.size() > 0) {  
30.             if (rNodes.size() == 0 || rNodes.size() != lNodes.size()) {  
31.                 return false;  
32.             }  
33.             lTempNodes = new ArrayList<ExtTreeNode>();  
34.             rTempNodes = new ArrayList<ExtTreeNode>();  
35.             for (int i = 0; i < lNodes.size(); i++) {  
36.                 ExtTreeNode lNode = lNodes.get(i);  
37.                 ExtTreeNode rNode = rNodes.get(i);  
38.                 if (lNode.pos + rNode.pos != count + 1 || lNode.node.val != rNode.node.val) {  
39.                     return false;  
40.                 }  
41.   
42.                 if (lNode.node.left != null) {  
43.                     lTempNodes.add(new ExtTreeNode(lNode.node.left, lNode.pos * 2 - 1));  
44.                 }  
45.                 if (lNode.node.right != null) {  
46.                     lTempNodes.add(new ExtTreeNode(lNode.node.right, lNode.pos * 2));  
47.                 }  
48.                 if (rNode.node.right != null) {  
49.                     rTempNodes.add(new ExtTreeNode(rNode.node.right, rNode.pos * 2));  
50.                 }  
51.                 if (rNode.node.left != null) {  
52.                     rTempNodes.add(new ExtTreeNode(rNode.node.left, rNode.pos * 2 - 1));  
53.                 }  
54.             }  
55.             lNodes = lTempNodes;  
56.             rNodes = rTempNodes;  
57.             count *= 2;  
58.         }  
59.         return rNodes.size() == 0;  
60.     }  
61. }  

附自己调试代码 主要参与了http://blog.csdn.net/greenapple_shan/article/details/25976165

/*
* LeetCode--Symmetric Tree
* date 2014/5/16
* state AC
*/
#include <iostream>
#include <queue>
#include <stack>
#include <vector>

using namespace std;

/**
 * Definition for binary tree
 */
 struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
	/*
    vector<int> vectorValue;
    void inOrder(TreeNode* root)
    {
        if(root!=NULL)
        {
            inOrder(root->left);
            vectorValue.push_back(root->val);
            inOrder(root->right);
        }
    }

    bool isSymmetric(TreeNode *root) {
        
        if(root==NULL)return true;
        vectorValue.clear();
        inOrder(root);
        int length=vectorValue.size();
        for(int i=0;i<length/2;i++)
        {
            if(vectorValue[i]!=vectorValue[length-1-i])
                return false;
        }
        return true;
    }
	
	bool isSymRec(TreeNode* left,TreeNode* right)
	{
		//递归结束条件
		if(left==NULL && right==NULL)
			return true;
		else if(left==NULL || right==NULL)
			return false;
		//递归体
		return(left->val == right->val //结点数值比较
			&& isSymRec(left->left,right->right) //左子树左对右子树右
			&& isSymRec(left->right,right->left));//左子树右对右子树左
	}
	bool isSymmetric(TreeNode* root)
	{
		if(root==NULL)return true;
		else isSymRec(root->left,root->right);
	}
	*/
	bool isSymmetric(TreeNode *root) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function  
        if(root==nullptr) return true;  
        queue<TreeNode*> q1;  
        queue<TreeNode*> q2;  
          
        q1.push(root->left);  
        q2.push(root->right);  
          
        while( !q1.empty() || !q2.empty()) {  
            TreeNode* t1 = q1.front();  
            TreeNode* t2 = q2.front();  
            q1.pop();  
            q2.pop();  
              
            if(t1==nullptr && t2==nullptr) continue;  
            if(t1==nullptr || t2==nullptr) return false;  
              
            if(t1->val!=t2->val) return false;  
             
            q1.push(t1->left);  
            q1.push(t1->right);  
            q2.push(t2->right);  
            q2.push(t2->left);  
        }  
          
        return true;  
          
    }    
};

TreeNode* create()
{
    char ch;
    cin>>ch;
    TreeNode* root;
    if(ch=='#')
        return NULL;
    else
    {
        root=new TreeNode(ch);
        root->left=create();
        root->right=create();
        return root;
    }
}

bool isSame(vector<int>& vectorValue)
{
	int length=vectorValue.size();
    for(int i=0;i<length;i++)
    {
        if(vectorValue[i]!=vectorValue[length-1-i])
           return false;
    }
}

int main()
{
    //cout << "Hello world!" << endl;
	
    TreeNode* t;
    t=create();
    Solution Solu;
	Solu.inOrder(t);
	int len=Solu.vectorValue.size();
	for(int i=0;i<len;i++)
		//cout<<Solu.vectorValue[i]<<" ";
			printf("%c ",Solu.vectorValue[i]);
	cout<<endl;
    if(Solu.isSymmetric(t))
        cout<<"true"<<endl;
    else cout<<"false"<<endl;
	
	/*
	vector<int> vec;
	int n;
	cin>>n;
	int t;
	for(int i=0;i<n;i++)
	{
		cin>>t;
		vec.push_back(t);
	}
	if(isSame(vec))cout<<"true"<<endl;
	else cout<<"false"<<endl;
	*/
    return 0;
}