【每日刷题】Day97

【每日刷题】Day97

🥕个人主页：开敲🍉

🔥所属专栏：每日刷题🍍

🌼文章目录🌼

1. 1122. 数组的相对排序 - 力扣（LeetCode）

2. 1859. 将句子排序 - 力扣（LeetCode）

3. 1609. 奇偶树 - 力扣（LeetCode）

1. 1122. 数组的相对排序 - 力扣（LeetCode）

//遍历+记数。

class Solution {

public:

    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2)

    {

        vector<int> ans;

        int hash[1001] = {0};

//记数

        for(int i = 0;i<arr1.size();i++)

        {

            hash[arr1[i]]+=1;

        }

//根据arr2数组中元素的相对顺序拿取元素

        for(int i = 0;i<arr2.size();i++)

        {

            while(hash[arr2[i]])

            {

                ans.push_back(arr2[i]);

                hash[arr2[i]]--;

            }

        }

//未在arr2中出现的元素按照升序排序

        for(int i = 0;i<1001;i++)

        {

            while(hash[i])

            {

                ans.push_back(i);

                hash[i]--;

            }

        }

        return ans;

    }

};

2. 1859. 将句子排序 - 力扣（LeetCode）

//思路：双指针暴力遍历。O(N^2)

//第一次遍历找数字1，将数字1位置的单词(包括空格)尾插入结果字符串；第二次遍历找数字2，将数字2位置的单词(包括空格)尾插入结果字符串。以此类推。

//需要注意的是，不论如何，结果一定在最后会多出一个空格，我们直接尾删结果字符串即可。

class Solution {

public:

    string sortSentence(string s)

    {

        int size = s.size();

//size作为第一层循环结束条件

        for(int i = 0;i<s.size();i++)

        {

            if(s[i]-'0'>=1&&s[i]-'0'<=9)

                size--;

        }

        string ans;

//从1开始寻找数字

        int flag = 1;

//如果结果字符串的长度＜size则继续

        while(ans.size()<size)

        {

//pcur用于指向单词的开头

            int pcur = 0;

//pmove用于寻找数字

            int pmove = 0;

            for(int i = 0;i<s.size();i++)

            {

//如果pmove找到了和flag匹配的字符，则开始将单词尾插

                if(s[pmove]-'0'==flag)

                {

                    pmove++;

//如果pmove到了末尾，需要我们手动在单词后面添加空格

                    if(pmove==s.size())

                    {

                        while(pcur<pmove)

                        {

                            if(s[pcur]-'0'>9||s[pcur]-'0'<0)

                                ans.push_back(s[pcur]);

                            pcur++;

                        }

//手动添加空格

                        ans.push_back(' ');

                        flag++;

                        break;

                    }

                    else

                    {

                        while(pcur<=pmove)

                        {

                            if(s[pcur]-'0'>9||s[pcur]-'0'<0)

                                ans.push_back(s[pcur]);

                            pcur++;

                        }

                        flag++;

                        break;

                    }

                }

//如果pmove遍历到了' '，更新pcur，使其指向新的单词

                if(s[pmove]== ' ')

                    pcur = pmove+1;

                pmove++;

            }

        }

//将多出的空格删去

        ans.pop_back();

        return ans;

    }

};

3. 1609. 奇偶树 - 力扣（LeetCode）

//思路：深度优先+数组。

//本题的难点在于需要如何判断偶数层每个节点的val都为奇数，且值要递增；奇数层每个节点的val都为偶数，且值要递减。

//我们结合着数组仔细思考：第0层的节点我们将它们放于0号下标，第1层的节点我们将它们放于1号下标，以此类推...

//但是又有一个问题，数组一个下标只能存储一个元素，我们如何同时将同一层的所有节点val都存储在一个下标呢？如果这样想那么这道题是解不出的，我们不需要将每一层的节点都存储起来，我们只需要先存储每一层的第一个节点的val。

//存储好后当我们深度优先遍历到同一层的第二个节点时，我们与第一个节点进行比较，(这里需要根据层号奇偶性的不同采用不同的比较)，判断其是否为递增或者递减。

//当然，在我们存储或更新每一个下标的val时，都需要根据层号的奇偶性判断val的奇偶性。

//不懂的话没关系，我们还是老样子，画图理解：

class Solution {

public:

    bool _isEvenOddTree(TreeNode* root,int* arr,int level)

    {

//当遍历到空节点时返回真

        if(!root)

            return true;

//如果当前val是当前层的第一个节点的val，我们直接存储

        if(arr[level]==0)

            arr[level] = root->val;

//如果不是，我们将当前val与数组中存储好的同一层上一个节点的val根据层号的奇偶性判断他们两个的大小关系。

        else if((level%2&&root->val>=arr[level])||(level%2==0&&root->val<=arr[level]))

            return false;

//如果两个val复合题意，我们将数组中的val更新

        else

            arr[level] = root->val;

//每次存储时需要判断奇偶性

        if((level%2&&arr[level]%2)||(level%2==0&&arr[level]%2==0))

            return false;

        return _isEvenOddTree(root->left,arr,level+1)&&_isEvenOddTree(root->right,arr,level+1);

    }

    bool isEvenOddTree(TreeNode* root)

    {

        if(root->val%2==0)

            return false;

        int arr[100001] = {0};

        return _isEvenOddTree(root,arr,0);

    }

};