力扣刷题记录（1）

最新推荐文章于 2024-08-13 14:47:10 发布

盛夏在冰城

最新推荐文章于 2024-08-13 14:47:10 发布

阅读量70

点赞数

分类专栏： Leetcode刷题记录文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/weixin_51121822/article/details/133187123

版权

Leetcode刷题记录专栏收录该内容

1 篇文章 0 订阅

订阅专栏

力扣刷题记录

本系列文章仅做为小白刷题记录使用

文章目录

力扣刷题记录
前言
一、两数之和
二、字母异位
三、最长连续序列
四、合并连个有序数组
五、将有序数组转换为二叉搜索树
六、杨辉三角
七、杨辉三角 II

前言

23春招惨烈，由于本身代码基础较弱，没有接触过ACM训练，于是对该类笔试胆战心惊，刷题只为提升代码水平。从最基础的题型和简单模式开始。9.25-10.02

一、两数之和

题目：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个
整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。
https://leetcode.cn/problems/two-sum/description/

本人思路：暴力求解

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        sorted(nums)
        anser=[]
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if (nums[i]+nums[j])==target:
                    anser.append(i)
                    anser.append(j)
                    return anser

优质解答：利用了Python列表本身的特性，提高了寻找速度。

 # 遍历列表
        for i in range(len(nums)):
            # 计算需要找到的下一个目标数字
            res = target-nums[i]
                # 遍历剩下的元素，查找是否存在该数字
            if res in nums[i+1:]:
                # 若存在，返回答案。这里由于是两数之和，可采用.index()方法
                # 获得目标元素在nums[i+1:]这个子数组中的索引后，还需加上i+1才是该元素在nums中的索引
                return [i, nums[i+1:].index(res)+i+1]

作者：从前的我——再次回归
链接：https://leetcode.cn/problems/two-sum/solutions/1463966/jian-dan-python-by-chanemo-muld/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二、字母异位

给你一个字符串数组，请你将字母异位词组合在一起。可以按任意顺序返回结果列表。
字母异位词是由重新排列源单词的所有字母得到的一个新单词。
https://leetcode.cn/problems/group-anagrams/description/?envType=study-plan-v2&envId=top-100-liked

def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        l=len(strs)
        temp={}
        for i in range(l):
            b=strs[i]
            a=''.join(sorted(b))
            if a in temp: 
                temp[a].append(b)
            else:temp[a]=[b]
        return list(temp.values())

两个容易遗忘的点：1.在向答案字典序列添加成员时，添加的是列表成员，才可以使用append；2.在对字符串顺序排序以后，需要将其转换为字符串

三、最长连续序列

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
https://leetcode.cn/problems/longest-consecutive-sequence/description/?envType=study-plan-v2&envId=top-100-liked

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        maxl=0;
        number=set(nums)
        for num in nums:
            #查找前一个数是否在数列中
            if(num-1 not in number):
                #如果不在，当前序列的长度则为1，当前数字是首位
                lenth=1
                #查找当前数字的后序数字
                while (num+1) in number:
                    lenth=lenth+1
                    num+=1
                maxl=max(maxl,lenth)
        return maxl

四、合并连个有序数组

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

//本题使用c更清晰好些一些；使用三指针尾插法，同时移动指针可加快合并速度，遍历一次即可完成
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
   int j=n-1, index=m+n-1,i=m-1;
    while(i>-1&&j>-1)
        {
          if(nums1[i]<nums2[j])
            {
                nums1[index]=nums2[j];
                j--;
                index--;
            }
            else 
            {
                nums1[index]=nums1[i];
                i--;
                index--;
            }}
            while(i>=0)nums1[index--]=nums1[i--];
            while(j>=0)nums1[index--]=nums2[j--];
            
            }

Python题解：在评论区看到的是直接复制数组nums2之后，使用sort函数，经大佬分析sort以后仍然满足时间限制。

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        nums1[m:] = nums2
        nums1.sort()
        return 

作者：_G_
链接：https://leetcode.cn/problems/merge-sorted-array/solutions/2385510/shu-zu-zhi-jie-he-bing-hou-pai-xu-by-adm-8405/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

五、将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵高度平衡二叉搜索树。

高度平衡二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/description/

经典递归思路：保证构造出来的树左右都是平衡二叉树，就要保证每一棵子树均为平衡二叉树。每次使用中间的元素作为根节点（题目表示已经升序），则在构造完成后能返回一棵平衡二叉树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return created(nums,0,nums.size()-1);

    }

    TreeNode* created(vector<int>& nums,int left ,int right)
    {
        if(left>right){
            return nullptr;
        }
        int mid=(left+right)/2;
        TreeNode* root=new TreeNode(nums[mid]);
        root->left=created(nums,left,mid-1);
        root->right=created(nums,mid+1,right);
        return root;
    }
};

评论区的简洁写法：
struct TreeNode* sortedArrayToBST(int* nums, int numsSize){
    if (NULL == nums || numsSize == 0) return NULL;

    int middle = numsSize / 2;
    struct TreeNode *ret = malloc(sizeof(struct TreeNode));
    ret->val = nums[middle];
    ret->left = sortedArrayToBST(nums, middle);
    ret->right = sortedArrayToBST(nums + middle + 1, numsSize - middle - 1);

    return ret;
}

六、杨辉三角

除了第一行，其余每行的第一个和最后一个元素均为1，并且每行的元素个数是元素
行号+1，得出当前元素值与上一行元素位置的关系后，两层循环可求出。

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> anser(numRows);
            for(int i=0;i<numRows;i++){
                anser[i].resize(i+1);
                anser[i][0]=1;
                for(int j=1;j<i;j++)
                    anser[i][j]=anser[i-1][j-1]+anser[i-1][j];            
                    anser[i][i]=1;
                }
                
        return anser;
        
    }
};

评论区用动态规划的大佬写的代码：
class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> dp(numRows);
        if (numRows >= 1) dp[0].emplace_back(1);
        if (numRows >= 2) {
            dp[1].emplace_back(1);
            dp[1].emplace_back(1);
        }
        for (int i = 2; i < numRows; ++i) {
            dp[i].emplace_back(1);
            for (int j = 1; j <= i - 1; ++j) {
                dp[i].emplace_back(dp[i - 1][j] + dp[i - 1][j - 1]);
            }
            dp[i].emplace_back(1);
        }
        return dp;
    }
};

作者：不想再打铁
链接：https://leetcode.cn/problems/pascals-triangle/solutions/2083039/dong-tai-gui-hua-qing-song-qiu-chu-by-ki-tsqr/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

七、杨辉三角 II

给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。https://leetcode.cn/problems/pascals-triangle-ii/

class Solution {
public:
    vector<int> getRow(int rowIndex) {
    vector<vector<int>> anser(rowIndex+1);
            for(int i=0;i<rowIndex+1;i++){
                anser[i].resize(i+1);
                anser[i][0]=1;
                for(int j=1;j<i;j++)
                    anser[i][j]=anser[i-1][j-1]+anser[i-1][j];            
                    anser[i][i]=1;
                }
                
        return anser[rowIndex];
    }
};