2021-08-29

学习目标：

整理笔记，刷题！

学习内容：

1.题151.翻转字符串里的单词

给你一个字符串 s ，逐个翻转字符串中的所有 单词 。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
请你返回一个翻转 s 中单词顺序并用单个空格相连的字符串。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-words-in-a-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法1

先用reverse()函数将字符串翻转，使每个单词的位置是对的；
之后将单个单词原地翻转，start记录每个单词的开始，遍历每个单词时，end记录单词翻转的结尾，idx记录新的字符串的位置；

string reverseWords(string s) {
        //翻转整个字符串
        reverse(s.begin(), s.end());

        //原地翻转单个单词
        int n = s.size();
        int idx = 0;

        for(int start = 0; start < n; start++){

            //不能有while(s[start] != ' ')，不需要循环更新
            if(s[start] != ' '){
                //除了第二个单词，其余单词的开头都要加一个空格
                if(idx != 0) s[idx++] = ' ';

                //遍历单词，原地更新替换
                int end = start;
                while(end < n && s[end] != ' '){
                    s[idx++] = s[end ++];
                }

                //翻转单个单词
                reverse(s.begin() + idx - (end - start), s.begin() + idx);//索引-单词长度

                //更新start到下一个单词开头
                start = end;
            }
        }

        //删除尾部多余空格
        s.erase(s.begin() + idx, s.end());
        return s;

    }

s.begin() + 偏移量，不是下标索引
s.erase(s.begin(), s.end()) 删除某段字符串
s.substr()取出子串

方法2 双端队列，在头部入队，实现先进后出

 //双端队列，先入后出
    string reverseWords(string s) {
        //首先将两端的空格去掉
        int left = 0;
        int right = s.size() - 1;
        //需要保证 left <= right
        while(left <= right && s[left] == ' ') left++;
        while(left <= right && s[right] == ' ') right--;
        
        //创建双端队列，开始入队
        deque<string> d;
        string word;

        while(left <= right){
            char c = s[left];
            if(word.size() && c == ' '){
                d.push_front(move(word));
                word = "";
            }
            else if(c != ' '){
                word += c;
            }

            left++;
        }

        //将最后一个单词入队
        d.push_front(move(word));

        //出队重新连接
        string ans;
        while(!d.empty()){
            ans += d.front();
            d.pop_front();
            //除了最后一个单词，每一个单词结尾加空格
            if(!d.empty()) ans += ' ';
        }

        return ans;

    }

方法3 直接循环

    string reverseWords(string s) {
        int len = s.length(), i = 0;
        string ans = "", tmp;
        while(i < len){
            tmp = "";
            while(i < len && s[i] == ' ') i++;
            while(i < len && s[i] != ' ') tmp += s[i++];
            if(tmp != ""){
                ans = tmp + " " + ans;
            }
        }
        return ans.substr(0, ans.length()-1);
    }

2.题25.K个一组翻转链表（链表的题目）

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

链表定义

struct ListNode{
	int val;
	ListNode* next;
	//构造函数，有参列表
	ListNode() :val(0), next(nullptr) {}
	ListNode(int x): val(x), next(nullptr) {}
	ListNode(int x, ListNode* next): val(x), next(next) {}
};	

如何构建虚假的链表头？

ListNode* dummyHead = new ListNode(0);

先来个简单的练练手！！

21.合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

方法1 迭代

 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {

        ListNode* dummyHead = new ListNode(-1);
        //定义一个指针变量 
        ListNode* prev = dummyHead;

        while(l1 != nullptr && l2 != nullptr){
            if(l1->val < l2->val){
                //连接l1
                prev->next = l1;
                //l1向后移动
                l1 = l1->next;
            }
            else{
                prev->next = l2;
                l2 = l2->next;
            }
            //prev指针向后移动
            prev = prev->next;
        }

        //结束后，连接剩下的
        prev->next = l1 == nullptr? l2: l1;

        return dummyHead->next;

    }

方法2 递归

终止条件：当两个链表都为空时，表示我们对链表已合并完成。
如何递归：我们判断 l1 和 l2 头结点哪个更小，然后较小结点的 next 指针指向其余结点的合并结果。（调用递归）

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;
        }
    }

练手结束！！！

不太行，再来一个简单的练练手！！！

206.反转链表

方法1 迭代

双指针，prev， curr，再加一个临时变量next记录过程值。
涉及链表的题目，画图永远是对的。

 ListNode* reverseList(ListNode* head) {
        //迭代
        ListNode* prev = nullptr;
        ListNode* curr = head;

        while(curr != nullptr){
            //翻转
            ListNode* next = curr->next;
            curr->next = prev;
            //指针向前移动
            prev = curr;
            curr = next;
        }
        return prev;
    }

方法2 递归，目前看不太懂！

方法1 迭代（开始解决困难题啦）

思路：
1.需要构造一个链表翻转函数reverseListNode()
2.画图，模拟翻转过程，先翻转再更新变量
3.定义一个虚链表头dummyHead，指向head
定义指针perv，表示待翻转链表的上一个节点
定义指针end，表示待翻转链表的为节点
4.首先待翻转的链表节点数是否够K for循环，并找到尾部节点
5.暂时断开，翻转，连接
定义临时变量start， 用来存放待翻转链表的头节点，也即翻转后的链表的尾节点，也即下一个待翻转链表的上一个节点，用来更新perv
定义临时变量next，用来记录下一个待翻转链表的头节点，有了更新perv->next;
6.更新

 //用于进行链表翻转的函数，输入链表的头
    ListNode* reverseListNode(ListNode* head){
        ListNode* prev = nullptr;
        ListNode* curr = head;

        while(curr != nullptr){
            ListNode* next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }

        return prev;
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        //创建虚假链表头
        ListNode* dummyHead = new ListNode(-1);
        dummyHead->next = head;

        ListNode* prev = dummyHead;//prev 代表每次翻转链表头节点的上一个节点
        ListNode* end = dummyHead;//end 代表每次翻转链表的尾节点

        while(end->next != nullptr){

            //循环检查当前待翻转的链表是否有k个节点
            for(int i = 0; i < k && end != nullptr; i++){
                end = end->next;
            }
            //如果不够k个就直接结束循环
            if(end == nullptr) break;

            //需要有一个中间变量记录待翻转的链表的头（其中的next需要改变）
            ListNode* start = prev->next;
            //记录下一个需要翻转的链表头
            ListNode* next = end->next;
            //断开链表
            end->next = nullptr;
            //翻转链表，并进行连接
            prev->next = reverseListNode(start);
            //更新
            /*ListNode* temp = new ListNode(0);
            temp->next = next;
            错误*/
            start->next = next;
            prev = start;
            end = prev;
        }

        return dummyHead->next;
        
    }

方法2 递归

理解不了，顶不住了，今天就到这！！
明天加油！！！

学习总结：

1.deque用法
2.有链表就画图，模拟，迭代
3.递归，太难了，以后攻克