程序员面试金典6-10

刷题链接

Leetcode程序员面试金典

06.字符串压缩

思路

直接用两个指针遍历字符串，i指向第一个重复的字符，j指向第一个不相同的字符，j和i的下标差值即为重复字符的个数。

题解

class Solution {
public:
    string compressString(string S) {
        if (S.size() < 3)
            return S;
        string res;
        int i = 0, j = 0; // 双指针
        while (i < S.size())
        {
            if (S[i] != S[j])
            {
                res += S[i];
                res += to_string(j - i);
                i = j;
            }
            else
                j++;
        }
        return S.size() <= res.size() ? S : res;
    }
};

07.旋转矩阵

思路

先将矩阵转置，再交换对应的列。

题解

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        //获取矩阵的阶数
        int n = matrix.size();
        //先将矩阵转置
        //遍历下三角
        for (int i = 0; i < n; ++i){
            for (int j = 0; j <= i; ++j ){
                swap(matrix[i][j], matrix[j][i]);
            }
        }
        //交换对应列，0和n-1列交换，1和n-2列交换,...
        for (int i = 0; i < n / 2; ++i){
            for (int j = 0; j < n; ++j){
                swap(matrix[j][i], matrix[j][n - 1 - i]);
            }
        }
    }
    //交换元素
    void swap(int &a, int &b){
        int tmp = a;
        a = b;
        b = tmp;
    }
};

08.零矩阵

思路

思路一

遍历矩阵，记录0元素的行号和列号；再遍历矩阵，将对应的行列元素置0。

• 时间复杂度：O（M*N）
• 空间复杂度：O（M+N）

思路二

用第一行和第一列分别代替思路一用于记录0元素行列号的一维数组，但是这时候第一行和第一列元素要被修改了，可以先引入两个变量记录第一行和第一列有没有0元素。

题解

思路一

class Solution 
{
public:
    void setZeroes(vector<vector<int>>& matrix) 
    {
        // 获取行数和列数
        int r = matrix.size(), c = matrix[0].size();
        // 遍历，记录0元素的行、列号
        vector<int> index(r + c, 0); // 一维数组记录行列号
        for (int i = 0; i < r; i++)
        {
            for (int j = 0; j < c; j++)
            {
                if (matrix[i][j] == 0)
                {
                    index[i]++;
                    index[j + r]++;
                }
                    
            }
        }
        // 再遍历，根据行列号置0
        for (int i = 0; i < r; i++)
        {
            for (int j = 0; j < c; j++)
            {
                if (index[i] > 0 || index[j + r] > 0)
                    matrix[i][j] = 0;                 
            }
        }
    }
};

思路二

class Solution 
{
public:
    void setZeroes(vector<vector<int>>& matrix) 
    {
        // 获取行数和列数
        int r = matrix.size(), c = matrix[0].size();
        // 记录第一行和第一列是否有0元素
        bool flag_r0 = false, flag_c0 = false; 
        // 遍历矩阵第0行
        for (int j = 0; j < c; j++)
        {
            if (matrix[0][j] == 0)
                flag_r0 = true;
        }
        // 遍历矩阵第0列
        for (int i = 0; i < r; i++)
        {
            if (matrix[i][0] == 0)
                flag_c0 = true;
        }
        // 从矩阵的第1行第1列开始遍历，如果某个位置的元素为0，
        // 将对应的第一行（列）的元素置为0，用于标记该行（列）存在0元素
        for (int i = 1; i < r; i++)
        {
            for (int j = 1; j < c; j++)
            {
                if (matrix[i][j] == 0)
                {
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
                    
            }
        }
        // 再从矩阵的第1行第1列开始遍历，根据第一行和第一列将对应的元素置0
        for (int i = 1; i < r; i++)
        {
            for (int j = 1; j < c; j++)
            {
                if (matrix[0][j] == 0 || matrix[i][0] == 0)
                    matrix[i][j] = 0;                 
            }
        }
        // 最后根据两个标记修改第一行和第一列
        if (flag_r0)
        {
            for (int j = 0; j < c; j++)
                matrix[0][j] = 0;
        }
        if (flag_c0)
        {
            for (int i = 0; i < r; i++)
                matrix[i][0] = 0;
        }
    }
};

09.字符串轮转

思路

如果两个字符串长度不相等，那么返回false；如果长度相等，那么：

• 将字符串s1+s1，如果s2是s1+s1的子串的话，返回true；
• 否则返回false。

题解

class Solution {
public:
    bool isFlipedString(string s1, string s2) {
        if (s1.size() == 0 && s2.size() == 0)
            return true;
        if (s1.size() != s2.size())
            return false;
        string s = s1 + s1;
        if (s.find(s2) != string::npos)
            return true;
        else
            return false;
    }
};

10.移除重复节点

思路

1. 用一个map<int,bool>记录节点是否出现过，出现过则map[val] = true;
2. 然后再次遍历链表，查询map;
3. 如果it->second == true，说明是第一次出现，保留该节点并让it->second = false；
4. 如果it->second == false，则跳过该节点。

题解

class Solution {
public:
    ListNode* removeDuplicateNodes(ListNode* head) {
        if (!head)
            return NULL;

        unordered_map<int, bool> map;
        ListNode *p = head, *prev = NULL;

        while (p != NULL)
        {
            map[p->val] = true;
            p = p->next;
        }

        p = head;
        while (p != NULL)
        {
            auto it = map.find(p->val);
            if ( it->second == true )
            {
                prev = p;
                p = p->next;
                it->second = false;
            }
            else
            {
                prev->next = p->next;
                p = prev->next;
            }
        }
        return head;
    }
};