剑指offer:DAY 2树的递归

题目描述

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

解题思路：有三种情况：A和B是同一棵树，B在A的左子树中，B在A的右子树中。

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* r1, TreeNode* r2)
    {
        if(r1==NULL||r2==NULL)
            return false;
        
        return judge(r1,r2)||judge(r1->left,r2)||judge(r1->right,r2);
        
    }
    
    
    bool  judge(TreeNode* r1,TreeNode* r2)
    {
        if(r2==NULL)
            return true;
        if(r1==NULL)
            return false;
        if(r1->val!=r2->val)
            return false;
        
        return judge(r1->left,r2->left)&&judge(r1->right,r2->right);

    }
    
};

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

class Solution {
public:
    
    
    void Mirror(TreeNode *pRoot) {
        if(pRoot==NULL)
            return ;
        
        TreeNode *tmp;
        tmp=pRoot->left;
        pRoot->left=pRoot->right;
        pRoot->right=tmp;
        
        Mirror(pRoot->left);
        Mirror(pRoot->right);
                
    }
};

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

解题思路：我把这个打印矩阵想象成贪吃蛇，按右、下、左、上的方式走（走完一个方向再走下一个方向）

关键在这项代码的理解while(x>=0&&x<n&&y>=0&&y<m&&!arr[x][y])

//只会在最后一步走到已经走过的数据，其他时候不会碰到已走过的数据。（因为在其他时候碰到已走过的数据的时候，立即换下一个方向）

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> a; 
        int n=matrix.size();
        int m=matrix[0].size();
        
        int dx[4]={0,1,0,-1};
        int dy[4]={1,0,-1,0};
        int x=0,y=0,dir=0;
        //int arr[10][10]={-1};
        bool **arr=new bool*[n];      //动态申请二维数组 n行 m列    
        for(int i=0;i<n;i++)  
            arr[i]=new bool[m];  

        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                arr[i][j]=false;
        while(x>=0&&x<n&&y>=0&&y<m&&!arr[x][y])//只会在最后一步出现数组的数据重叠
        {
            a.push_back(matrix[x][y]);
            arr[x][y] = true;

            // 试着继续向dir的方向走
            while(x + dx[dir] >= 0 && x + dx[dir] < n && y + dy[dir] >= 0 && y + dy[dir] < m && !arr[x + dx[dir]][y + dy[dir]])
            {
                x += dx[dir];
                y += dy[dir];
                a.push_back(matrix[x][y]);
                arr[x][y] = true;
            }
            // 走不动了换方向
            dir = (dir + 1) % 4;
            x += dx[dir];
            y += dy[dir];
        }
        return a;
    
    }
};

题目描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

解题思路：正向顺序的东西，考虑队列的先进先出

class Solution {
public:
    //打印的数据按正向顺序，故应该用先进先出思想    
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> a;
        queue<TreeNode*> q;
        if(root==NULL)
            return a;
        q.push(root);
        TreeNode* tmp;
        
        while(!q.empty())
        {
            tmp=q.front();
            a.push_back(tmp->val);
            if(tmp->left!=NULL)
                q.push(tmp->left);
            if(tmp->right!=NULL)
                q.push(tmp->right);
            q.pop();
            
        }
        return a;

    }
};