尊享面试100题

题目624：数组列表的最大距离（NO）

解题思路：记录每个数组的最大最小值，循环判断最大距离。

给定 m 个数组，每个数组都已经按照升序排好序了。

现在你需要从两个不同的数组中选择两个整数（每个数组选一个）并且计算它们的距离。两个整数 a 和 b 之间的距离定义为它们差的绝对值 |a-b| 。

返回最大距离。

cpp 复制代码

class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        //这题的做题思路其实就是遍历每个数组，记录数组的最大最小值

        //先记录第一组的最大最小值
        //.back()是获取最后一个值
        int max_value=arrays[0].back();
        int min_value=arrays[0][0];

        int max_Distance=0;

        //从第二个数组开始遍历
        //这里可以是可以进入for循环的，因为题目限制了
        //这里有个限制，最大最小值不能再同一个数组中
        for(int i=1;i<arrays.size();i++)
        {
            //当前数组的最大最小值
            int current_min=arrays[i][0];
            int current_max=arrays[i].back();

            max_Distance=max(max_Distance,abs(current_max-min_value));
            max_Distance=max(max_Distance,abs(current_min-max_value));

            //更新最大最小值
            max_value=max(current_max,max_value);
            min_value=min(current_min,min_value);

        }

        return max_Distance;


    }
};

题目280：摆动排序（YES）

解题思路：这里有规律，排序后再指定位置插入。

给你一个的整数数组 nums, 将该数组重新排序后使 nums[0] <= nums[1] >= nums[2] <= nums[3]...

输入数组总是有一个有效的答案。

cpp 复制代码

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        //我发现了其中的规律，他是排序后按位置插入的
        sort(nums.begin(),nums.end());
        vector<int>ans=nums;

        int size=ans.size();

        int count=0;
        for(int i=0;i<size;i++)
        {
            if(i%2==0)
            {
                //偶数的不用变
                nums[i]=ans[count];
            }else
            {
                //奇数要变
                nums[i]=ans[size-(count+1)];
                count++;
            }
            
        }


    }
};

题目1056：易混淆数（NO）

解题思路：按照题目的思路，讲所有的数反转再进行比较。

给定一个数字 N，当它满足以下条件的时候返回 true：

原数字旋转 180° 以后可以得到新的数字。

如 0, 1, 6, 8, 9 旋转 180° 以后，得到了新的数字 0, 1, 9, 8, 6 。

2, 3, 4, 5, 7 旋转 180° 后，得到的不是数字。

易混淆数 (confusing number) 在旋转180°以后，可以得到和原来不同的数，且新数字的每一位都是有效的。

cpp 复制代码

class Solution {
public:
    bool confusingNumber(int n) {
        //这题的解题思路是按照题目的意思走，比较旋转反转后是否相同

        //用哈希表来表示旋转后的数
        unordered_map<char,char>map=
        {
            {'0','0'},
            {'1','1'},
            {'9','6'},
            {'8','8'},
            {'6','9'}
        };
        string ret=to_string(n);
        string ans="";//最终结果

        for(char c:ret)
        {
            if(map.find(c)==map.end())
            {
                //存在不能反转的返回false
                return false;
            }
            ans=map[c]+ans;//反转的数放在最前面
        }

        return ans!=ret;

        

    }

};

题目1427：字符串的左右移（YES）

解题思路：根据题目的思路，模拟出来就行。

给定一个包含小写英文字母的字符串 s 以及一个矩阵 shift，其中 shift[i] = [direction, amount]：

direction 可以为 0 （表示左移）或 1 （表示右移）。

amount 表示 s 左右移的位数。

左移 1 位表示移除 s 的第一个字符，并将该字符插入到 s 的结尾。

类似地，右移 1 位表示移除 s 的最后一个字符，并将该字符插入到 s 的开头。

对这个字符串进行所有操作后，返回最终结果。

cpp 复制代码

class Solution {
public:
    string stringShift(string s, vector<vector<int>>& shift) {
        //这种最常规的方法就是根据题目的思路进行移动
        for(int i=0;i<shift.size();i++)
        {
            for(int j=0;j<shift[i][1];j++)
            {
                //移动的位数
                if(shift[i][0]==0)
                {
                    //左移
                    char c=s[0];
                    //从0位置开始删除1个
                    s.erase(0,1);
                    s=s+c;
                }else
                {
                    //右移
                    char c=s[s.size()-1];
                    s.erase(s.size()-1,1);
                    s=c+s;
                }
            }
        }

        return s;
    }
};

题目161：相隔为1的编辑距离（NO）

解题思路：这题也是要迎合这题目的思路，首先就是要将情况分清楚，大于1的必然不行，后面就是对长度差等于0和等于1的情况进行单独的处理就行。方法其实是相似的。

给定两个字符串 s 和 t ，如果它们的编辑距离为 1 ，则返回 true ，否则返回 false 。

字符串 s 和字符串 t 之间满足编辑距离等于 1 有三种可能的情形：

往 s 中插入恰好一个字符得到 t

从 s 中删除恰好一个字符得到 t

在 s 中用一个不同的字符替换恰好一个字符得到 t

cpp 复制代码

class Solution {
public:
    bool isOneEditDistance(string s, string t) {

        //这题的难点在于你要将情况分析清楚
        //1.长度差大于1的必然是不行的
        //2.长度差等于1或者为0这是两种可能可以编辑的情况

        //这里全局默认s<t
        int len_s=s.size();
        int len_t=t.size();

        if(abs(len_s-len_t)>1)
        {
            return false;
        }

        //这里筛选下来的都是有可能的，先切换
        if(len_s>len_t)
        {
            swap(s,t);
            swap(len_s,len_t);
        }

        if(len_s==len_t)
        {
            //相等的情况
            bool check=false;
            for(int i=0;i<len_s;i++)
            {
                if(s[i]!=t[i])
                {
                    if(check)
                    {
                        //再次出现不相等就是错误的
                        return false;
                    }
                    //出现一个不相等
                    check=true;
                }
            }

            return check;
        }else
        {
            //差值为1的情况

            //其实和上面的非常相似，就是要找到一个不相等的
            int i=0;
            int j=0;
            for(;i<len_s&&j<len_t;)
            {
                if(s[i]==t[j])
                {
                    //都相等的情况
                    i++;
                    j++;
                }else
                {
                    //头一次找到不相等的
                    if(i==j)
                    {
                        //第一次不相等是允许的
                        j++;
                    }else
                    {
                        return false;
                    }
                }
            }

            return true;
        }

    }
};

题目186：反转字符串中的单词（NO）

解题思路：先反转整体，再反转单个单词。

给你一个字符数组 s ，反转其中单词的顺序。

单词的定义为：单词是一个由非空格字符组成的序列。s 中的单词将会由单个空格分隔。

必须设计并实现原地解法来解决此问题，即不分配额外的空间。

cpp 复制代码

class Solution {
public:
     void reverseWords(vector<char>& s) {  
        // 1. 反转整个字符数组  
        reverseRange(s, 0, s.size() - 1);  
        
        // 2. 逐个反转每个单词  
        int start = 0;  
        while (start < s.size()) {  
            int end = start;  
            // 找到单词的结束位置  
            while (end < s.size() && s[end] != ' ') {  
                end++;  
            }  
            // 反转当前单词  
            reverseRange(s, start, end - 1);  
            // 移动到下一个单词  
            start = end + 1;  
        }  
    }  
    
private:  
    void reverseRange(vector<char>& s, int start, int end) {  
        while (start < end) {  
            swap(s[start], s[end]);  
            start++;  
            end--;  
        }  
    } 
};