算法刷题日记（一）

剑指offer

JZ28 对称的二叉树

描述：给定一棵二叉树，判断其是否是自身的镜像

上面这棵树是对称的

这棵树不对称。

要求：时间复杂度O(n)，空间复杂度O(n)

解题思路：从根节点开始，递归比较左子节点和右子节点

    bool isSame(TreeNode *root1, TreeNode *root2) {//设置递归函数，参数为两个子树的根节点
        if (!root1 && !root2) return true;         //递归结束条件：两个节点同时为空，说明对称
        if (!root1 || !root2) return false;        //若只有一个为空，说明不对称
        return root1->val == root2->val &&         //递归比较左子节点和右子节点
        isSame(root1->left, root2->right) &&
        isSame(root1->right, root2->left);
    }
    bool isSymmetrical(TreeNode* pRoot) {
        return isSame(pRoot, pRoot);
    }

JZ32 从上往下打印二叉树

描述：从上往下打印出二叉树的每个节点，同层节点从左至右打印，打印结果放在数组中返回。

分析：二叉树的层次优先遍历

    vector<int> PrintFromTopToBottom(TreeNode* root) {
        queue<TreeNode*> q;    //借助队列
        vector<int> v;         //定义数组接收遍历结果
        if(!root) return v;    //边界条件判断
        q.push(root);          //根节点入队
        while(!q.empty())      //层序遍历
        {
            root=q.front();
            q.pop();
            v.push_back(root->val);
            if(root->left) q.push(root->left);
            if(root->right) q.push(root->right);
        }
        return v;
    }

剑指 Offer 32 - II. 从上到下打印二叉树 II

题目描述：从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

思路：根普通层序遍历不同的是，在while循环中增加了一个for循环，一次性遍历整层节点。

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int>> ret;
        if (!root) return ret;
        queue <TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int height = q.size();
            ret.push_back(vector <int> ());
            for (int i = 1; i <= height; ++i) {
                auto node = q.front(); q.pop();
                ret.back().push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        return ret;
    }

剑指 Offer 32 - III. 从上到下打印二叉树 III

题目描述：请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

思路：根上题不同的是，此题需要之字形打印，一个比较快速的方法是将vector中偶数层的数值反转。

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int>> v;
        if (!root) return v;
        queue <TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int height = q.size();
            v.push_back(vector <int> ());
            for (int i = 1; i <= height; ++i) {
                auto node = q.front(); q.pop();
                v.back().push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        for(int i=0;i<v.size();i++)
        {
            if(i%2!=0) reverse(v[i].begin(),v[i].end());
        }
        return v;
    }