leedcode做题汇总

最新推荐文章于 2024-08-09 09:36:32 发布

龙虎w

最新推荐文章于 2024-08-09 09:36:32 发布

阅读量104

点赞数

分类专栏：学习文章标签： python java c++ node.js

本文链接：https://blog.csdn.net/weixin_43563417/article/details/108603427

版权

学习专栏收录该内容

24 篇文章 0 订阅

订阅专栏

1.PYTHON

#给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if s=="":
            return 0;
        answer=1;
        sLen=len(s);
        initIndex=0;
        while sLen-initIndex>answer:
            for i in range(initIndex+1,sLen):
                if s[initIndex:i].find(s[i])==-1:
                    if i-initIndex+1>answer:
                        answer= i-initIndex+1;
                    else:
                        answer=answer;
                else:
                    initIndex+=s[initIndex:i].find(s[i])+1;
                    break;
        return answer;

# 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
# 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        answer=[0,0];
        numsLen=len(nums);
        for firstIndex in range(numsLen):
            if firstIndex+1!=numsLen:
                for secondIndex in range(firstIndex+1,len(nums)):
                    if nums[secondIndex]+nums[firstIndex]==target:
                        answer[0]=firstIndex;
                        answer[1]=secondIndex;
        return answer;

### 解题思路
此处撰写解题思路
1.核心：将nums2按正序插入到nums1中，最后返回值，
        如果m+n是偶数返回的是中间两个数的平均值，否则直接返回中间那个数
2.步骤：
    1.首先解决数组为空的情况，
    2.创建两个变量，分别作为标签，记录两个数组分别比较到哪一个了
    3.当前索引到的nums1的值小于等于nums2怎么做
        1.是不是nums1最后面那个，就是最大的那个数，
        2.是的话，可以将nums2后面的全部按序插入nums1末尾
        3.不是的话，nums1向后索引1个位置，重新比较
    4.当前索引到的nums1的值大于nums2怎么做，且不是nums1的第一个值
        1.nums1的前一个数是否小于nums2
        2.是的话，将nums2当前值插入nums1当前位置
        3.不是，nums1的索引向前索引一个位置，重新比较
    5.nums1的第一个值大于nums2，将当前nums2的值插入nums1,且两个数组都索引标签+1

### 代码

```python3
class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        m=len(nums1)
        n=len(nums2)
        mider=(m+n)/2
        index=int(mider)
        if m==0:
            if index<mider:
                return nums2[index]
            else:
                return (nums2[index]+nums2[index-1])/2
        if n==0:
            if index<mider:
                return nums1[index]
            else:
                return (nums1[index]+nums1[index-1])/2
        mi=0
        ni=0
        while ni<n:
            if nums1[mi]<=nums2[ni]:
                if mi+1 ==len(nums1):
                    while ni<n:
                        nums1.insert(len(nums1)+1,nums2[ni])
                        ni+=1
                mi+=1
                continue
            while mi>0:
                if nums1[mi-1]>nums2[ni]:
                    mi-=1
                    continue
                nums1.insert(mi,nums2[ni])
                mi+=1
                ni+=1
                break
            if mi==0:
                nums1.insert(mi,nums2[ni])
                mi+=1
                ni+=1
        if index<mider:
            return nums1[index]
        else:
            return (nums1[index]+nums1[index-1])/2

1.核心：首先匹配出两个相同的字母，再利用递归函数处理，字符串中某字母有多个相同的字母的情况
2.步骤：
2.1还是先处理字符串为空和只有一个字母的情况
2.2开始遍历字符串，获得字符a
2.3匹配和他相同的但索引位置不同的另一个字符
2.4无则执行下一次循环
2.5有，则要判断，这以这两个字符作为端点，是否比已有的最长回文字符串长
2.6更短，就执行下一次循环
2.7更长，就去判断是否是回文字符串
2.8是，则更新最长回文字符串
2.9否，则去掉这个尾端，找到一个更短的尾端，通过递归函数回到2.5
2.10递归函数返回两个值，一个是suc（=0代表不是当前最长回文字符串，=1代表是当期最长的回文字符串）；另一个是尾端字符的索引
2.11更新最长回文字符串
2.12每次循环末尾判断剩余字符串长度是否比已有最长回文字符串上，否的话就可以直接结束遍历了。


def confirmIF(s,sindex,eindex,ResultL):
    if s[sindex:eindex+1]==s[sindex:eindex+1][::-1]:
        return 1,eindex
    secondeindex=s.rfind(s[sindex],sindex,eindex)
    if secondeindex-sindex>=ResultL:
        return confirmIF(s,sindex,secondeindex,ResultL)
    return 0,eindex
class Solution:
    def longestPalindrome(self, s: str) -> str:
        strl=len(s)
        if strl==0 or strl==1:
            return s
        resultL=1
        resStaindex=0
        resEndindex=0
        suc=0
        for i in range(strl):
            staIndex=i
            endIndex=s.rfind(s[i],staIndex)
            tempL=endIndex-staIndex
            if tempL>=resultL:
                suc,ResEndindex=confirmIF(s,staIndex,endIndex,resultL)
            if suc==1:
                resStaindex=i
                resEndindex=ResEndindex
                resultL=ResEndindex-i+1
                suc=0
            if resultL>=strl-i:
                break             
        result=s[resStaindex:resEndindex+1]
        return result

解题思路
核心：获取字符串在Z字数组中的行索引值，将行索引值和字符串里字符的本身索引值联合排序，就能得到新字符串的输出顺序了，列索引值没必要知道，因为列索引的大小排序顺序和字符串里字符的本身索引值排序是一样的。
1.一如既往，将最简单的情况先解决掉，即输出和输入一样的的情况
2.本来使用numpy来创建数组，但他会占用15MB左右的内存空间
3.创建一个sL(字符串长度)*2的索引数组，第一列存储本身的索引，第二列存储在Z字数组中的行索引
4.direct代表此时字符串是在按列向下添加字符，还是向上
5.最后按行输出即可

代码

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        sL=len(s)
        if sL<=numRows or numRows==1:
            return s
        result=''
        index = [None]*sL
        for i in range(sL):
            index[i] = [0]*2
        yindex=0
        direct=0
        for i in range(1,sL):
            if yindex==numRows-1:
                direct=1
            if yindex==0:
                direct=0
            if direct==1:
                yindex-=1
            else:
                yindex+=1
            index[i]=[i,yindex]
        for yi in range(numRows):
            for i in range(sL):
                if index[i][1]==yi:
                    result+=s[i]
        return result

2.C++

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
class Solution {
public:
    int reverse(int x) {
        int result=0;
        while(x!=0){
            if (result > INT_MAX/10 ||(result == INT_MAX/10&&x>7)||result < INT_MIN/10||(result == INT_MIN/10&&x>8)){result = 0;break;}
            result=result*10+x%10;
            x=x/10;
        }
        return result;
    }
};

### 解题思路
此处撰写解题思路

### 代码

```cpp
class Solution {
public:
    int myAtoi(string str) {
        int result=0;
        int signal=0;
        int p=0;
        for(char c :str){
            if(c==' '&&signal==0){
                p=0;
            }
            else if(c==45&&signal==0){
                signal=1;
            }
            else if(c==43&&signal==0){
                signal=2;
            }
            else if(isdigit(c)){
                p=c-'0';
                if(signal==0){
                    signal=2;
                }
            }
            else{return result;}
            if (result > INT_MAX/10 ||(result == INT_MAX/10&&p>7)){
                return INT_MAX;
            }
            if(result < INT_MIN/10||(result == INT_MIN/10&&p>8)){return INT_MIN;}

            if(signal==1){
                result=result*10-p;
            }
            else{
                result=result*10+p;
            }

        }
        return result;
        }
};

**3.**

```cpp
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int lenl1=0;
        int lenl2=0;
        ListNode* p=l1;
        ListNode* q=l2;
        while(p->next!=NULL){lenl1++;p=p->next;}
        while(q->next!=NULL){lenl2++;q=q->next;}
        while(lenl1!=lenl2){
            if(lenl1>lenl2){
                q->next=new ListNode(0);
                q=q->next;
                lenl2++;
            }
            else{
                p->next=new ListNode(0);
                p=p->next;
                lenl1++;
            }
        }
        int carryBit=0;
        ListNode* Rresult=new ListNode(0);
        ListNode* result=Rresult;
        int tempVal=0;
        while(l1!=NULL){
            result->next=new ListNode(0);
            result=result->next;
            tempVal=l1->val+l2->val+carryBit;
            if(tempVal<10){result->val=tempVal;carryBit=0;}
            else{
                result->val=tempVal-10;
                carryBit=1;
            }
            l1=l1->next;
            l2=l2->next;
        }
        if(carryBit){
            result->next=new ListNode(0);
            result=result->next;
            result->val=carryBit;}
        return Rresult->next;
    }
};

### 解题思路
**首先负数返回false,然后进行整数的反转就可以了，最后判断反转之后两数是否相等**

### 代码

```cpp
class Solution {
public:
    int reverse(int x) {
        int result=0;
        while(x!=0){
            if (result > INT_MAX/10 ||(result == INT_MAX/10&&x>7)||result < INT_MIN/10||(result == INT_MIN/10&&x>8)){result = 0;break;}
            result=result*10+x%10;
            x=x/10;
        }
        return result;
    }
    bool isPalindrome(int x) {
        if(x<0){return false;}
        int y=reverse(x);
        if(x==y){return true;}
        return false;
    }
};