leetcode 刷题笔记1-5

最新推荐文章于 2024-08-31 00:26:34 发布

素筒肠

最新推荐文章于 2024-08-31 00:26:34 发布

阅读量260

点赞数

分类专栏： leetcode 文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_41706166/article/details/89638586

版权

leetcode 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

本文详细记录了LeetCode前五个问题的解题思路，包括暴力法、哈希优化和滑动窗口等算法，涵盖C++和C语言实现，探讨了时间复杂度和空间复杂度的优化。

摘要由CSDN通过智能技术生成

leetcode 刷题笔记1-5

浑浑噩噩过了好久，刷一刷leetcode吧，创了个博客也写一下思路，也督促自己多刷一点，以前没经过系统训练，希望大佬们多多指点。

1

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思路1
首先想到的思路就是暴力遍历法，遍历每一个元素，查找该元素后面的元素是否满足条件。

c代码

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
#include<stdlib.h>
int* twoSum(int* nums, int numsSize, int target) {
    int i = 0;
    int j = 1;
    int *result = (int *)malloc(2 * sizeof(int));
    for (j = 1; j < numsSize; j++)
    {
        for (i = 0; i < j; i++)
        {
            if (nums[i] + nums[j] == target)
            {
                result[0] = i;
                result[1] = j;
                return result;
            }
        }
    }
    return 0;
}

时间复杂度为 $O(n^2)$ ，空间复杂度为 $O (1)$ 。

思路2
运用hash思想，第一次将数组中每个数字和序号存入map，第二次遍历hash，查询每个值的目标元素是否在map中。
c++代码

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        int size = nums.size();
        map<int, int> myMap;
        vector<int> arr;
        for (int i = 0; i < size; i++)
        {
            myMap[nums[i]] = i;
        }
        for (int i = 0; i < size; i++)
        {
            map<int, int>::iterator iter;
            iter = myMap.find(target - nums[i]);
            if (iter != myMap.end())
            {
                if (iter->second != i)
                {
                    arr.push_back(i);
                    arr.push_back(iter->second);
                    return arr;
                }
            }
        }
        return arr;
    }
};

时间复杂度为 $O (n)$ ，空间复杂度为 $O (n)$ 。
思路3
其实和思路二差不多，只是使用一遍哈希，把上面两步哈希的工作放到一步中，在将元素插入表中的同时查找表中是否存在当前元素的目标元素。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        int size = nums.size();
        map<int, int> myMap;
        vector<int> arr;
        for (int i = 0; i < size; i++)
        {
            map<int, int>::iterator iter;
            iter = myMap.find(target - nums[i]);
            if (iter != myMap.end())
            {
                if (iter->second != i)
                {
                    arr.push_back(iter->second);
					arr.push_back(i);
					return arr;
                }
            }
            myMap[nums[i]] = i;
        }
        return arr;
    }
};

时间复杂度为 $O (n)$ ，空间复杂度为 $O (n)$

2

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

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

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

示例

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

思路1
第一反应是分别把两个数表示出来，然后返回直接相加。。。。。，结果好像因为数太大溢出了，还是贴一下代码。

/**
 * 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 nums1 = 0;
        int nums2 = 0;
        ListNode *result = NULL;
        ListNode *p = result;
        int ans;
        ListNode *ptr1 = l1;
        ListNode *ptr2 = l2;
        int i = 1;
        while (ptr1 != NULL)
        {
            nums1 += i * (ptr1->val);
            ptr1 = ptr1->next;
            i *= 10;
        }
        i = 1;
        while (ptr2 != NULL)
        {
            nums2 += i * (ptr2->val);
            ptr2 = ptr2->next;
            i *= 10;
        }
        ans = nums1 + nums2;
        while (ans >= 1)
        {
            int n = ans % 10;
            ans /= 10;
            if (result == NULL)
            {
                result = new ListNode(n);
                p = result;
            }
            else
            {
                p->next = new ListNode(n);
                p = p->next;
            }
        }
        return result;
    }
};

思路2
思路二就是按照小学里老师教我们加法竖式的方法，只不过左右相反，从左往右相加，大于10就往后进1。可以用一个bool型变量flag表示是否进位，注意在循环最后如果flag为真还要再加上1。

/**
 * 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) 
    {
        ListNode *result = NULL;
        ListNode *p;
        ListNode *ptr1 = l1;
        ListNode *ptr2 = l2;
        bool flag = false;
        while(ptr1 != NULL || ptr2 != NULL)
        {
            int a, b, sum;
            if (ptr1 != NULL)
            {
                a = ptr1->val;
            }
            else
            {
                a = 0;
            }
            if (ptr2 != NULL)
            {
                b = ptr2->val;
            }
            else
            {
                b = 0;
            }
            sum = a + b;
            if (flag)
            {
                sum += 1;
            }
            flag = sum / 10;
            if (result == NULL)
            {
                result = new ListNode(sum % 10);
                p = result;
            }
            else
            {
                p->next = new ListNode(sum % 10);
                p = p->next;
            }
            if (ptr1 != NULL)
            {
                ptr1 = ptr1->next;
            }
            if (ptr2 != NULL)
            {
                ptr2 = ptr2->next;
            }
        }
        if (flag)
        {
            p->next = new ListNode(1);
        }
        return result;
    }
};

时间复杂度为 $O (m a x (m, n))$ ，空间复杂度为 $O (m a x (m, n))$ 。

3

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

思路1
第一种思路还是我最喜欢的暴力法，先写一个判定函数，判定一个字符串中是否存在重复字符，然后从第一个字符开始，向后遍历，对该字符串每一个子串进行判定，得到最大子串长度（完全没有想。。。然后需要三个大循环 $O(n^3)$ 的时间复杂度。。。然后超时了）。

class Solution {
public:
    int lengthOfLongestSubstring(string s)
    {
        int len = s.size();
        int res = 0;
        if (len == 1)
        {
            return 1;
        }
        for (int i = 0; i < len; i++)
        {
            for (int j = i + 1; j < len + 1; j++)
            {
                int max_t = 0;
                string stmp(s.begin() + i,s.begin() + j);
                bool isUniq = isUnique(stmp);
                if (isUniq == true)
                {
                    max_t = stmp.size();
                    if (res < max_t)
                    {
                        res = max_t;
                    }
                }
            }
        }
        return res;
    }
    
    bool isUnique(string s)
    {
        int size = s.size();
        for (int i = size - 1; i > 0; i--)
        {
            string strtmp (s, 0, i);
            string::size_type postion = strtmp.find(s[i]);
            if (postion != string::npos)
            {
                return false;
            }
        }
        return true;
    }
};

思路2
思路二我们试着优化一下思路一的算法，首先我们还是通过一次大循环，来遍历子串的首字符索引i，然后用j遍历子串的末字符后一位索引，如果 $s [j]$ 不存在于 $s [i, j]$ 中，则j加1，如果存在，则直接跳出循环。

class Solution {
public:
    int lengthOfLongestSubstring(string s)
    {
        int len = s.size();
        int res = 0;
        for (int i = 0; i < len; i++)
        {
            int t_tmp = 1;
            for (int j = i + 1; j < len; j++)
            {
                string stmp(s.begin() + i, s.begin() + j);
                if (stmp.find(s[j]) != string::npos)
                {
                    break;
                }
                t_tmp++;
            }
            if (res < t_tmp)
            {
                res = t_tmp;
            }
            if (res + i >= len)
            {
                break;
            }
        }
        return res;
    }
};

思路3
思路二虽然通过了，但是时间空间复杂度还是较大，思路三使用了滑窗的思路。相当于指定头索引i，尾索引j，使j向后遍历，如果s[j]的字符在s[i-j]中存在，则将i子串中前一个重复的字符去掉，始终保证是无重复子串。

class Solution 
{
    public:
    int lengthOfLongestSubstring(string s)
    {
        int size = s.size();
        int i = 0;
        int j = 1;
        int res = 0;
        if (size == 1)
        {
            return 1;
        }
        while(j <= size)
        {
            string strtmp(s.begin() + i, s.begin() + j);
            if (strtmp.find(s[j]) != string::npos)
            {   
                i = i + strtmp.find(s[j]) + 1;   
            }
            j++;
            if (res < strtmp.size())
            {
                res = strtmp.size();
            }
        }  
    return res;
    }
};

4

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

思路1
思路一暂时不考虑时间复杂度的要求，看到题目直觉上就是使用归并算法的思想，首先新建一个数组，依次两个有序数列的第一个数，将小的数放入新建的数组，排序后按数组总长度的奇偶分类计算中位数。

class Solution {
public:
	double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2) 
	{
		vector<int> arr;
		int l = 0, r = 0;
		while (arr.size() < nums1.size() + nums2.size())
		{
			if (r >= nums2.size())
			{
				arr.push_back(nums1[l++]);
			}
			else if (l >= nums1.size())
			{
				arr.push_back(nums2[r++]);
			}
			else if (nums1[l] > nums2[r])
			{
				arr.push_back(nums2[r]);
				r++;
			}
			else
			{
				arr.push_back(nums1[l]);
				l++;
			}
		}
		if (arr.size()%2)
		{
			return arr[arr.size() / 2];
		}
		else
		{
			return ((double)arr[arr.size() / 2] + arr[arr.size() / 2 - 1]) / 2;
		}
	}
};

思路2
思路2是借鉴了评论区大神的想法，中位数之前，之后分别有tot = (n+m-1)/2个数，我们假设这tot个数的分布情况为nums1中的前p个，和nums2中的前tot-p个。因为中位数大于每一个他前面的数，所以，如果nums1中的第p+1个数小于nums2中的第tot-p个数，则说明p过小。使用二分法寻找p即可。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size(), m = nums2.size();
        if(!n && !m) return 0.0;
        int pos = (n + m - 1) >> 1;
        int l = max(0, pos - m), r = min(pos, n);
        while(l < r){
            int mid = (l + r) >> 1;
            if(nums1[mid] < nums2[pos - mid - 1])
                l = mid + 1;
            else r = mid;
        }
        if((n + m) & 1) {
            if(l >= n) return nums2[pos - l];
            if(pos - l >= m) return nums1[l];
            if(nums1[l] < nums2[pos - l]) return nums1[l];
            return nums2[pos - l];
        }else{
            if(l >= n) return 0.5 * (nums2[pos - l] + nums2[pos - l + 1]);
            if(pos - l >= m) return 0.5 * (nums1[l] + nums1[l + 1]);
            if(pos - l + 1 < m && nums1[l] > nums2[pos - l + 1])
                return 0.5 * (nums2[pos - l] + nums2[pos - l + 1]);
            else if(l + 1 < n && nums2[pos - l] > nums1[l + 1])
                return 0.5 * (nums1[l] + nums1[l + 1]);
            else return 0.5 * (nums1[l] + nums2[pos - l]);
        }
    }
};

5

给定一个字符串s，找到s中最长的回文子串。你可以假设  s的最大长度为1000。

输入： “babad”
 输出： “bab”
 注意： “aba”也是一个有效答案。

输入： “cbbd”
 输出： “bb”

思路1
依旧是暴力法，写出所有可能的子串，然后计算是否回文，有时候会超时。

class Solution {
public:
	string longestPalindrome(string s) {
		if (s == "")
		{
			return s;
		}
		string temp;
		int size = s.size();
		for (int len = size; len > 0; len--)
		{	
			for (int i = 0; i <= size - len; i++)
			{
				if (s[i] != s[len + i - 1])
				{
					continue; 
				}
				temp = s.substr(i, len);
				string revtemp = temp;
				reverse(revtemp.begin(), revtemp.end());
				if (temp == revtemp)
				{
					return temp;
				}
			}
		}
		return "";
	}
};

思路2
思路二是使用中心扩展法的思想.

class Solution {
public:
	string longestPalindrome(string s) {
		if (s == "" || s.size()== 1)
		{
			return s;
		}
		int size = s.size();
		int start = 0;
		int max = 1;
		int len1 = 0, len2 = 0;
		int len = 0;
		for (int i = 0; i < size; i++)
		{
			len1 = retRomeLen(s, i, i);
			len2 = retRomeLen(s, i, i + 1);
			len = len1>len2 ? len1 : len2;
			if (len > max)
			{	
				max = len;
				start = i - (len-1) / 2;
			}
		}
		
		return s.substr(start, max);
	}
	int retRomeLen(string s, int left, int right)
	{
		while (left >= 0 && right < s.size() && s[left] == s[right] )
		{	
			left--;
			right++;
		}
		return right - left -1;
	}
};

素筒肠

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode 刷题笔记1-5

leetcode 刷题笔记1-5123浑浑噩噩过了好久，刷一刷leetcode吧，创了个博客也写一下思路，也督促自己多刷一点，以前没经过系统训练，希望大佬们多多指点。1给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。示例给定 nu...
复制链接

扫一扫