2021-03-21

最新推荐文章于 2022-04-12 15:52:08 发布
最新推荐文章于 2022-04-12 15:52:08 发布
阅读量168 收藏
点赞数
分类专栏： 春招实习刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZAJ1996/article/details/115035512
版权

LeetCode Easy

两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> Map;
        for(int i=0;i<nums.size();i++)
        {
            Map[nums[i]]=i;
        }
        vector<int> res;
        for(int j=0;j<nums.size();j++)
        {
            int k=target-nums[j];
            if( (Map.count(k))&&(Map[k]!=j) )//顺序不能颠倒
            {
                res.push_back(j);
                res.push_back(Map[k]);
                break;
            }
        }
        return res;
    }
};

整数反转

在这里插入图片描述

class Solution {
public:
    int reverse(int x) {
        int a=0;
        while(x!=0)
        {
            int pop=x%10;      
            x=x/10;
            if(a>INT_MAX/10||(a==INT_MAX/10&&pop>7))
            {
                //cout<<111;
                return 0;
            }
            if(a<INT_MIN/10||(a==INT_MIN/10&&pop<-8))
            {
                return 0;
            }
            a = a*10+pop;
          
        }
    return a;
    }
};

回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
思想其实就是反转数，判断反转数和原数相不相等，再对别的情况进行判断，比如超过范围，负数等；

class Solution {
public:
    bool isPalindrome(int x) {
        int temp=x;
        int a=0;
        if(x<0)
        {
            return false;
        }     
        while(x!=0)
        {
            int pop=x%10;
            x/=10;
            if(a>INT_MAX/10 || ((a==INT_MAX/10)&&pop>7))
            {
                return false;
            }
            if(a<INT_MIN/10 || ((a==INT_MIN/10)&&pop<-8))
            {
                return false;
            }
            a=a*10+pop;
        }
        //cout<<a;
        if(a==temp)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};

罗马数字转整数

在这里插入图片描述

class Solution {
public:
    int romanToInt(string s) {
        unordered_map<string,int> M={{"I",1},{"V",5},{"X",10},{"L",50},{"C",100},{"D",500},{"M",1000}};
        int i=s.size()-1;
        string k=s.substr(i,1);
        int result=M[k];
        
        while(i>0)
        {
            if(M[s.substr(i-1,1)]<M[s.substr(i,1)])
            {
                result-=M[s.substr(i-1,1)];
                //cout<<result<<endl;
            }
            if(M[s.substr(i-1,1)]>=M[s.substr(i,1)])
            {
                result+=M[s.substr(i-1,1)];
                //cout<<result<<endl;
            }
            --i;
        }
        return result;
    }
};

最长公共前缀

在这里插入图片描述

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if(!strs.size())
            return "";
        int count=strs.size();
        string prefix=strs[0];
        for(int i=1;i<count;i++)
        {
            prefix=longestCommonPrefix(prefix,strs[i]);
            if(!prefix.size())
                return "";
        }
        return prefix;
    }
    string longestCommonPrefix(string& str1,string& str2)
    {
        int length=min(str1.size(),str2.size());
        int index=0;
        //string prefix=str1[0];
        while(index<length)
        {
            if(str1[index]==str2[index])
            {
                //prefix=str1[index];
                index++;
            }
            else
                break;
        }
        return str1.substr(0,index);
    }
};

有效的括号

在这里插入图片描述
其实就是利用栈的思想，先压左括号

class Solution {
public:
    bool isValid(string s) {
        unordered_map<char,char> M={{')','('},{'}','{'},{']','['}};
        int count=s.size();
        stack<char> left;
        //cout<<s[0];
        if(count%2!=0)
            return false;
        else
        {
            for(int i=0;i<count;i++)
            {
                if(M.count(s[i]))
                {
                    if(left.empty()||left.top()!=M[s[i]])
                    {
                        return false;
                    }
                    left.pop();
                }
                else
                    left.push(s[i]);
                
            }
        }
        return left.empty();
    }
};

合并两个有序链表

在这里插入图片描述

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

删除链表的倒数第 N 个结点

在这里插入图片描述

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy=new ListNode(0,head);//作用在于当删除的是head结点的时候也可以正常操作
        ListNode* first=head;
        ListNode* second=dummy;
        for(int i=0;i<n;i++)
        {
            first=first->next;
        }
        while(first)
        {
            first=first->next;
            second=second->next;
        }
        second->next=second->next->next;
        ListNode* ans=dummy->next;
        delete dummy;
        return ans;
    }
};

反转链表

双指针

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

删除链表的节点

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        ListNode* dummy=new ListNode(0,head);
        ListNode* t=dummy;
        while(t->next->val!=val)
        {
            t=t->next; 
        }
        t->next=t->next->next;
        return dummy->next;
    }
};

反转链表II

在这里插入图片描述

/**
 * 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* reverseBetween(ListNode* head, int left, int right) {
        ListNode* dummy=new ListNode(0,head);
        ListNode* cur=dummy;
        ListNode* pre=head;
        ListNode* back=head;
        ListNode* fore=dummy;
        if(left==right)
        {
            return head;
        }
        else
        {
            for(int i=0;i<left;i++)
            {
                cur=cur->next;
                pre=pre->next;
                //fore=fore->next;
            }
            //cur=cur->next;
           // pre=pre->next;
            ListNode* p=cur;
            for(int i=0;i<left-1;i++)
            {
                fore=fore->next;
            }
            for(int j=0;j<right;j++)
            {
                back=back->next;
            }
            while(pre!=back)
            {
                ListNode* t=pre->next;
                pre->next=cur;
                cur=pre;
                pre=t;
            }
            fore->next=cur;
            p->next=back;
            return dummy->next;
        }
    }
};

两个链表的第一个公共节点

输入两个链表，找出它们的第一个公共节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* nodeA= headA;
        ListNode* nodeB= headB;
        while(nodeA != nodeB)
        {
            nodeA=nodeA==NULL?headB:nodeA->next;
            nodeB=nodeB==NULL?headA:nodeB->next;
        }
        return nodeA;
    }
};

环形链表

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        
        //bool ans=false;
        if(head==NULL||head->next==NULL)
        {
            return false;
        }
        else
        {
            ListNode* slow=head;       
            ListNode* fast=head->next;
            while(slow!=fast)
            {
                if(fast==NULL||fast->next==NULL)
                {
                    return false;
                }
                slow=slow->next;
                fast=fast->next->next;
            }
        }
        return true;
    }
};

回文链表

请判断一个链表是否为回文链表。`

/**
 * 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:
    bool isPalindrome(ListNode* head) {
        if(head==nullptr)
        {
            return true;
        }
        else
        {
            vector<int> a;
            while(head != nullptr)
            {
                a.push_back(head->val);
                head=head->next;
            }
            int len=a.size();
            for(int i=0,j=len-1;i<j;++i,--j)
            {
                if(a[i]!=a[j])
                {
                    return false;
                }
            }
            return true;
        }
    }
};

快慢指针解法，空间复杂度为o（1）

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if (head == nullptr) {
            return true;
        }

        // 找到前半部分链表的尾节点并反转后半部分链表
        ListNode* firstHalfEnd = endOfFirstHalf(head);
        ListNode* secondHalfStart = reverseList(firstHalfEnd->next);

        // 判断是否回文
        ListNode* p1 = head;
        ListNode* p2 = secondHalfStart;
        bool result = true;
        while (result && p2 != nullptr) {
            if (p1->val != p2->val) {
                result = false;
            }
            p1 = p1->next;
            p2 = p2->next;
        }        

        // 还原链表并返回结果
        firstHalfEnd->next = reverseList(secondHalfStart);
        return result;
    }

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

    ListNode* endOfFirstHalf(ListNode* head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast->next != nullptr && fast->next->next != nullptr) {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
};

链表的中间结点

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* dummy=new ListNode(0,head);
        ListNode* fast=dummy;
        ListNode* slow=dummy;
        while(fast->next!=NULL && fast->next->next!=NULL)
        {
            slow=slow->next;
            fast=fast->next->next;
        }
        //slow->next=slow->next->next;
        return slow->next;
    }
};

二进制链表转整数

给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。
请你返回该链表所表示数字的 十进制值 。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int getDecimalValue(ListNode* head) {
        ListNode* p=head;
        int ans=0;
        while(p !=NULL)
        {
            ans=ans*2+p->val;
            p=p->next;
        }     
        return ans;
    }
};

平衡二叉树

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        return dfs(root)!=-1;
    }
    int dfs(TreeNode* root)
    {
        if(root==NULL)
        {
            return 0;
        }
        int left=dfs(root->left);
        if(left==-1)
            return -1;
        int right=dfs(root->right);
        if(right==-1)
            return -1;
        return abs(left-right)<2?max(left,right)+1:-1;
    }
};

对称二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)
            return true;
        return isequal(root->left,root->right);
    }
    bool isequal(TreeNode* left,TreeNode* right)
    {
        if(left==NULL && right==NULL)
            return true;
        if(left==NULL && right!=NULL)
            return false;
        if(left!=NULL && right==NULL)
            return false;
        if(left->val!=right->val)
            return false;
        bool outside=isequal(left->left,right->right);
        bool inside=isequal(left->right,right->left);
        //bool ans=false;
        //if(left->val==right->val)
        //    ans=true;
        return outside && inside;
    }
};

二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if(root==NULL)
        {
            return NULL;
        }
        TreeNode* left=mirrorTree(root->left);
        TreeNode* right=mirrorTree(root->right);
        root->right=left;
        root->left=right;
        return root;    
    }   
};

二叉树的最近公共祖先

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* ans;
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
       dfs(root,p,q);
       return ans; 
    }
    bool dfs(TreeNode* root, TreeNode* p, TreeNode* q)
    {
        if(root==NULL)
        {
            return false;
        }
        bool lson=dfs(root->left,p,q);
        bool rson=dfs(root->right,p,q);
        if((lson && rson) || ((root->val == p->val || root->val == q->val) && (lson || rson)))
        {
            ans=root;
        }
        return lson || rson ||(root->val == p->val || root->val == q->val);
    }
};

从上到下打印二叉树II

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        if (!root)  return {};
        vector<vector<int>> res;    // 结果数组
        queue<TreeNode*> que;       // 辅助队列
        que.push(root);             
        while (!que.empty())
        {
            int cnt = que.size();   // 当前层的节点数
            vector<int> level;      // 保存当前层的元素
            // 处理当前层的元素，每个元素出队前将其左右子节点入队，作为下一层的元素
            while (cnt)
            {
                auto node = que.front();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                level.push_back(node->val);
                que.pop();
                cnt--;
            }
            res.push_back(level);   // 得到了一层的元素
        }
        return res;
    }
};

二叉搜索树的第K大节点

给定一棵二叉搜索树，请找出其中第k大的节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int n,ans=0;
    int kthLargest(TreeNode* root, int k) {
        n=k;
        dfs(root);
        return ans;
    }
    void dfs(TreeNode* root)
    {
        if(root==NULL||n==0)
        {
            return;
        }
        dfs(root->right);
        if(--n==0)
        {
            ans=root->val;
            return;
        }
        dfs(root->left);
    }
};
ZAJ1996
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode学习记录（C++）——第一题
LiuXF93的博客
08-11 668
1.题目：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 注：你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 2.原始模板 class Solution { public: vector<int> twoSum(vector<int>& nums...
leetcode1.两数之和
weixin_43980161的博客
03-16 85
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 你可以按任意顺序返回答案。 //暴力解法 class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { int i,j; for(i=0;i&
LeetCode #1 两数之和
weixin_42147027的博客
10-17 127
leetcode #1 两数之和 class Solution { public: vector&lt;int&gt; twoSum(vector&lt;int&gt;&amp; nums, int target) { vector&lt;int&gt; twoSum; for(int i=0;i&lt;nums.size();i++){ f...
Two Sum - LeetCode 题解
大松鼠
09-18 100
1.Two Sum Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solution, and you may not use ...
LeetCode 解题笔记（二）数组篇
火山上的企鹅
02-27 8641
文章目录26.删除排序数组中的重复--2022/01/16122. 买卖股票的最佳时机 II--2022/01/17189. 轮转数组--2022/01/18217. 存在重复元素--2022/01/19136. 只出现一次的数字--2021/12/14350. 两个数组的交集 II -- 2022/01/1266. 加一 -- 2022/01/201.两数之和 系列篇:      Qt TCP/UDP 网络协议入门实操（一）TCP通讯 Qt TCP/UDP
Exported-2021-03-21.vssettings
05-07
Exported-2021-03-21.vssettings
next.js-2021-03-21
03-21
命令$ npx create-next-app --use-npm --example with-typescript 备忘录 useRecoilState状态の更新に使うfunction useRecoilState < T> ( state : RecoilState < T> ) : [ T , SetterOrUpdater < T> ] ;...
2021-03-05_20-14-58_Underwater Survival Base.zip
03-07
2021年3月5日20时14分58秒，这个项目被封装在名为"2021-03-05_20-14-58_Underwater Survival Base.zip"的压缩文件中，它可能包含了设计图纸、研究报告、技术文档等一系列珍贵资料，为我们的讨论提供了宝贵的素材。...
WebIDE-UISimpleTC-2021-03-15T16-21-01.654Z-github
03-16
标题“WebIDE-UISimpleTC-2021-03-15T16-21-01.654Z-github”暗示这是一个与Web集成开发环境（WebIDE）相关的项目，可能是一个开源项目，存储在GitHub上。日期部分“2021-03-15T16-21-01.654Z”表示这个项目的某个...
优质资料（2021-2022年收藏）数控车工技师理论知识试卷03.doc
10-11
这份资料是2021-2022年间收集的数控车工技师理论知识试卷，主要涵盖数控车工的专业技能和理论知识。试卷分为两大部分，理论知识占比80%，职业道德占比20%。试题包括填空题和选择题，旨在考核考生在数控车削加工中的...
Leetcode——第1题两数之和
weixin_44730078的博客
12-06 401
题目要求是给一个数组，给一个target，求得到target的元素在数组中的位置 暴力法不展示，两层循环 这里是使用map容器，他能够提供一个关键字和关键字的值，这是成对出现的。 想法就是：创建一个map容器，从第一个数字遍历，记录下第一个数字与target的差值，放入容器。 循环到下一个数字，判断容器内是否有新的差值，如果有，那说明该数字和容器内差值数字对应的两个数字是结果。返回i和map[find] 代码展示： class Solution { public: vector<int>
力扣刷题第1天——两数之和
qq_52189899的博客
04-12 807
力扣每日一题挑战：第一天——两数之和
Leetcode - 1：两数之和
WINGREZ‘S BLOG
04-25 243
两数之和 来源：Leetcode 标签：基础 参考资料： 相似题目： 题目 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + n...
【C++】两数之和
https://blog.csdn.net/WL0616
07-27 1934
class Solution { public: vector<int> TwoSum(vector<int>&nums, int target) { int n = nums.size; for (int i = 0; i < n - 1; ++i) { for (int j = i + 1; j < n; ++j) { if (nums[i] + nums[j] == target) return{ i, j };
LeetCode | Roman to Integer
Allan的专栏
09-15 3624
题目： Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999. 思路： 罗马数字的基本思想是右加左减，并且左减最大只能一位。所以我们可以将所以数相加，然后再遍历一次，当前一个数比后一个数小时，从结果中减去该数
LeetCode学习——两数之和，C++方法（附详解，map，vector）
qq_42265133的博客
01-19 470
题目描述   给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。   你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 解法一——暴力搜索法  思路：   看到题目的第一眼想到的肯定是暴力搜索方法：即使用两个for循环，在第一个循环中，检查对于第i个元素，是否存在一个位置j处在[i + 1, ]，使...
Two Sum
luoshiyong123的博客
03-02 187
class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { vector<int> result(2); for(int i = 0;i<nums.size();i++) { ...
Leetcode 13题 罗马数字转换为整形
evolone的专栏
04-01 1550
Given a roman numeral, convert it to an integer.Input is guaranteed to be within the range from 1 to 3999.查了下罗马数字的进制与表示规律。 首先是进制： Roman numerals ( 罗马数字 ) : I = 1 V = 5 X =10 L = 50 C = 100 D =
Integer.reverse(int)反转的原理
大新博客
08-07 4997
Integer有一个静态方法用于反转底层二进制数组public static int reverse(inti)； System.out.println(Integer.reverse(886)); 得到的值为1858076672 下面给出886的二进制数据 （00000000000000000000‬）‭0011 0111 0110‬ 下面给出1858076672的二进制数据 ...
结果是这样的，没有根据id排：start_date end_date 0 2020-01-15 2020-04-27 1 2020-09-30 2020-10-10 2 2021-02-07 2021-02-22 3 2021-03-06 2021-03-24 4 2020-01-21 2020-03-03 .. ... ... 639 2021-03-09 2021-03-18 640 2021-03-24 2021-04-01 641 2020-01-12 2020-04-19 642 2021-02-09 2021-02-18 643 2020-01-18 2020-03-09
最新发布
06-03
如果你想根据企业id对结果进行排序，可以在输出结果之前加上一行代码： ```python result = result.sort_values(by=['id']) ``` 此代码将会根据id对结果进行排序，使得每个企业的结果排在一起。完整的代码如下： ```python mean = DataFrame.groupby(['id'])['amount'].mean() # 列出每个企业用电量低于均值时间超过一周的时间段，标记起始时间和结束时间，省略中间时间 filtered_data = DataFrame[DataFrame['amount'] < DataFrame['id'].map(mean)] filtered_data['date'] = pd.to_datetime(filtered_data['date']) filtered_data['diff'] = filtered_data.groupby('id')['date'].diff().dt.days filtered_data['period'] = (filtered_data['diff'] > 1).cumsum() # 找出连续时间段，并计算起始时间和结束时间 result = filtered_data.groupby(['id', 'period']).agg(start_date=('date', 'min'), end_date=('date', 'max')) result = result[result['end_date'] - result['start_date'] > pd.Timedelta(days=7)].reset_index(drop=True) # 根据id排序输出结果 result = result.sort_values(by=['id']) print(result) ``` 输出结果将会按照企业id进行排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值