2021-5-13学习记录

主题：

昨天鸽了，实际上是因为昨天写的题有点少，没好意思发，嘿嘿嘿。今日涉及

• 算法题：合并两个有序数组
• 算法题：链表中的节点每k个一组进行反转
• 算法题：合并有序链表
• 算法题：二叉树的层序遍历

内容：

1 合并两个有序数组
问题描述：合并两个有序数组，其中一个数组A有足够大的空间，可以容纳合并后的数组
解决思路：比较法：如果可以使用一个额外的数组的话，可以首先创建一个数组空间作为整合后的数组
的容器。双指针，分别指向两个数组的末尾元素，进行比较，如果A的末尾元素>B的末尾元素的话，
就把A的末尾元素放到新的数组中，指针前移一步。否则，把B的末尾指针放到新的数组中，前移一步
那是因为在末尾位置上比较，比较大的就肯定是AB所有元素中最大的，就需要放到新的数组中。
当两个指针有一个小于0的时候，也就是一个队列遍历结束，如果另外一个队列还有，那就将这个队列
的全部逐个拷贝进去。
同样的道理，也可以使用从AB的头开始的策略，也就是找到目前所有的中最小的元素。

如果直接使用A的空间的话，就不可以采用从头开始的比较法，而应该采用从尾开始的比较法。把
A当作新申请的数组空间，这个数组空间的长度为m+n，永远不会和A的遍历指针相撞。
代码

void merge(int A[], int m, int B[], int n) {
        
        int p1 = m-1;
        int p2 = n-1;
        int p = m+n-1;
        while(p1>=0 && p2>=0)
        {
            A[p--] = A[p1]>B[p2]?A[p1--]:B[p2--];  //找最大的赋值，然后--，是向后退
        }
        while(p2>=0)  //如果p1率先完成了
        {
            A[p--] = B[p2--];
        }
    }

2 链表中的节点每k个一组进行反转
问题描述：将给出的链表中的节点每k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。
要求空间复杂度O(1)
例如：
给定的链表是1→2→3→4→5
对于k=2, 你应该返回 2→1→4→3→5
对于k=3, 你应该返回 3→2→1→4→5
思路：采用递归的思路进行操作：
1 拿到一个链表，首先设置一个tail指针，向后跳k次，作为一个
尾指针。然后在head和tail区域内进行链表逆转。
2 将反转部分的反转之后的尾指针的next来指向下一组的头节点。
注意点：以tail和head作为区间进行反转，采用的是设置一个pre指针，一个mid指针，
一个next用来在每一次进行保存前向的指针。pre初始化为null，mid初始化为head
这两个指针是最重要的。mid指向谁，代表本次处理会反转谁。因此，可以当next为null的
那一轮，说明已经到头了，而且已经反转了最后一个元素。这是针对从头到尾的来的。
如果是到某一个指针就结束了，并且是左闭右开的，那么就可以将条件设置为mid不等于tail
代码：

ListNode* reverseKGroup(ListNode* head, int k) {
        //递归做法
        if(head == NULL || head->next == NULL)  //当没有元素和只有一个元素
            return head;
        ListNode* tail = head;
        for(int i=0;i<k;i++)
        {
            if(tail == NULL)
            {
                return head;
            }
            tail = tail->next;
        }
        
        ListNode* newHead = reverse(head, tail);
        //cout<<newHead->val<<endl;
        head->next = reverseKGroup(tail, k);  //反转的时候是左开右闭的，因此，下一轮的头是tail，不是newhead
        //cout<<"完成输出\n";
        return newHead;
    }
    
    ListNode* reverse(ListNode* head, ListNode* tail)
    {
        ListNode* pre = NULL;
        ListNode* next = NULL;
        ListNode* mid  = head;
        while(mid!=tail)
        {
            next = mid->next;
            mid->next = pre;
            pre  = mid;
            mid = next;
        }
        return pre;
    }

3 合并有序链表
题目描述：将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来
生成的，且合并后新链表依然有序。
思路：设置一个新的链表头指针。《为了避免不必要的麻烦，可以设置一个头节点，不过最后要返回
head->next，来跳过头节点即可。》
对于每一轮，比较l1和l2的值大小，然后比较大小，比较小的将指针加入到新的链表里面。
当有一个链表结束时，就进行剩余的链接进去。
注意：特殊情况，也就是l1或者l2为NULL的情况，直接输出另外一个即可,不许要管另外一个是NULL
还是别的什么
代码：

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        // write code here
        /*
        if(l1 == NULL || l2==NULL)
        {
            if(l1!=NULL)
            {
                return l1;
            }
            else if(l2!=NULL)
            {
                return l2;
            }
            else{
                return NULL;
            }
        }
        */
        //可以简化为
        /*
        if(l1 ==NULL) return l2;
        if(l2 == NULL) return l1;
        
        ListNode* l = new ListNode(0);//为了避免多余操作，先设置一个头节点
        ListNode* ll = l;
        while(l1!=NULL && l2!=NULL)
        {
            if(l1->val > l2->val)
            {
                l->next = l2;
                l2 = l2->next;
                l = l->next;
            }
            else{
                l->next = l1;
                l1 = l1->next;
                l = l->next;
            }
        }
        
        /*
        if(l1!=NULL)
        {
            while(l1!=NULL)
            {
                l->next = l1;
                l1 = l1->next;
                l = l->next;
            }
        }
        
        if(l2!=NULL)
        {
            while(l2!=NULL)
            {
                l->next = l2;
                l2 = l2->next;
                l = l->next;
            }
        }
        */
        //可以简化为
        l->next = (l1==NULL)?l2:l1;
        return ll->next;
    }

4 二叉树的层序遍历
问题描述：给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）
要求用一个vector矩阵来盛放每一层的节点数据。也就是一层一个vector，而不是全部
从标准输出中输出
思路：仍然利用queue的数据结构。用一个while循环（条件为size–大于0）完成一个层的遍历，
也就是当前层的元素用一个vector，下一层的元素开始进队列。
代码：

vector<vector<int> > levelOrder(TreeNode* root) {
        // write code here
        queue<TreeNode*> q;
        vector<vector<int>> bfs;
        if(root==NULL) return bfs;
        q.push(root);
        while(!q.empty())
        {
            int size = q.size();  //存放每一层的值，旧的一层弹出，新的一层进去
            vector<int> vec;
            while(size--)  //完成层内容的深入和更换，并且把当前层次进行保存
            {
                TreeNode* node = q.front();
                q.pop();
                vec.push_back(node->val); 
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            if(vec.size()>0)  bfs.push_back(vec);
        }
        return bfs;
    }