2021.1.18 刷题(反转字符串、链表)

1.反转字符串
题目链接：https://leetcode-cn.com/problems/reverse-string
题目描述：
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：
输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

双指针法图示：

代码：

class Solution {
public:
    void reverseString(vector<char>& s) {
        int i = 0;
        int j = s.size() - 1;
        for(i, j; i < s.size()/2; i++, j-- )
        {
            swap(s[i],s[j]);
        }

    }
};

2.反转字符串||
题目链接：https://leetcode-cn.com/problems/reverse-string-ii
题目描述：
给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例:
输入: s = "abcdefg", k = 2
输出: "bacdfeg"
解题：

class Solution {
public:
    string reverseStr(string s, int k) {
        for(int i = 0; i< s.size(); i += (2 * k))
        {
            if((i + k) <= s.size())
            {
                reverse(s.begin() + i, s.begin() + i + k);
                continue;
            }
            reverse(s.begin() + i, s.end());

        }
        return s;
    }
};

3.反转链表
题目链接：https://leetcode-cn.com/problems/reverse-linked-list/
题目描述：
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

/**
 * 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 *pre = NULL;
        ListNode *cur = head;
        ListNode *temp;
        while(cur)
        {
            temp = cur-> next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

4.反转链表||
题目链接：https://leetcode-cn.com/problems/reverse-linked-list-ii/
题目描述：
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。

示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n || !head || !head->next) return head;
        ListNode* prehead = new ListNode;
        prehead->next = head;
        ListNode* p = prehead,*q = head;
        for(int i = 1; i<m; i++) p = p->next;     //翻转范围前的一个
        q = p->next;
        int i = n-m;
        while(i--)
        {                                   //头插法
            ListNode* t = q->next;
            q->next = t->next;
            t->next = p->next;
            p->next = t;
        }
        return prehead->next;
    }
};