【刷题】day01--对称的二叉树、把二叉树打印成多行、二维数组的查找、替换空格

最新推荐文章于 2024-11-13 16:53:13 发布

原创最新推荐文章于 2024-11-13 16:53:13 发布 · 264 阅读

1 ·

CC 4.0 BY-SA版权

刷题专栏收录该内容

3 篇文章

订阅专栏

本文探讨了二叉树的对称性判断与多行打印算法，以及二维数组查找和字符串空格替换等常见算法问题。通过递归与非递归方法实现，帮助读者深入理解这些核心算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

[编程题]对称的二叉树
热度指数：90872时间限制：1秒空间限制：32768K
算法知识视频讲解
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
递归思想：
利用二叉树的先序遍历，先序遍历如果先遍历左子树和先遍历右子树，遍历的结果相同说明二叉树是对称的。
代码如下：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool _isSymmetrical(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if (pRoot1 == NULL&&pRoot2 == NULL)
            return true;
        if (pRoot1 == NULL || pRoot2 == NULL)
            return false;
        if (pRoot1->val != pRoot2->val)
            return false;
        return pRoot1->val == pRoot2->val&&_isSymmetrical(pRoot1->left, \
            pRoot2->right) && _isSymmetrical(pRoot1->right , pRoot2->left);
    }
    bool isSymmetrical(TreeNode* pRoot)
    {

        return _isSymmetrical(pRoot, pRoot);
    }

};

非递归思想：
不论使用哪一种遍历方式，采用先左后右，或者先右后左的方式，最后遍历出来的结果都是一样的则说明二叉树是对称的。
代码如下：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if (pRoot == NULL)
            return true;
        queue<TreeNode*> q1;
        queue<TreeNode*> q2;
        q1.push(pRoot->left);
        q2.push(pRoot->right);
        while (!q1.empty()&&!q2.empty())
        {
            TreeNode* left = q1.front();
            q1.pop();
            TreeNode* right = q2.front();
            q2.pop();
            if (NULL == left&&NULL == right)
                continue;
            if (NULL == left||NULL == right)
                return false;
            if (left->val != right->val)
                return false;
            q1.push(left->left);
            q1.push(left->right);
            q2.push(right->right);
            q2.push(right->left);
        }
        return true;
    }

};

[编程题]把二叉树打印成多行
热度指数：85099时间限制：1秒空间限制：32768K
算法知识视频讲解
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
算法思路：
二叉树的层次遍历然后将每一层的数据存入一个二维数组的每一行中。
代码如下：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int>> Print(TreeNode* pRoot) {
        vector<vector<int>> v;
        if (pRoot == NULL)
            return v;
        queue<TreeNode*> q;
        q.push(pRoot);
        while (!q.empty())
        {
            int size0 = 0;
            int size = q.size();
            vector<int> tmp;
            while (size0++<size)
            {
                TreeNode* t = q.front();
                q.pop();
                tmp.push_back(t->val);
                if (t->left)
                    q.push(t->left);
                if (t->right)
                    q.push(t->right);
            }
            v.push_back(tmp);
        }
        return v;
    }

};

[编程题]二维数组中的查找
热度指数：807866时间限制：1秒空间限制：32768K
算法知识视频讲解
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解题思路：
为了方便思考，我画了一张图：
这里写图片描述
从图中可以看出数据递增的趋势，从左到右递增，从上到下递增，我们选取右上角的位置做为搜索开始位置，这个位置的特点就是是第一行最大的一个数，也是最后一列最小的一个，如果要找比它小得就让列数减一，在前面的列找，如果要找的数比这个数大就将行数加1，在它下面找然后利用一个循环逐渐缩小范围，直到找到返回，或者下标越界，退出循环表示没找到。
代码如下：

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if (array.empty())
            return false;
        int col = array[0].size();
        int row = array.size();
        int i = 0;
        int j = col-1;
        while (j>=0&&i<row)
        {
            if (target == array[i][j])
                return true;
            if (target>array[i][j])
                i++;
            else
                j--;
        }
        return false;
    }

};

[编程题]替换空格
热度指数：686820时间限制：1秒空间限制：32768K
算法知识视频讲解
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
解题思路：
这个题将一个字符的空格扩展为三个字符，如果从前向后替换就会有字符被覆盖而不能达到这个题目的目的，所以我们先将空格的数量记录下来，就可以直到新字符串的末尾位置，然后从后往前替换就不会覆盖任何字符，每一个字符都能在新字符串中出现，每一次判断出是空格的时候先对count–就可以将要替换的字符放进去了。
代码如下：



class Solution {
public:
    void replaceSpace(char *str,int length) {
        if(str == NULL||length<0)
           return;
        int count = 0;
        for(int i = 0;i < length; i++)
        {
            if(isspace(str[i]))
                count++;

        }
        for(int i = length-1; i>=0; i--)
        {
            if(!isspace(str[i]))
            {
                str[i+count*2] = str[i];
            }
            else
            {
                count--;
                str[i+count*2] = '%';
                str[i+count*2+1] = '2';
                str[i+count*2+2] = '0';
            }

        }
    }
};