LeetCode----树

1.题目：Invert Binary Tree

    4
   /   \
  2     7
 / \   / \
1   3 6   9

to

     4
   /   \
  7     2
 / \   / \
9   6 3   1

思路：

递归的交换左右子树

代码：

 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(NULL==root)
        {
            return NULL;
        }
        TreeNode *temp=root->left;
        root->left=invertTree(root->right);
        root->right=invertTree(temp);
        return root;
    }
};

可以改进的地方：使用递归的代价是十分巨大的：它会消耗大量的内存！！递归循环时它用的是堆栈，而堆栈的资源是十分有限的。

递归的本质和栈数据的存取很相似了，都是先进去，但是往往最后处理！再者对于递归函数的局部变量的存储是按照栈的方式去存的，对于每一层的递归函数在栈中都保存了本层函数的局部变量，一边该层递归函数结束时能够保存原来该层的数据！如图:http://www.2cto.com/kf/201303/195338.html

     

        如上图递归式依次往下进行的，并且在该层递归函数还没结束即将进入下一层递归调用时，将会把该层函数中的局部变量保存起来，以供下次使用!

改进的方法：

思路：

1）堆栈

class Solution {  
public:  
    TreeNode* invertTree(TreeNode* root)   
    {  
        if(root == NULL)  
            return NULL;  
        stack<TreeNode *> s;  
        s.push(root);  
        while(!s.empty())  
        {  
            TreeNode *node = s.top();  
            s.pop();  
            swap(node->left , node->right);  
            if(node->left)  
                s.push(node->left);  
            if(node->right)  
                s.push(node->right);  
        }  
        return root;  
    }  
}; 

2)队列

 

class Solution {  
public:  
    TreeNode* invertTree(TreeNode* root)   
    {  
        if(root == NULL)  
            return NULL;  
        queue<TreeNode *> s;  
        s.push(root);  
        while(!s.empty())  
        {  
            TreeNode *node = s.front();  
            s.pop();  
            swap(node->left , node->right);  
            if(node->left)  
                s.push(node->left);  
            if(node->right)  
                s.push(node->right);  
        }  
        return root;  
    }  
};  <strong>
</strong>