刷题笔记15 二叉树 PartII

102.层序遍历 226.翻转二叉树 101.对称二叉树

层序遍历

102层序遍历

法1：

		 vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> store_que;
        if (root != NULL) store_que.push(root);
        while(!store_que.empty()){
            int size = store_que.size();
            vector<int> pre_ans;
            for (int i = 0; i < size; ++i) {
                TreeNode* node = store_que.front();
                store_que.pop();
                pre_ans.push_back(node->val);
                if (node->left) store_que.push(node->left);
                if (node->right) store_que.push(node->right);
            }
           ans.push_back(pre_ans);
        }
        return ans;
    }

226.翻转二叉树

226.翻转二叉树
法1：

    TreeNode* invertTree(TreeNode* root) {
        //递归
        if (root == NULL) return root;
//        TreeNode* node = root;
        swap(root->left, root->right); //关键点
        if (root->left) invertTree(root->left);
        if (root->right) invertTree(root->right);
        return root;
        //迭代
       /* stack<TreeNode*> store_st;
        //前序遍历和后序遍历均可以
        if (root != NULL) store_st.push(root);
        while(!store_st.empty()){
            TreeNode* node = store_st.top(); //中
            store_st.pop();
            swap(node->left, node->right); //关键点
            if (node->left) store_st.push(node->left);//左
            if (node->right) store_st.push(node->right);//右
        }
        return root;*/
    }

101.对称二叉树

101.对称二叉树

法1： 常规思路 数值裂解 求平方和 放入set 平方和在set中已经存在->no_happy 反之 happy

   bool compare(TreeNode* left,TreeNode* right){
        if (left == NULL && right == NULL) return true;
        if (left == NULL || right == NULL) return false;
        //结构对称但值不一定相等
        else if (left->val != right->val)return false;
//        else if (left == NULL && right != NULL) return false;
//        else if (left != NULL && right == NULL) return false;
        bool outside = compare(left->left,right->right);
        bool inside = compare(left->right,right->left);
        return outside && inside;
    }
    bool isSymmetric(TreeNode* root) {
        //迭代
        if (root->left == NULL && root->right == NULL) return true;
        if (root->left == NULL || root->right == NULL) return false;
        queue<TreeNode*> store_que;
        store_que.push(root->left);
        store_que.push(root->right);
        /**改写 java*/
        while (!store_que.empty()){
            TreeNode* l = store_que.front();
            store_que.pop();
            TreeNode* r = store_que.front();
            store_que.pop();
            if(l == NULL && r== NULL){
                continue;
                //return true;
            }
            if((l == NULL || r == NULL)||(l->val !=r->val)){
                return false;
            }

            store_que.push(l->left);
            store_que.push(r->right);
            store_que.push(l->right);
            store_que.push(r->left);
        }
        return true;
        /*
        //递归
        if (root == NULL) return true;
        bool ans = compare(root->left,root->right);
        return ans;*/
    }