qxwithlsy-CSDN博客

原创 2021-03-14

628.三个数的最大乘积分析讨论各种情况，可以知道，最大乘积要么是前三个数的乘积，要么是第一个数和最后两个数的乘积。class Solution(object): def maximumProduct(self, nums): """ :type nums: List[int] :rtype: int """ # 如果一共只有三个数 # prod=1 if(len(nums)==3):

2021-03-14 11:21:19 93

原创 2021-01-25

1. 每日一题–959 由斜杠划分区域连通或连通块的问题可以使用BFS或者DFS或者并查集解决。class Solution(object): def regionsBySlashes(self, grid): """ :type grid: List[str] :rtype: int """ #并查集 n=len(grid) self.count=4*n*n pare

2021-01-26 15:48:24 83

725.分隔链表（1）向上取整/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; *//** * Note: The returned array must be malloced, assume caller calls free(). */struct ListNode** splitListToParts(s

2020-07-29 00:01:36 125

原创 20200725,0726

1019.链表中的下一个更大节点（1）两层循环/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; *//** * Note: The returned array must be malloced, assume caller calls free(). */int* nextLargerNodes(struct

2020-07-26 23:42:48 97

原创 20200724

1.剑指offer 24.反转链表（1）双指针/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* reverseList(struct ListNode* head){ struct ListNode* temp=NULL,*cur=NULL; while(head)

2020-07-24 23:29:48 94

原创 20200721

445. 两数相加21.我的笨办法，先反转链表，然后两数相加，然后反转链表/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* reverseList(struct ListNode* l){ struct ListNode* temp=NULL; struct List

2020-07-24 17:00:07 89

原创 20200723

143.重排链表1.先用快慢指针找到链表中点，把后半部分链表反转，再合并两部分链表。/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* reverselist(struct ListNode* p){ //反转链表 struct ListNode* temp=NULL

2020-07-24 00:27:35 73

原创 83.删除排序链表中的重复元素

/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* deleteDuplicates(struct ListNode* head){ // 快的先去前一个检查是否有重复的，如果有的话就一直往后走，直到下一个数 struct ListNode* cur=head; wh

2020-07-20 23:31:09 65

原创面试题 02.06 回文链表

1.普通版把链表的每个值存储在数组中，然后从链表两端向中间挨个对比，如果有不等的，就返回false。/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */bool isPalindrome(struct ListNode* head){ //快慢指针？先找到中间位置，然后一个从中间开始，新建一个指针从头开始

2020-07-20 22:32:05 123

原创 2. 两数相加

1.顺着逻辑的思路将两个链表中的每个元素对应相加，要注意处理链表长度不同的情况，和需要进位但两个链表都已经同时走完的情况。/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2)

2020-07-19 18:14:29 84

原创 86. 分隔链表

本来想用快慢指针做的，就像面试题02.04，交换节点的值，但是这样不能保证每个结点的初始相对位置，于是就只能构造两个链表large和small，分别存放大于x的节点和小于x的节点，再把两个链表拼接起来。/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* partition(struct

2020-07-18 15:42:35 79

原创剑指offer06. 从尾到头打印链表

1.常规做法/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; *//** * Note: The returned array must be malloced, assume caller calls free(). */int* reversePrint(struct ListNode* head, int*

2020-07-18 14:19:59 116

原创 142. 环形链表

快慢指针，好像和之前的某道题相似/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode *detectCycle(struct ListNode *head) { // 快慢指针 struct ListNode *fast=head; struct ListNode .

2020-07-17 23:53:51 89

原创 1367. 二叉树中的列表

递归法：1./** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; *//** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNo

2020-07-17 23:20:54 131

原创 82.删除排序链表中的重复元素

1.创建一个新的头结点newhead，在head之前，便于删除开始的重复元素。提前一步检测后面两个元素是否是一样的。/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */struct ListNode* deleteDuplicates(struct ListNode* head){ if(head==NULL

2020-07-16 23:17:07 78

原创 1171.从链表中删去总和值为零的连续节点

1.用一个字典存储前缀和，如果两个节点对应的前缀和相同，那么他们之间的节点总和值为零。首先遍历一遍链表，把所有的前缀和存起来，第二遍遍历，找当前前缀和对应的节点。# Definition for singly-linked list.# class ListNode(object):# def __init__(self, x):# self.val = x# self.next = Noneclass Solution(object): def

2020-07-14 22:54:31 186

原创 138.复制带随机指针的链表

1.用一个字典visited来存储已经复制过的节点。拷贝旧链表的next和random"""# Definition for a Node.class Node: def __init__(self, x, next=None, random=None): self.val = int(x) self.next = next self.random = random"""class Solution(object): def __

2020-07-14 00:06:11 99

原创面试题02.04 分割链表

1.分成两个链表，超出时间限制了# Definition for singly-linked list.# class ListNode(object):# def __init__(self, x):# self.val = x# self.next = Noneclass Solution(object): def partition(self, head, x): """ :type head: ListNo

2020-07-10 18:13:38 234

原创面试题 02.08 环路检测

1.首先想到用集合来做，直接判断下一个节点是否已经在集合中，那么能不能用双指针来做呢？# Definition for singly-linked list.# class ListNode(object):# def __init__(self, x):# self.val = x# self.next = Noneclass Solution(object): def detectCycle(self, head): """

2020-07-10 16:34:59 126

原创 237.删除链表中的节点

1.不是双向链表，所以就把要删除的节点和下一个节点做替换# Definition for singly-linked list.# class ListNode(object):# def __init__(self, x):# self.val = x# self.next = Noneclass Solution(object): def deleteNode(self, node): """ :type no

2020-07-10 14:59:23 124

原创 328.奇偶链表

1.把链表分成奇数节点组成的链表和偶数节点组成的链表，把偶数链表的头接在奇数链表的尾巴上。我想到了这个方法，但是实现的时候不会操作o(╥﹏╥)o指针和链表学的真菜，再复习一下吧# Definition for singly-linked list.# class ListNode(object):# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass

2020-07-09 17:34:16 114

原创面试题02.02 返回倒数第k个节点

1.我只想到了一个最直白的办法┭┮﹏┭┮# Definition for singly-linked list.# class ListNode(object):# def __init__(self, x):# self.val = x# self.next = Noneclass Solution(object): def kthToLast(self, head, k): """ :type head: Li

2020-07-09 16:27:44 179

原创面试题02.07链表相交

1.暴力求解# Definition for singly-linked list.# class ListNode(object):# def __init__(self, x):# self.val = x# self.next = Noneclass Solution(object): def getIntersectionNode(self, headA, headB): """ :type head1,

2020-07-09 12:33:45 176

原创字节跳动一面凉经

昨天参加了字节的后端实习生一面，果然透心凉。问了我的项目经历然后是死锁的条件怎么避免死锁mysql主键和唯一索引的区别进程共享数据？代码是让我写最右匹配，懵了，唉暑假一定好好刷leetcode...

2020-07-09 11:17:45 211

原创 Cannot uninstall ‘SQLAlchemy‘. It is a distutils installed project

安装jqdatasdk的时候遇到的问题：Cannot uninstall ‘SQLAlchemy’. It is a distutils installed project and thus we cannot accurately determine which files belong to it which would lead to only a partial uninstall.解决方法：强制升级pip install --ignore-installed SQLAlchemy...

2020-07-09 11:13:49 211

原创 leetcode 476 数字的补数

class Solution(object): def findComplement(self, num): """ :type num: int :rtype: int """ # 求二进制数 binary=[] if(num==0): return 1 if(num>0): i=0 while

2020-06-20 23:07:10 92

原创 leetcode1262可被三整除的最大和

动态规划，有一个知识盲区class Solution(object): def maxSumDivThree(self, nums): """ :type nums: List[int] :rtype: int """ # 动态规划的思想，不太懂啊。。。 dp=[0,0,0] for i in range(len(nums)): mod=nums[i]%3

2020-06-14 23:10:57 213

原创 leetcode845数组中的最长山脉

class Solution(object): def longestMountain(self, A): """ :type A: List[int] :rtype: int """ # 想法：一个用来记录左边山底，一个用来记录山顶，一个用来记录右边山底 left=0 top=left right=top maxlength=0 while

2020-06-13 23:53:28 121

原创 leetcode58左旋转字符串

class Solution(object): def reverseLeftWords(self, s, n): """ :type s: str :type n: int :rtype: str """ # 把后面的放到前面来 liststr=list(s) objectstr='' objectstr=objectstr+s[n:len(s)]+s[0

2020-06-10 18:06:59 86

原创 leetcode165比较版本号

class Solution(object): def compareVersion(self, version1, version2): """ :type version1: str :type version2: str :rtype: int """ # 不一定只有4级，以长的那级为准 sp1=version1.split('.') sp2=version2.spl

2020-06-09 23:25:18 144

原创 leetcode1432.改变一个整数能得到的最大差值

菜鸡版：class Solution(object): def maxDiff(self, num): """ :type num: int :rtype: int """ # 要得到最小值，如果第一位不是1，那么就把第一位换成1。如果是1，从第二位开始检查，把最高位非0且非1的数字都替换为0，判断是否为0，如果为0，则替换为1 # 要得到最大值，把最高位的数变成9 str_num=s

2020-06-08 13:29:59 166

原创 leetcode1375灯泡开关三

傻兮兮地每个都判断一次class Solution(object): def numTimesAllBlue(self, light): """ :type light: List[int] :rtype: int """ # 就是判断某个时刻k，light[0:k+1]是否包含了[1:k+1] count=0 for i in range(len(light)):

2020-06-07 23:00:33 179

原创 leetcode7整数反转

还是用python写的，我发现用了这些更方便的语言之后，就不怎么动脑子想怎么一个一个拆了，我记得以前学c的时候，遇到这个问题，好像是通过不断取模来得到每一位数的。先放我的菜鸡版本：class Solution(object): def reverse(self, x): """ :type x: int :rtype: int """ list_x=list(str(abs(x))) list_x.r

2020-06-06 22:25:09 116

原创 1两数之和

class Solution(object): def twoSum(self, nums, target): """ :type nums: List[int] :type target: int :rtype: List[int] """ for i in range(len(nums)): for j in range(len(nums)):

2020-06-04 10:21:13 109

原创 811子域名访问计数

信心满满地提交了答案，结果在一个巨巨巨巨巨巨巨巨巨长的用例上出错了，看得我眼睛要瞎了，草（一种植物）class Solution: def subdomainVisits(self, cpdomains: List[str]) -> List[str]: domain={} for i in range(len(cpdomains)): count, full_domain=cpdomains[i].split(" ")

2020-06-03 19:49:22 115

原创 leetcode1436旅行终点站

把起点存储到了一个列表，然后判断终点有没有在这个列表里面，如果没有就返回。begin=[]for path in paths: begin.append(path[0])for path in paths: if path[1] not in begin: return path[1]本来想求一下这个paths的长度，但是好像不行，一会儿研究一下。学习一下大佬们的技术。用python的大佬set，利用集合差，起点放在setA，终点放在setB，setB-set

2020-06-02 16:08:34 241

原创 leetcode1431拥有最多糖果的孩子

load of null pointer of type ‘_Bool’ (Serializer.c)错误片段：bool result[candiesSize];错误原因：要求返回的是bool*解决方案：指针使用malloc分配空间bool* result=(bool* )malloc(sizeof(bool)*candiesSize);然后又出现了问题===================================================================4

2020-06-02 00:19:55 246 1

qxwithlsy的博客