额外题目第1天｜1365 941 1207 283 189 724 34 922 35 24

1365 暴力解法也能过

class Solution {
public:
    vector smallerNumbersThanCurrent(vector& nums) {
        vector result(nums.size(), 0);
        for (int i=0; i

优化 看了代码随想录的思路 其实本来自己想到了要sort就可以 但是没想到用一个hash来对应数值和数组中比他小的个数 填充hash时从后往前 这样相等的数值就会被覆盖成最前面的 

class Solution {
public:
    vector smallerNumbersThanCurrent(vector& nums) {
        vector sorted = nums;
        sort(sorted.begin(), sorted.end());

        int hash[105] = {};
        for (int i=sorted.size()-1; i>=0; i--) {
            hash[sorted[i]]=i;
        }

        vector result(nums.size(), 0);
        for (int i=0; i

941 我是按照顺序来遍历找山峰的 但这个逻辑确实是比较容易有所疏漏 所以第一次提交的时候忽略了单调递减这个情况 错误判断成了true

class Solution {
public:
    bool validMountainArray(vector& arr) {
        if (arr.size()<3) {
            return false;
        }
        int i=1;
        while (iarr[i-1]) {
            i++;
        }
        if (i>=arr.size() || arr[i]==arr[i-1] || i==1) {
            return false;
        }
        while (i=arr.size()) {
            return true;
        }
        return false;
    }
};

用双指针来写更加清晰且不易错 让i和j从两边单调递增到山峰 最后的i和j应该是会合且不在数组头尾 其他情况都return false

lass Solution {
public:
    bool validMountainArray(vector& arr) {
        if (arr.size()<3) return false;
        int i=1;
        int j= arr.size()-2;
        while (iarr[i-1]) i++;
        while (j>=0 && arr[j]>arr[j+1]) j--;
        i--; j++;
        if (i!=j || i==0 || j==arr.size()-1) return false;
        return true;
    }
};

1207 典型哈希表题目 出现的元素范围是-1000到1000 所以定义数组hash数出元素出现的个数 之后遍历整个hash数组 再映射到existed数组 如果hash数组的值>0则记为出现过 如果遍历到出现过的个数就return false

下面comment的是我自己想的用umap来写的 就是把每个次数map到第一个元素出现这么多次数的数上面去 遍历arr数组 通过hash值在map里找这个次数 如果找到就说明前面有过相同次数 return false

class Solution {
public:
    bool uniqueOccurrences(vector& arr) {
        int hash[2001]={0};
        for (int i=0; i0) existed[hash[i]]=true;
        }
        return true;
        
        /* unordered_map umap;
        for (int i=0; i

 283 这个是我自己想的！ 每次从头找第一个零 与他后面第一个非0交换位置 直到两个while loop任意一个到数组末尾为止

class Solution {
private:
    void swap(vector& nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
public:
    void moveZeroes(vector& nums) {
        while (true) {
            int i=0; 
            while (i

这个思路是参考代码随想录之后写的 双指针法效率感觉更高！如果忘记思路了可以再去看一下那个动图 总结来说就是slow指针是一个一个走的 fast碰到有0的就跳过 每次让nums[slow]=nums[fast] 当fast走到末尾的时候 从slow现在的位置到末尾都赋值0

class Solution {
public:
    void moveZeroes(vector& nums) {
        int slow=0;
        int fast=0;
        while(fast

189 double数组之后再赋值就可以！注意旋转方向

class Solution {
public:
    void rotate(vector& nums, int k) {
        k=k%nums.size();
        vector double_nums(2*nums.size(),0);
        for (int i=0; i

method 2 先反转整个数组 再反转前k个和后面的（这是向右轮转）

--diff 向右转就是前k个 向左转是后k个

class Solution {
public:
    void rotate(vector& nums, int k) {
        //method 2
        k=k%nums.size();
        reverse(nums.begin(), nums.end());
        reverse(nums.begin(), nums.begin()+k);
        reverse(nums.begin()+k, nums.end());
    }
};

 724 本来想用双指针做 但因为数组里会有负数所以还是用动态规划来做比较好 （其实这里的left和right不需要是数组 是variable就可以了 每次覆盖就ok

class Solution {
public:
    int pivotIndex(vector& nums) {
        vector left(nums.size(), 0);
        vector right(nums.size(),0);
        left[0]=0;
        for (int i=1; i

34 二分查找题 一定一定要记得是什么区间 这里是左闭右闭 所以更新mid的时候是left=mid+1 or right = mid-1 才能终止while loop

class Solution {
public:
    vector searchRange(vector& nums, int target) {
        int left = 0; 
        int right = nums.size()-1; 
        int mid=0;
        while (left<=right) {
            mid = (left+right)/2;
            if (nums[mid]==target) break;
            if (nums[mid]>target) right=mid-1;
            else if (nums[mid] result = {-1,-1};
        if (nums.size() == 0 || nums[mid]!=target) return result;

        int first=mid; int last=mid;
        while (first>=0 && nums[first]==target) first--;
        first++;
        while (last

922 双指针法 i指向偶数位 j指向奇数位 遇到合格的就跳过 两个都是不合格的就互换位置 一直到任意一个遍历完整个数组位置

class Solution {
public:
    vector sortArrayByParityII(vector& nums) {
        int i=0;
        int j=1;
        while (i=nums.size() || j>=nums.size()) break;
            int temp = nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
        }
        return nums;
    }
};

35 二分查找经典模版 但return的时候要判断一下是放在mid前面还是后面

class Solution {
public:
    int searchInsert(vector& nums, int target) {
        int left = 0; int right = nums.size()-1;
        int mid=0;
        while (left<=right) {
            mid = (left+right)/2;
            cout<<"mid = "<nums[mid]) left = mid+1;
            else if (targettarget) return mid;
        return mid+1;
    }
};

24 记得加dummy_head会好写一点 要单独考虑特殊情况 用curr来遍历整个链表

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummy_head = new ListNode(0, head);
        ListNode* curr = dummy_head;
        while (curr!=nullptr) {
            ListNode* temp = curr->next;
            if (temp==nullptr || temp->next == nullptr) break;
            ListNode* temp1 = temp->next->next;
            curr->next = temp->next;
            curr->next->next = temp;
            temp->next = temp1;
            curr = curr->next->next;
        }
        return dummy_head->next;
    }
};