极客时间 - 算法训练营 算法笔记

本文章是基于极客时间算法训练营 李煜东版本课程进行总结记录，也作为自己的算法笔记，长期更新
任何思考，都基于模型的基础出发

第一周 数组、链表、栈、队列

1. 数组

26.去重
给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

保序操作的模板（需要自己填写过滤器）

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        //先遍历 确定要不要处理该元素
        int n =0; //确定存了几个数
        for(int i =0;i< nums.size();i++){
            if(){   //此处填写过滤器，要处理 
                nums[n]= nums[i];
                n++;
            }
        }
        return n;
    }
};

本题答案

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        //先遍历 确定要不要处理该元素
        int n =0; //确定存了几个数
        for(int i =0;i< nums.size();i++){
            if( i == 0 ||nums[i] != nums[i-1]) {   //要处理 ,对于i=0 必定存入
                nums[n]= nums[i];
                n++;
            }
        }
        return n;
    }
};

283.移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

本题答案（套用上题模板）

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = 0;
        //该循环保前面非0数
        for(int i =0;i<nums.size();i++){
            if(nums[i]!=0){
                nums[n]= nums[i];
                n++;
            }
        }
        //该循环保后面的0数
        while(n<nums.size()){
            nums[n] = 0;
            n++;
        }
    }
};

88.合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

使用一个新的数组的方法

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        //新建一个数组
        vector<int> result;
        int i=0;j=0;
        while( i<m || j<n ){
            if ( j>=n || (i<m && nums1[i] <= nums2[j])){ //第二个数组出界了或者两个都还在界内，要小的
                result.push_back(nums1[i]);
                i++;
            }else{
                result.push_back(nums2[j]);
                j++;
            }
        }
        for(int i =0;i<m+n;i++) {
            nums1[i]=result[i];
        }
        
    }
};

不使用额外空间的方法

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        //原地合并两个有序数组
        int i = m-1;
        int j = n-1;
        for (int k = m+n-1;k>=0;k--){
            //当第二个数组遍历完成或 第一个数组末元素大于第二个数组末元素时，将第一个数组末元素从后往前放置
            if(j<0 || (i>=0 && nums1[i]>=nums2[j] )){
                nums1[k] = nums1[i];
                i--;
            }else{
                nums1[k] = nums2[j];
                j--;
            }
        }
    }
};

2. 链表

同数组一样，首先思考模型，先给出第一题就是一个模板题 ，单链表的逆置

206. 反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

/**
 * Definition for singly-linked list.
 * 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) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //链表遍历模板
        ListNode* last = NULL; //用于存当前结点的上一个结点
        while(head != NULL){
            ListNode* nextHead = head->next;
            head->next = last;
            //始终保持last是head的前一个
            last = head;
            head = nextHead;
        }
        //最后返回的是最后处理的一个结点
        return last;

    }
};

25. K 个一组翻转链表
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

注意点： 本题目需要用到上题的模板

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* protect = new ListNode(0,head); 
        ListNode* last = protect; 
        //分组遍历框架
        while(head != NULL){
            //1.分组 （往后走k-1步，找到一组）
            //找到一组的开头head 结尾 end
            ListNode* end = getEnd(head,k);
            //最后一组不足k个，不处理
            if (end == NULL) break;

            ListNode* nextGroupHead = end->next;

            
            //2.一组内部（head到end之间）要反转（调用反转链表）
            reverseList(head,nextGroupHead);

            //3.更新每一组跟前一组、后一组之间的边
            //上一组的最后一个指向end
            last->next = end;
            head->next = nextGroupHead;

            last = head;
            head = nextGroupHead;
        }
        return protect->next;   
    }

    ListNode* getEnd(ListNode* head,int k){
        while(head != NULL){
            k--;
            if(k==0) return head; // 访问到该组的最后一个
            head = head->next;
        }
        //最后一组，不足k个,返回空
        return NULL;
    }

    //反转链表，在stop这里停止（组内）
    void reverseList(ListNode* head, ListNode* stop) {
    //链表遍历模板
        ListNode* last = head; //用于存当前结点的上一个结点,在组内反转时，第一个结点不用指向空，从模板第二步开始
        head = head->next;
        while(head != stop){
            ListNode* nextHead = head->next;
            head->next = last;
            //始终保持last是head的前一个
            last = head;
            head = nextHead;
        }

    }
};