leetcode 刷题笔记&心得【c++】【每日一题】

最新推荐文章于 2024-09-14 18:52:56 发布
最新推荐文章于 2024-09-14 18:52:56 发布
阅读量179 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guangjie2333/article/details/117674794
版权

第一题
vector 是一个int向量，添加元素： 向量名.push_back(被添加的元素)
c++ 获取数组元素数量用nums.size() 用 sizeof(nums)/sizeof(int) leetcode报错说内存消耗
map.count(Key)返回值为1或者0，1返回存在，0返回不存在

方法1：两个嵌套for
方法2：先将key-value 存入map （一个for），用targrt-nums[i]去判断该值是否在key中可以被找到（map.count,其实应该也是相当于一个for）。个人认为该方法还不如暴力来的好。
方法3： 一个map（不用添加元素）nums每一个元素都去map找是否有满足targrt-nums[i]的元素），这样map.count就不是在所有元素中遍历了，该方法的时间复杂度小于O(N2)。

第二题
我的代码是这样的，然而看了一下题解，发现我好菜啊，而且我的执行还不通过。
有的人简化了案例给出了一种解法更加简单明了。


/**
 * 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
        
        ListNode* result;
        ListNode* p;
        ListNode* p1;
        ListNode* p2;
        int max_count,i,j,k = 0;
        int* r1;//数组存放个位
        int* r2;//存放进位
        //声明递归函数

        
        //判断结果链表的长度
        p = l1;
        for(i = 0; p != NULL; i++)
        {
            p = p->next;
        }
        p = l2;
        for(j = 0; p != NULL; j++)
        {
            p = p->next;
        }
        max_count = i>j ? i:j;
        //计算result链表
        p = result;
        p1 = l1;
        p2 = l2;
        //搞定头节点
        p->next = (ListNode *)malloc(sizeof(ListNode));
        if(p1->val + p2->val >= 10)
        {
            p->val = p1->val + p2->val - 10;
            p->next->val = 1;
        }
        else
        {
            p->val = p1->val + p2->val ;
            p->next->val = 0;
        }
        //搞定其余节点
        for(k = 0;i<max_count+1;k++) //+1是避免最后两个相加进位
        {
            p = p->next;
            p1 = p1->next;
            p2 = p2->next;
            p->next = (ListNode *)malloc(sizeof(ListNode));
            if(p1 != NULL && p2 != NULL)
            {
                if(p1->val + p2->val + p->val >= 10)
                {
                    p->val = p1->val + p2->val + p->val- 10;
                    p->next->val = 1;
                }
                else
                {
                    p->val = p1->val + p2->val + p->val ;
                    p->next->val = 0;
                }
            }
            else
            {
                if(p1 != NULL)
                {
                    p->val = p->val + p1->val;
                }
                else
                {
                    p->val = p->val + p2->val;
                }
                p->next->val = 0;
            } 
        }   
        return result;
    }

};

/**别人的方法
 * 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* head=new ListNode(-1);//存放结果的链表
        ListNode* h=head;//移动指针
        int sum=0;//每个位的加和结果
        bool carry=false;//进位标志
        while(l1!=NULL||l2!=NULL)
        {
            sum=0;
            if(l1!=NULL)
            {
                sum+=l1->val;
                l1=l1->next;
            }
            if(l2!=NULL)
            {
                sum+=l2->val;
                l2=l2->next;
            }
            if(carry)
                sum++;
            h->next=new ListNode(sum%10);
            h=h->next;
            carry=sum>=10?true:false;
        }
        if(carry)
        {
            h->next=new ListNode(1);
        }
        return head->next;
    }
};

第三题
第三题是我花了两个晚上搞出来的，没看题解，就是不停的提交，修改逻辑然后实现了要求，第一次击败了那么多人。
在这里插入图片描述

#include "Solution.h"


int Solution :: lengthOfLongestSubstring(string s) {
    //声明变量
    const char* str;
    const char* head;
    const char* tail;
    const char* temp;
    int len = 0;
    int max_len = 0;
    bool flag = false;

    //类转char数组
    str = s.c_str();

    //实例化指针
    head = tail = temp = str;

    if (s.empty())
    {
        return 0; //字符串为空返回0
    }
    else
    {
        max_len = len = 1;//不空意味着至少有一个元素
        head = &str[0];
        tail = &str[1];
        while (*tail != '\0')
        {
            //看看新加入的元素是否和之前重复
            for (temp = head; temp < tail; )
            {
                if (*tail == *temp)
                {
                    flag = true; //发现重复项
                    break;
                }
                else
                {
                    temp++;//未发现重复项就自加
                }
            }

            if (flag)
            {
                flag = false;
                head = ++temp; //i++先赋值再自加，++i先自加，再赋值
                tail++;
                max_len = max_len > len ? max_len : len;
                if (*tail == '\0')
                {
                    break;
                }
                else
                {
                    len = tail - head;
                }
            }
            else
            {
                tail++;
                len++;
                max_len = max_len > len ? max_len : len;
            }
        }
    }
    return max_len;
}

第四题

在这里插入图片描述
该题花了两个晚上，我比较一般，用的方法都是按照正常人的思维来解题的。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2)
 {
    int m = nums1.size();//数组1的长度
	int n = nums2.size();//数组2的长度
	int p;

	//当前需要判断数组的长短，短的数组的元素插到长的数组
	if (m>=n) 
	{
		if (nums2.empty())
		{
			if (nums1.empty())
			{
				return 0;
			}
			if (m%2 == 0)//偶数，取中位数 
			{
				return ((double)nums1[m / 2 - 1] + (double)nums1[m / 2])/2;
			}
			else
			{
				return (double)nums1[m / 2];
			}
		}
		//nums2插入nums1
		while (!nums2.empty())
		{
			p = nums2[0];
			nums2.erase(nums2.begin());
			insert(nums1,p);
		}

		//取中位数
		m = nums1.size() ;
		if (m % 2 == 0)//偶数，取中位数 
		{
			return (double)(nums1[m / 2 - 1] + (double)nums1[m / 2]) / 2;
		}
		else
		{
			return (double)nums1[m / 2];
		}
		
	}
	else
	{
		if (nums1.empty())
		{
			if (nums2.empty())
			{
				return 0;
			}
			if (n % 2 == 0)//偶数，取中位数 
			{
				return ((double)nums2[n / 2 - 1] + (double)nums2[n / 2]) / 2;
			}
			else
			{
				return (double)nums2[n / 2];
			}
		}
		//nums1插入nums2
		while (!nums1.empty())
		{
			p = nums1[0];
			nums1.erase(nums1.begin());
			insert(nums2, p);
		}

		//取中位数
		n = nums2.size() ;
		if (n%2 == 0)//偶数，取中位数 
		{
			return ((double)nums2[n / 2 - 1] + (double)nums2[n / 2]) / 2;
		}
		else
		{
			return (double)nums2[n / 2];
		}
	}
    }
private :
    void insert(vector<int>& num, int p)
{
	int low;
	int high;
	int mid;

	low = 0;
	high = num.size()-1;

	while (low <= high)
	{
		mid = (low + high+1) / 2;
		if (num[mid] == p)
		{
            low = mid;
			break;
		}
		else if (num[mid] > p)
		{
			high = mid - 1;
		}
		else
		{
			low = mid + 1;
		}
	}
	num.insert(num.begin() + low, p);

}
};

第五题

实在是做不出来，一开始以为可以很快出结果，后面心态就炸了。
这个代码是跑不出来的。

#include "longestPalindrome.h"


string Solution::longestPalindrome(string s)
{
	string res = "";
	string temp;
	int len = s.length();
	bool flag = false; //用来判断是否属于左右对称的类型
	int p = 1;
	int i = 1;

	//len == 1 ; len == 2 的情况单独算
	if (len == 1)
	{
		res = s;
		return res;
	}

	if (len == 2)
	{
		if (s[0] == s[1])
		{
			res = s;
		}
		else
		{
			res = s[0];
		}
		return res;
	}

	while (p < len)
	{
		while (p - i >= 0 && p + i < len)
		{
			if (s[p - i] == s[p + i])//以某个数为中心两边对称
			{
				if ((i * 2 + 1) > res.length())
					res = s.substr(p - i, i * 2 + 1);
				i++;
				flag = true;

			}
			else
			{
				if (!flag) //意味着不属于两边对称的情况
				{
					if (s[p] == s[p + 1] && 2 >= res.length()) //看看能不能和右边的元素相等
						res = s.substr(p, 2);
					if (s[p] == s[p - 1] && 2 >= res.length())//看看能不能和左边的元素相等
						res = s.substr(p - 1, 2);
					if (1 > res.length()) //左右不相等，而且res为""
						res = s[p];
				}

				break;
			}
		}

		//避免因为一侧越界导致另一侧没被算入res
		if (res.length()%2 == 1)
		{
			int j = 0;
			while (j + 1 < res.length())
			{
				if (res[0] == res[j + 1])
				{
					j++;
				}
				else
				{
					break;
				}

			}

			if (res.length() < len && j + 1 == res.length() && j != 0)
			{
				if (p - i >= 0)
				{
					if (s[p - i] == res[0])
					{
						res = res + s[p - i];
					}
				}
				else if (p + i < len)
				{
					if (s[p + i] == res[0])
					{
						res = res + s[p + i];
					}
				}
			}
		}
		
		
		p++;
		i = 1;
	}

	return res;
}

第八题

class Solution {
public:
    int myAtoi(string s) {
        char negFlag = 1;
	int i = 0;
	char errState = 0; //0字符串为纯数字  1字符串不是纯数字
	int p = 0;
	double ret = 0;
	if (!s.empty())
	{
		s.erase(0, s.find_first_not_of(" "));
		s.erase(s.find_last_not_of(" ") + 1);
		//cout << s << endl; //清空空格
		//cout << s[0] << endl;
		char* numSave = (char*)malloc(sizeof(char) * s.size());

		//分为有符号和无符号的三种情况
		if (s[0] == '-')
		{
			negFlag = -negFlag;
			i = 1;
		}
		else if (s[0] == '+')
		{
			i = 1;
		}
		else
		{
			i = 0;
		}

		//字符转换成数字
		for (; i < s.size(); i++)
		{
			if (s[i] >= 48 && s[i] <= 57) // ASCII 48-57对应 ‘0’-‘9’
			{
				numSave[p] = s[i]-48;
				p++;
			}
			else
			{
				if ((s[0] == '-' || s[0] == '+') && i>1) //带符号的情况下存在数字
				{
					break;
				}
				else if (i>0)//不带符号的情况下存在数字
				{
					break;
				}
				else //一开始就不存在数字
				{
					errState = 1;
					break;
				}
				
			}

		}

		if (errState)
		{
			free(numSave);
			return 0;
		}

		for (p--,i = 0; p>=0; p--,i++)
		{
			ret +=(double) (numSave[p] * pow(10,i));
		}
		free(numSave);
		if ((double)negFlag * ret < -2147483648)
		{
			return -2147483648;
		}
		if (negFlag * ret > 2147483647)
		{
			return 2147483647;
		}
		return (int)negFlag*ret;
	}
	return 0;
    }
};

第九题

这题参考了之前数字逆排的思路，当时那题我也是用递归先做了一遍，然后采用的是while方法。
不过我这种方法击败的人很少。

h文件
#ifndef SOLUTION_H
#define SOLUTION_H
#include "stdlib.h"
#include <iostream>
using namespace std;
class Solution
{
public:
    typedef struct
    {
        int count;
        char* array;
    }Array_ntoa;

public:
    bool isPalindrome(int x);
    bool fun(int x, Array_ntoa* y);

};


#endif // !SOLUTION_H


c文件
#include "Solution.h"

# define INITSIZE 3

bool Solution::isPalindrome(int x)
{
	Array_ntoa y;
	y.count = 0;
	y.array = (char*)malloc(sizeof(char) * INITSIZE);
	if (!y.array)
	{
		exit(1);
	}
	if (x<0)
	{
		return false;
	}

	while (x!=0)
	{
		
		if (y.count >= INITSIZE)
		{
			y.array =(char*) realloc(y.array,y.count+1);
		}
		y.array[y.count] = x % 10;
		y.count++;
		x = x / 10;
	}

	for (int i = 0; i < y.count/2; i++)
	{
		if (y.array[0+i] != y.array[y.count-1-i])
		{
			return false;
		}
	}

	free(y.array);
	return true;
}

//递归函数

bool Solution::fun(int x, Array_ntoa *y_struct)
{
	/*	if (x <= 0)
	{
		return false;
	}
	else 
	{
		if (fun(x / 10, y_struct))
		{
			y_struct->array[y_struct->count] = x % 10;
			y_struct->count++;
			return true;
		}
		else
		{
			y_struct->array[y_struct->count] = x % 10;
			y_struct->count++;
			return true;
		}
		
	}*/
	return true;
}

主函数
#include "Solution.h"
#include "stdio.h"
#include "stdlib.h"


void main()
{

	Solution s;
	if (s.isPalindrome(10))
	{
		printf("yes");
	}
	else
	{
		printf("no");
	}

}
鄢广杰
关注
专栏目录
二分法专题-lintcode二分法问题解惑
lang的飞起的博客
11-27 452
二分法是常考的算法，适用于:在一个有序的序列中，找第一个满足某条件的位置(当然也可以找满足某条件的最后一个位置) 学习过程中让人迷惑的问题有: 上下限的确定,low=0,high=n-1还是low=0,high=n循环条件low循环中low=mid还是low=mid+1,high=mid还是high=mid-1有些情况无法退出循环，即是要mid=(low+high)/2还是mid=(l
leetCode刷题技巧总结（C++篇）
Accept1234的博客
03-15 2784
C++/C语言编程技巧 C++的STL库总结 字符串STL总结之string C++结构体定义 C++/C输入输出定义 专栏文章 挑战程序设计竞赛（经验篇）刷题记录索引 挑战程序设计竞赛（算法和数据结构）专栏 算法竞赛入门经典（第2版）刷题记录索引 王道计算机考研-机试指南 专栏 ...
LeetCode刷题总结C++-树篇（上）
panxiying1993的博客
08-13 1301
LeetCode刷题C++总结-树篇（上） 引子：刷题的过程可能是枯燥的，但程序员们的日常确不乏趣味。分享一则LeetCode上名为《打家劫舍 |||》题目的评论： 如有兴趣可以从此题为起点，去LeetCode开启刷题之旅，哈哈。该题目是选择一颗二叉树中对应节点的问题，也是本文收录的一道例题（具体请参考例12）。 本文开始分享作者对于LeetCode上有关树的刷题总结。谈到树，很多初学者会感觉很头疼。头疼的重点是其很多解法都离不开递归（或者说是深度优先搜索）的应用。...
LEETCODE上基于c++的编程题
adkinsy的博客
06-05 282
两数求和： 给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 c++方法： #include<iostream> #include <malloc.h> using namespace std; class ...
[C++] C\C++ printf 输出格式
weixin_33778778的博客
03-09 2642
  1．转换说明符      %a(%A)     浮点数、十六进制数字和p-(P-)记数法(C99)      %c         字符      %d         有符号十进制整数      %f         浮点数(包括float和doulbe)      %e(%E)     浮点数指数输出[e-(E-)记数法]      %g(%G)     浮点数不显无意义的零"0"   ...
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
谷歌和阿里大佬的Leetcode刷题笔记.zip
08-10
《谷歌和阿里大佬Leetcode刷题笔记》是一个珍贵的学习资源，专为提升算法能力和准备面试设计。LeetCode是一个在线平台，提供了大量的编程题目，旨在帮助程序员提升算法技能，特别是对于那些希望进入顶级科技公司如...
LeetCodeTest:leetcode刷题笔记
03-21
《LeetCodeTest: C++刷题笔记》 LeetCode是一个广受欢迎的在线编程挑战平台，尤其对于准备技术面试和提升编程技能的程序员来说，它是一个不可或缺的资源。本笔记主要聚焦于使用C++语言在LeetCode上进行算法解题的...
Leetcode刷题笔记.zip
04-20
在这个“Leetcode刷题笔记.zip”压缩包中，我们可以期待找到作者在解决LeetCode题目过程中积累的珍贵心得和解题策略。这份笔记可能涵盖了多种算法和数据结构的应用，对于学习和提升编程能力，特别是准备技术面试的...
谷歌师兄的leetcode刷题笔记-lbdb:小兄弟的数据库
06-30
"谷歌师兄"的LeetCode刷题笔记是他在挑战这些算法题目时积累的经验与心得，对于学习和提升算法能力具有很高的参考价值。而"Lbdb"则是他在笔记中提到的一个小型数据库系统，可能作为实现某些算法或数据结构练习的辅助...
leetcode的c++实现（一）
l_b_yuan的博客
04-28 4174
说在前面的话：c++的书看了几遍，但是平时写的机会比较少，所以忘得很快，俗话说读万卷书行万里路，没有实践理论的东西都是浮云。正好leetcode给我们提供了一个温故而知新的平台，我就计划借助这个平台在无聊的时候写写代码，慢慢把c++捡起来。下面的代码有的是自己写的，有的是在讨论区看到的让我醍醐灌顶的。这个系列的博客用来记录自己这个渐渐追忆、慢慢进步的过程，也方便以后找工作的时候复习。题目： Giv
leetcode 打印_刷 LeetCode 需要掌握的 C++ 知识
weixin_39673742的博客
11-28 692
最近有同学反馈，为什么不使用 OC 来实现算法，这里我统一回答下。原因主要有以下几点：1.在 LeetCode 的网站上并没有支持 OC 这门语言，导致写好的算法无法通过 LeetCode 来校验正确性；2.OC 中实现的数据结构很少，比如连基本的栈、队列、链表这样的数据结构都没有实现，有些算法实现需要依赖这些数据结构，这样使得理解算法的思想反而增加了成本；3.OC 这门语言受众面太小，...
每日一题：704.二分查找
qq_43160319的博客
09-06 103
题目： 给定一个n个元素有序的（升序）整型数组nums 和一个目标值target ，写一个函数搜索nums中的 target，如果目标值存在返回下标，否则返回 -1。 示例 1: 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 示例2: 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 -1 （这题感觉是编程...
C++学习笔记之 printf输出字符串
tsq19888的博客
10-12 9699
printf输出字符串 leetcode的练习14——最长公共前缀，遇到打印字符串的问题 string ss = { "\0" }; Solution sol1; ss=sol1.longestCommonPrefix(s1); printf("%s\n", &amp;ss); ss是一个string类型的变量，原本想通过printf直接打印字符串，结果以上方式输...
Leetcode 刷题经验总结 C++版
yao09605的博客
05-17 1838
文章目录一 容器1.vector2.stack3.queue, deque4. set，multiset5. map，multimap，hashmap二 常用类1. string三 常用函数1. sort()2. next_permutation()3. strtok()4. atoi(), atol(), atof()5. sprintf()6. strtol() 一 容器 每个容器都提供了很多方法，这里只介绍最适用于这种数据结构的一些方法，并且在做题时候会常用的一些方法。 1.vector vector
LeetCode 加快输入输出
weixin_30333885的博客
05-28 367
static auto __=[](){ std::ios::sync_with_stdio(false); cin.tie(nullptr); return nullptr; }();//注意放在solution上面 转载于:https://www.cnblogs.com/Jawen/p/10940043.html...
【JavaScript】LeetCode：707设计链表
最新发布
weixin_45980065的博客
09-14 575
【代码】【JavaScript】LeetCode：707设计链表。
leetcode-617. 合并二叉树
曼巴的博客
09-11 243
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；1）如果没有root1，return root2。2）如果没有root2，return root1。null 的节点将直接作为新二叉树的节点。合并过程必须从两个树的根节点开始。3）根结点处理：两节点值加和。4）遍历两棵树的左节点。5）遍历两棵树的右节点。返回合并后的二叉树。
leetcode-647. 回文子串
曼巴的博客
09-12 408
3）遍历顺序：一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。6个回文子串: "a", "a", "a", "aa", "aa", "aaa"当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况。三个回文子串: "a", "b", "c"是字符串中的由连续字符组成的一个序列。是正着读和倒过来读一样的字符串。
算法进阶指南：PAT、蓝桥杯与LeetCode实战心得
《PAT|蓝桥|LeetCode学习路路径&刷题经验by柳柳婼》是一本针对计算机科学学生编写的指南，着重讲解了在IT行业中算法学习的重要性，特别是在求职和提升技能方面的作用。本书分为以下几个部分： 1. **计算机科学中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鄢广杰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值