【leetcode刷题之路】剑指Offer——字符串+链表+双指针

1 字符串

1.1【字符串】【双指针】剑指 Offer 05 - 替换空格

https://leetcode.cn/problems/ti-huan-kong-ge-lcof/

  首先计算出字符串中的空格数量，然后对原字符串进行扩充，之后使用双指针i和j，i指向原字符串的尾部，j指向新字符串的尾部，然后双指针一起从尾部向前移动，如果此时i为空，则发生替换，否则直接挪到j的位置即可。

class Solution {
public:
    string replaceSpace(string s) {
        int length = s.size();
        int count = 0;
        for(int i=0;i<length;i++)
        {
            if(s[i]==' ') count++;
        }
        s.resize(length + 2 * count);
        for(int i=length-1,j=s.size()-1;i>0,j>i;i--,j--)
        {
            if(s[i]==' ')
            {
                s[j] = '0';
                s[j-1] = '2';
                s[j-2] = '%';
                j-=2;
            }
            else s[j] = s[i];
        }
        return s;
    }
};

1.2【字符串】剑指 Offer 58 - II. 左旋转字符串

https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/

（1）使用了额外的字符串来进行移动，左移n位可以看成右移length-n位，最后对length取余就是移动后的位置。
（2）直接在原字符串上修改，这里举一个例子来帮助大家理解：
  我们假设s=‘abcde’,n=2,那么最后的结果应该是cdeab，我们把这个结果进行翻转可以得到baedc，而这个字符串与原来的abcde的区别就是ab进行对称翻转+cde进行对称翻转，把他们分开的点就是第n个字符的位置，所以我们可以基于这个发现，先对前n个字符进行翻转，再对剩下的字符进行翻转，最后对整个字符串进行翻转。

//方法1---借助额外字符串
class Solution {
public:
    string reverseLeftWords(string s, int n) {
        string ans = s;
        int length = s.size();
        for(int i=0;i<length;i++)
        {
            ans[(i+length-n)%length] = s[i];
        }
        return ans;
    }
};

//方法2---在原字符串上修改
class Solution {
public:
    string reverseLeftWords(string s, int n) {
        //对前n个字符进行翻转
        reverse(s.begin(),s.begin()+n);
        //对剩下的字符进行翻转
        reverse(s.begin()+n,s.end());
        //对整个字符串进行翻转
        reverse(s.begin(),s.end());
        return s;
    }
};

1.3 【双指针】【字符串】剑指 Offer 20 - 表示数值的字符串

https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/

首先通过双指针找到字符串中不为空的部分，对这部分内容进行数值判断

其实这道题的难点在于特殊符号±eE.的判断，如果是纯数字的组成一定是数值，下面对这些特殊符合分别进行分析

（1）小数点.

• 如果这个数值含有小数点的话，那么有且只能有一个小数点，且小数点的前后必须都是数字；
• 如果这个数值是科学计数法，那么小数点只能出现在e/E的前面，比如5.3e2；

（2）科学计数法e/E

  如果这个数值采用科学计数法的话，那么e/E有且只能出现一次，并且e/E的前后必须都是数字；

（3）符号±

• 如果这个数值有符号的话，那么符号必须得在数值的第一位；
• 如果这个数值是科学计数法，那么符号的前一位可以是e/E，但是后一位绝对不能是e/E，比如-1E-16；

class Solution {
public:
    bool isNumber(string s) {
        int i = 0 , j = s.size()-1;
        //找到字符串中第一个不为空的位置
        for(;i<s.size();i++)
        {
            if(s[i]!=' ') break;
        }
        //从末尾找到字符串最后一个不为空的位置
        for(;j>0;j--)
        {
            if(s[j]!=' ') break;
        }
        //判断是否为数值，以及是否有小数点和e/E
        bool num_flag = false;
        bool dot_flag = false;
        bool e_flag = false;
        for(int k=i;k<j+1;k++)
        {
            //判断是否为数字
            if(isdigit(s[k]))
            {
                num_flag = true;
            }
            //判断是否为小数点，并且之前是否出现过小数点和e/E
            else if(s[k]=='.' && !dot_flag && !e_flag)
            {
                dot_flag = true;
            }
            //判断是否为e/E，并且之前是否出现过e/E和数字
            else if((s[k]=='e' || s[k]=='E') && !e_flag && num_flag)
            {
                e_flag = true;
                //因为e/E的前后必须都是数字，所以如果找到了e/E就把num_flag设为false，
                //遇到下一个数字再设为true，避免出现12e的情况
                num_flag = false;
            }
            //判断是否为+-，并且符号是否在数值的首位，或者前一位是e/E
            else if((s[k]=='+' || s[k]=='-') && (k==i || s[k-1]=='e' || s[k-1]=='E'))
            {
                continue;
            }
            //其他均为非法情况，输出false
            else return false;
        }
        return num_flag;
    }
};

1.4 【双指针】【字符串】剑指 Offer 67 - 把字符串转换成整数

https://leetcode.cn/problems/ba-zi-fu-chuan-zhuan-huan-cheng-zheng-shu-lcof/

这道题的思路其实不难想出来，就是找到数值的部分然后转化为整数，主要是需要考虑很多边界条件，这里列举我碰到的一些问题。
（1）只有一个字符，且该字符为空格或+或-，这种需要返回0；
（2）对于含有小数点的数值，比如3.1415，应该输出3，因为小数点在本题中属于多余字符；
（3）数值中间可能存在多余字符，比如123a456，应该输出123，注意识别其中的多余字符；
（4）开头有且只能有一个+或-，对于±1，应该输出0；
（5）注意int的边界条件，可能在字符串按序遍历*10的时候就已经超出int大小了，这里可以提前break循环。

class Solution {
public:
    int strToInt(string str) {
        //解题思路中第一种情况
        if(str.size()==1 && (str[0]==' ' || str[0]=='+' || str[0]=='-')) return 0;
        int i = 0 , j = str.size()-1;
        //找出数值部分的第一个元素
        for(;i<str.size();i++)
        {
            if(isdigit(str[i]) || str[i]=='+' || str[i]=='-') break;
            else if(str[i]==' ') continue;
            else return 0;
        }
        //找出数值部分的最后一个元素
        for(;j>0;j--)
        {
            if(isdigit(str[j])) break;
        }
        //判断数值的正负
        bool sym = true;
        if(str[i]=='+' || str[i]=='-')
        {
            if(str[i+1]=='+' || str[i+1]=='-') return 0;
            else
            {
                if(str[i]=='-') sym = false;
                i++;
            }
        }
        //判断是否超过int大小
        long long num = 0;
        bool overflow = false;
        while(i<=j)
        {
            if(!isdigit(str[i])) break;
            num = num * 10 + str[i] - '0';
            if(num!=int(num))
            {
                overflow = true;
                break;
            }
            i++; 
        }
        //根据符号正负选择对应的输出
        if(sym)
        {
            if(!overflow) return num;
            else return pow(2,31)-1;
        }
        else
        {
            if(!overflow) return -num;
            else return -pow(2,31);
        }
    }
};

2 链表

2.1 【回溯】【链表】剑指 Offer 06 - 从尾到头打印链表

https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/

（1）常规思路，先正序存入一个数组中，然后再逆序存入另一个数组中，作为最后结果；
（2）回溯法，先找到链表的最后一个元素，然后一步步往前输出到数组中。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
//常规思路
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> temp , ans;
        ListNode *p = head;
        while(p)
        {
            temp.push_back(p->val);
            p = p->next;
        }
        for(int i=temp.size()-1;i>=0;i--)
        {
            ans.push_back(temp[i]);
        }
        return ans;
    }
};

//回溯法
class Solution {
public:
    vector<int> ans;
    vector<int> reversePrint(ListNode* head) {
        if(!head) return ans;
        reversePrint(head->next);
        ans.push_back(head->val);
        return ans;
    }
};

2.2 【双指针】【链表】剑指 Offer 24 - 反转链表

https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/

  定义两个指针，cur指向头结点，ans指向NULL，在每次遍历中都让cur的下一个元素指向ans，实现反转。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *cur = head , *ans = NULL;
        while(cur)
        {
            ListNode *tmp = cur->next;
            cur->next = ans;
            ans = cur;
            cur = tmp;
        }
        return ans;
    }
};

2.3 【链表】【回溯】【哈希表】剑指 Offer 35 - 复杂链表的复制

https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof

  这道题目考察的是链表的深拷贝，这里借助哈希表来存储结点，而且这个链表有一个随机指针，所以普通的复制是行不通的，因此采用了回溯的方法，每一次先看待复制的结点是否在哈希表中，如果在的话才好复制random指向的结点。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    unordered_map<Node*,Node*> hash_map;
    Node* copyRandomList(Node* head) {
        if(head == nullptr) return nullptr;
        if(!hash_map.count(head))
        {
            Node *new_node = new Node(head->val);
            hash_map[head] = new_node;
            new_node->next = copyRandomList(head->next);
            new_node->random = copyRandomList(head->random);
        }
        return hash_map[head];
    }
};

3 双指针

3.1 【链表】【双指针】剑指 Offer 18 - 删除链表的节点

https://leetcode.cn/problems/shan-chu-lian-biao-de-jie-dian-lcof/

  采用双指针，cur指向当前遍历的结点，pre指向cur的前一个结点，如果遇到val就直接删除，这里需要特殊判断一下头结点就是val的情况。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if(head->val == val) return head->next;
        ListNode *pre = head;
        ListNode *cur = head;
        while(cur!=nullptr && cur->val!=val)
        {
            pre = cur;
            cur = cur->next;
        }
        if(cur->val==val)
        {
            pre->next = cur->next;
        }
        return head;
    }
};

3.2 【双指针】剑指 Offer 22 - 链表中倒数第k个节点

https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/

  双指针left和right，先让right遍历k个结点，然后和left同时向后遍历，但right到达尾结点时left即为倒数第k个结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode *left = head;
        ListNode *right = head;
        for(int i=0;i<k;i++)
        {
            right = right->next;
        }
        while(right)
        {
            left = left->next;
            right = right->next;
        }
        return left;
    }
};

3.3 【递归】剑指 Offer 25 - 合并两个排序的链表

https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/

  判断当前l1和l2的大小，如果l1较小，就从l1往后连接，并返回l1，同理l2。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==nullptr) return l2;
        else if(l2==nullptr) return l1;
        else if(l1->val < l2->val)
        {
            l1->next = mergeTwoLists(l1->next,l2);
            return l1;
        }
        else
        {
            l2->next = mergeTwoLists(l1,l2->next);
            return l2;
        }
    }
};

3.4 【双指针】剑指 Offer 52 - 两个链表的第一个公共节点

https://leetcode.cn/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/

  利用双指针，定义pa和pb分别指向A和B的头节点，这里判断是否相交采用了一个非常有意思的方法，假设A和B相交节点前各有skipA和skipB个节点，而相交节点数为C，pa和pb同时开始遍历，如果pa遍历完了就指向headB，同理pb，那么到最后总会遍历相同次数，对于A：skipA+C+skipB，对于B：skipB+C+skipA，如果此时的节点一样的话，说明相交，否则说明都遍历到了各自的最后节点仍不相交，返回空指针。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA == nullptr || headB == nullptr) return nullptr;
        ListNode *pa = headA;
        ListNode *pb = headB;
        while(pa != pb)
        {
            pa = pa == nullptr ? headB : pa->next;
            pb = pb == nullptr ? headA : pb->next;
        }
        return pa;
    }
};

3.5 【双指针】剑指 Offer 21 - 调整数组顺序使奇数位于偶数前面

https://leetcode.cn/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof/

  定义双指针i和j分别指向数组的第一个元素和最后一个元素，然后i往后遍历，直到找到前半部分的第一个偶数，j向前遍历，直到找到后半部分的第一个奇数，然后交换i和j所在位置的数即可，如果想不改变奇数和偶数分别在数组中的原有排列位置，这里推荐采用快慢指针来实现，让两个指针同时从头开始遍历，分别找到第一个出现的偶数和奇数交换位置。

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int i = 0 , j = nums.size()-1;
        while(i<j)
        {
            if(nums[i]%2==1)
            {
                i++;
                continue;
            }
            if(nums[j]%2==0)
            {
                j--;
                continue;
            }
            swap(nums[i++],nums[j--]);
        }
        return nums;
    }
};

3.6 【双指针】剑指 Offer 57 - 和为s的两个数字

https://leetcode.cn/problems/he-wei-sde-liang-ge-shu-zi-lcof/

  定义双指针left和right，分别指向数组的第一个元素和最后一个元素，如果两者之和大于target，则right向前移，如果两者之和小于target，则left向后移，直到两者之和等于target，输出结果。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ans;
        if(nums.size()==1) return ans;
        int left = 0 , right = nums.size()-1;
        while(left<right)
        {
            if(nums[left] + nums[right] < target) left++;
            else if(nums[left] + nums[right] > target) right--;
            else
            {
                ans.push_back(nums[left]);
                ans.push_back(nums[right]);
                break;
            }
        }
        return ans;
    }
};

3.7 【双指针】剑指 Offer 58 - I - 翻转单词顺序

https://leetcode.cn/problems/fan-zhuan-dan-ci-shun-xu-lcof/

  定义双指针start和end，分别表示每个单词开始和结束。这道题的难点在于，如果两个单词之间存在不止一个空格应该怎么办，这里的做法是先把整个字符串反转，然后定义了index作为全局移动的指针，表示目前字符串遍历到哪里了，同时也借助index实现以下功能：

• 如果每个单词开始位置之前有多个空格，则去掉这些空格，使用的方法是挨个赋值代替这些空格，例如" abc"->“abcc”;
• 当每个单词的反转结束时，下一个字符一定是空格，例如"abcc"->"cba ";
• 当所有单词全部反转之后，会在字符串末尾留下一些空格，去掉它们，例如"cba "->“cba”。

class Solution {
public:
    string reverseWords(string s) {
        reverse(s.begin(),s.end());
        
        int index = 0;
        for(int start=0;start<s.size();start++)
        {
            if(s[start]!=' ')
            {
                //对应第二个功能
                if(index!=0) s[index++] = ' ';
                int end = start;
                //对应第一个功能
                while(end<s.size() && s[end]!=' ')
                {
                    s[index++] = s[end++];
                }
                reverse(s.begin()+index-(end-start),s.begin()+index);
                start = end;
            }
        }
        //对应第三个功能
        s.erase(s.begin()+index,s.end());
        return s;
    }
};