失业第一天_leetcode

已于 2023-11-23 16:15:47 修改
阅读量129 收藏
点赞数
文章标签： leetcode 算法 职场和发展
于 2023-11-10 00:47:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Forwarding3/article/details/134305453
版权

题目列表

1. 两数之和

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

//class Solution {
//public:
//	vector<int> twoSum(vector<int>& nums, int target) {
//		int n = nums.size();
//		for (int i = 0; i < n; ++i) {
//			for (int j = i + 1; j < n; ++j) {
//				if (nums[i] + nums[j] == target) {
//					return {i, j};
//				}
//			}
//		}
//		return {};
//	}
//};

class Solution {
public:
	vector<int> twoSum(vector<int>& nums, int target) {
		unordered_map<int, int> hashtable;
		for (int i = 0; i < nums.size(); ++i) {
			auto it = hashtable.find(target - nums[i]);
			if (it != hashtable.end()) {
				return {it->second, i};
			}
			hashtable[nums[i]] = i;
		}
		return {};
	}
};

int main() {
	int tgt = 6;
	vector<int> nums = { 3,3 };
	vector<int> res;
	Solution s1;
	res = s1.twoSum(nums, tgt);
	//for (auto it = res.begin(); it != res.end(); it++) {
	//	cout << *it << endl;
	//}
	for (int i = 0; i < res.size(); ++i) {
		cout << res[i] << ' ';
	}
	system("pause");
	return 0;
}

2. 两数相加

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

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* creatNode(int n) {
		ListNode* headnode = new ListNode();//申请动态空间;
		headnode->next = nullptr;
		ListNode* p = headnode;
		while (n--)
		{
			ListNode* q = new ListNode();
			cin >> q->val;
			q->next = p->next;
			p->next = q;
			p = q;//每次把头结点后移，重复上面操作;
		}
		return headnode;
	}

	//打印链表
	void printList(ListNode* headnode) {
		ListNode* pmove = headnode->next;
		while(pmove) {
			cout << pmove->val << " ";
			pmove = pmove->next;
		}
		if (!pmove){
			cout << endl;
		}
	}

	//两数相加
	ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
		ListNode* head = nullptr, *tail = nullptr;
		int carry = 0;
		while (l1 || l2) {
			int n1 = l1 ? l1->val : 0;
			int n2 = l2 ? l2->val : 0;
			int sum = n1 + n2 + carry;
			if (!head) {
				head = tail = new ListNode(sum % 10);
			}
			else {
				tail->next = new ListNode(sum % 10);
				tail = tail->next;
			} 
			carry = sum / 10;
			if (l1) {
				l1 = l1->next;
			}
			if (l2) {
				l2 = l2->next;
			}
		}

		if (carry > 0) {
			tail->next = new ListNode(carry);
		}
		return head;
	}
};

int main() {
	int n, m;
	Solution s1;
	ListNode* List1, *List2, *res;
	cin >> n >> m;
	List1 = s1.creatNode(n);
	s1.printList(List1);

	List2 = s1.creatNode(m);
	s1.printList(List2);

	res = s1.addTwoNumbers(List1, List2);
	s1.printList(res);

	system("pause");
	return 0;

}

3. 无重复字符的最长子串

#include <iostream>
#include <string>
#include <unordered_set>
#include <algorithm>
using namespace std;

class Solution {
public:
	int lengthOfLongestSubstring(string s) {
	/*依次对每一个字母为起点，找到最长子串，然后取最长
	*/
		unordered_set<char> occ;
		int n = s.length();
		int right = 0, ans = 0;

		for (int left = 0; left < n; ++left) {
			if (left != 0) {
				occ.erase(s[left - 1]);
			}
			while (right < n && !occ.count(s[right])) {
				occ.insert(s[right]);
				++right;
			}
			ans = max(ans, right - left);
		}
		return ans;
	}
};

int main() {
	string s;
	Solution s1;
	getline(cin, s);
	int ans;
	ans = s1.lengthOfLongestSubstring(s);
	cout << ans;
    return 0;


}

4. 最长回文子串

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

class Solution {
public:
	string longestPalindrome(string s) {
		// 中心扩展
		if (s.length() < 2) {
			return s;
		}
		int maxLeft = 0;
		int maxRight = 0;
		int len = 1;
		int maxlen = 0;

		for (int mid = 0; mid < s.length(); ++mid) {
			int left = mid - 1;
			int right = mid + 1;

			while (left >= 0 && s[left] == s[mid]) {
				left--;
				len++;
			}
			while (right < s.length() && s[right] == s[mid]) {
				right++;
				len++;
			}

			while (left >= 0 && right < s.length() && s[left] == s[right]) {
				left--;
				right++;
				len += 2;
			}
			if (len > maxlen) {
				maxLeft = left;
				maxRight = right;
				maxlen = len;
			}
			len = 1;

		}
		return s.substr(maxLeft + 1, maxlen);

	}
};

int main() {
	string s;
	Solution s1;
	getline(cin, s);
	string ans;
	ans = s1.longestPalindrome(s);
	cout << ans;
	return 0;
}

5. N 字形变换

class Solution {
public:
    string convert(string s, int numRows) {
        if (numRows < 2)
            return s;
        vector<string> rows(numRows);
        int i = 0, flag = -1;
        for (char c : s) {
            rows[i].push_back(c);
            if (i == 0 || i == numRows -1)
                flag = - flag;
            i += flag;
        }
        string res;
        for (const string &row : rows)
            res += row;
        return res;
    }
};

6. 整数反转

class Solution {
public:
    int reverse(int x) {
    /*数学方法，每次取x的末尾数字，然后判断待压入的数字时候在int范围
    */
        int rev = 0;
        while (x != 0) {
            if (rev < INT_MIN / 10 || rev > INT_MAX / 10) {
                return 0;
            }
            int digit = x % 10;
            x /= 10;
            rev = rev * 10 + digit;
        }
        return rev;
    }
};

7. 字符串转换整数 (atoi)

class Solution {
public:
    int myAtoi(string s) {
        int res = 0, bndry = INT_MAX / 10;
        int i = 0, sign = 1, length = s.size();
        if(length == 0) return 0;
        //排除前导空格
        while(s[i] == ' ')
            if(++i == length) return 0;
        //确定正负
        if(s[i] == '-') sign = -1;
        if(s[i] == '-' || s[i] == '+') i++;
        //开始取数
        for(int j = i; j < length; j++) {
            if(s[j] < '0' || s[j] > '9') break;
            //判断是不是越界
            if(res > bndry || res == bndry && s[j] > '7')
                return sign == 1 ? INT_MAX : INT_MIN;
            res = res * 10 + (s[j] - '0');
        }
        return sign * res;
    }
};

8. 回文数

class Solution {
public:
    bool isPalindrome(int x) {
    //转成字符串然后反转
        string s = to_string(x);
        return s == string(s.rbegin(),s.rend());
    }
};

9. 盛最多水的容器

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;

class Solution {
public:
	int maxArea(vector<int>& height) {
	//双指针，每次只挪更短的那根木板
		int ans = 0, left = 0, right = height.size() - 1;
		while (left < right) {
			if (height[left] <= height[right]) {
				ans = max(ans, (right - left) * height[left]);
				left++;
			}
			else {
				ans = max(ans, (right - left) * height[right]);
				right--;
			}
		}
		return ans;
	}
};

int main() {
	vector<int> nums = { 1,8,6,2,5,4,8,3,7 };
	int ans = 0;
	Solution s1;
	ans = s1.maxArea(nums);
	cout << ans << endl;
	return 0;
}

10. 整数转罗马数字

class Solution {
public:
    string intToRoman(int num) {
        vector<int> values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        vector<string> reps = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        string res;
        for (int i = 0; i < 13; ++i) {
            while (num >= values[i]) {
                num -= values[i];
                res += reps[i];
            }
        }
        return res;
    }
};

11. 罗马数字转整数

class Solution {
private:
    unordered_map<char, int> symbolValues = {
        {'I', 1},
        {'V', 5},
        {'X', 10},
        {'L', 50},
        {'C', 100},
        {'D', 500},
        {'M', 1000},
    };
public:
    int romanToInt(string s) {
    /*通常情况下，罗马数字中小的数字在大的数字的右边。若输入的字符串满足该情况，那么可以将每个字符视作一个单独的值，累加每个字符对应的数值即可。
例如 XXVII = X+X+V+I+I=10+10+5+1+1=27。
若存在小的数字在大的数字的左边的情况，根据规则需要减去小的数字。对于这种情况，我们也可以将每个字符视作一个单独的值，若一个数字右侧的数字比它大，则将该数字的符号取反。
例如 XIV = X−I+V=10−1+5=14。
    */
        int ans = 0;
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            int value = symbolValues[s[i]];
            if (i < n - 1 && value < symbolValues[s[i + 1]]) {
                ans -= value;
            }else{
                ans += value;
            }
        }
        return ans;
    }
};

12. 最长公共前缀

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int n = strs.size();
        if(n == 0) {
            return "";
        }
        int length = strs[0].size();
        for (int i = 0; i < length; ++i) {
            char c = strs[0][i];
            for (int j = 1; j < n; ++j) {
                if (i == strs[j].size() || strs[j][i] != c) {
                    return strs[0].substr(0, i);
                }
            }
        }
        return strs[0];
    }
};

13. 三数之和

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;

class Solution {
public:
	vector<vector<int>> threeSum(vector<int>& nums) {
		int n = nums.size();
		sort(nums.begin(), nums.end());
		vector<vector<int>> ans;


		for (int first = 0; first < n; ++first) {
			if (first > 0 && nums[first] == nums[first - 1]) {
				continue;
			}
			if (nums[first] > 0) {
				break;
			}

			int third = n - 1;
			for (int second = first + 1; second < n; ++second) {
				if (second > first + 1 && nums[second] == nums[second - 1]) {
					continue;
				}
				
				while (second < third && nums[first] + nums[second] + nums[third] > 0) {
					--third;
				}
				if (second == third) {
					break;
				}
				if (nums[first] + nums[second] + nums[third] == 0) {
					ans.push_back({nums[first], nums[second], nums[third]});
				}
			}
		}
		return ans;
	}
};

int main() {
	vector<int> nums = {-1,0,1,2,-1,-4};
	vector<vector<int>> ans;
	Solution s1;
	ans = s1.threeSum(nums);
	int n = ans.size();
	int m = ans[0].size();
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < m; ++j) {
			cout << ans[i][j] << " ";
		}
	}
	return 0;
}

14. 最接近的三数之和

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        int n = nums.size();
		sort(nums.begin(), nums.end());
        int ans = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < n; ++i) {
            int start = i + 1, end = n - 1;
            while (start < end) {
                int sum = nums[start] + nums[end] + nums[i];
                if(abs(ans - target) > abs(sum - target)) {
                    ans = sum;
                }
                if (sum > target) {
                    end--;
                }
                else if (sum < target) {
                    start++;
                }else {
                    return ans;
                }
            }
        }
        return ans;
    }
};

15. 电话号码的字母组合

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

class Solution {
public:
	string temp;
	vector<string> res;
	vector<string> board = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};

	void DFS(int pos, string digits) {
		if (pos == digits.size()) {
			res.push_back(temp);
			return;
		}

		int num = digits[pos] - '0';
		for (int i = 0; i < board[num].size(); ++i) {
			temp.push_back(board[num][i]);
			DFS(pos + 1, digits);
			temp.pop_back();     //移除容器中的最后一个元素
		}
	}
	vector<string> letterCombinations(string digits) {
		if (digits.size() == 0) {
			return res;
		}
		DFS(0, digits);
		return res;
	}
};

int main() {
	string s;
	Solution s1;
	getline(cin, s);
	vector<string> ans;
	ans = s1.letterCombinations(s);
	for (int i = 0; i < ans.size(); ++i) {
		cout << ans[i] << endl;
	}
	return 0;
}

16. 四数之和

class Solution{
	public: 
	vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        vector<vector<int> > res;
        if(nums.size() < 4)
        return res;
        int a,b,c,d,_size = nums.size();
        for( a = 0;a <= _size - 4;a++){
        	if(a > 0 && nums[a] == nums[a-1]) continue;      //确保nums[a] 改变了
        	for( b = a + 1; b <= _size - 3; b++){
        		if( b > a + 1 && nums[b] == nums[b-1])continue;   //确保nums[b] 改变了
        		c=b+1,d=_size-1;
        		while(c<d){
        			if(nums[a]+nums[b]-target < -(nums[c]+nums[d]))//原写法num[a]+num[b]+num[c]+num[d]<target为了防止溢出，见下面的补充修改
        			    c++;
        			else if(nums[a]+nums[b]-target>-(nums[c]+nums[d]))//同上
        			    d--;
        			else{
        				res.push_back({nums[a],nums[b],nums[c],nums[d]});
        				while(c<d&&nums[c+1]==nums[c])      //确保nums[c] 改变了
        				    c++;
        				while(c<d&&nums[d-1]==nums[d])      //确保nums[d] 改变了
        				    d--;
        				c++;
        				d--;
					}
				}
			}
		}
		return res;
    }
};

17. 删除链表的倒数第 N 个结点

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

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* creatNode(int n) {
		ListNode* headnode = new ListNode();//申请动态空间;
		headnode->next = nullptr;
		ListNode* p = headnode;
		while (n--)
		{
			ListNode* q = new ListNode();
			cin >> q->val;
			q->next = p->next;
			p->next = q;
			p = q;//每次把头结点后移，重复上面操作;
		}
		return headnode;
	}

	//打印链表
	void printList(ListNode* headnode) {
		ListNode* pmove = headnode->next;
		while(pmove) {
			cout << pmove->val << " ";
			pmove = pmove->next;
		}
		if (!pmove){
			cout << endl;
		}
	}
	//删除链表的倒数第 N 个结点
	ListNode* removeNthFromEnd(ListNode* head, int n) {
		if (!head) {
			return head;
		}
		int length = 0;
		ListNode* dummy1 = head;
		while (dummy1) {
			++length;
			dummy1 = dummy1->next;
		}

		ListNode* dummy = new ListNode(0, head);
		ListNode* cur = dummy;
		for (int i = 1; i < length - n + 1; ++i) {
			cur = cur->next;
		}
		cur->next = cur->next->next;
		ListNode* ans = dummy->next;
		delete dummy;
		return ans;
	}
};

int main() {
	int n = 0, m = 2;
	Solution s1;
	ListNode* List1, *res;
	cin >> n;
	List1 = s1.creatNode(n);
	s1.printList(List1);
	res = s1.removeNthFromEnd(List1, m);
	s1.printList(res);

	system("pause");
	return 0;
}

18. 有效的括号

#include <iostream>
#include <vector>
#include <stack>
#include <string>
#include <unordered_map>
using namespace std;

class Solution {
public:
	bool isValid(string s) {
		unordered_map<char, int> myMap = {
			{'(', 1},
			{'{', 2},
			{'[', 3},
			{']', 4},
			{'}', 5},
			{')', 6},
		};

		stack<char> mySk;
		for (auto element : s) {
			if (myMap[element] < 4) {
				mySk.push(element);
			}
			else {
				if (mySk.empty() || myMap[element] + myMap[mySk.top()] != 7) {
					return false;
				}
				else {
					mySk.pop();
				}
			}
		}
		return mySk.empty();
	}
};

int main() {
	bool ans;
	Solution s1;
	string s;
	getline(cin, s);
	ans = s1.isValid(s);
	cout << ans;
	return 0;
}

19. 合并两个有序链表

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

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* creatNode(int n) {
		ListNode* headnode = new ListNode();//申请动态空间;
		headnode->next = nullptr;
		ListNode* p = headnode;
		while (n--)
		{
			ListNode* q = new ListNode();
			cin >> q->val;
			q->next = p->next;
			p->next = q;
			p = q;//每次把头结点后移，重复上面操作;
		}
		return headnode;
	}

	//打印链表
	void printList(ListNode* headnode) {
		ListNode* pmove = headnode->next;
		while(pmove) {
			cout << pmove->val << " ";
			pmove = pmove->next;
		}
		if (!pmove){
			cout << endl;
		}
	}

	ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
		ListNode* preHead = new ListNode(0);
		ListNode* prev = preHead;
		while (list1 != nullptr && list2 != nullptr) {
			if (list1->val < list2->val) {
				prev->next = list1;
				list1 = list1->next;
			}
			else {
				prev->next = list2;
				list2 = list2->next;
			}
			prev = prev->next;
		}
		prev->next = list1 == nullptr ? list2 : list1;
		return preHead->next;
	}
};

int main() {
	int n, m;
	Solution s1;
	ListNode* List1, *List2, *res;
	cin >> n >> m;
	List1 = s1.creatNode(n);
	s1.printList(List1);

	List2 = s1.creatNode(m);
	s1.printList(List2);

	res = s1.mergeTwoLists(List1, List2);
	s1.printList(res->next);

	system("pause");
	return 0;
}
Forwarding3
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode-solution15.zip_idea leetcode_leetcode_leetcode python
09-20
Leetcode 题目解答 python版本
LeetCode_No80.rar_leetcode_leetcode c++代码
09-24
找工作刷题，这是个很好的选择。每天刷上一个两个的题，不错。
leetcode题解_leetcode_leetcode题解_
09-29
leetcode题解 算法和数据结构题目及解答
leetcode详解.zip_leetcode_leetcode详解
07-15
程序员招工组必备，leetcode刷题中文详解，迅速提升代码能力
LeetCode.41缺失的第一个正数详解
LeoLei8060的博客
06-22 319
首先，遍历数组，对于每个元素，如果它是一个正整数并且它不在它的理想位置（例如数字 iii 应该位于索引i−1），则将它与其理想位置上的元素交换。最后，遍历数组查找第一个非负数的索引，该索引加 1 即为未出现的最小正整数。通过确保所有的正整数均在数组中有一个对应的索引，我们可以通过索引位置来判断一个数是否存在于数组中。再次遍历数组，第一个其索引+1不等于其值的位置，就指示了未出现的最小正整数。首先，我们需要遍历数组，将所有非正整数以及大于数组长度的数替换为一个大于数组长度的值（例如。请你实现时间复杂度为。
LeetCode 算法：排序链表 c++
小金牛来了
06-22 443
LeetCode 算法：排序链表 c++
力扣454题解：四数相加（java实现简易）
2301_77695569的博客
06-17 697
LeetCode第454题是一个考察数组和哈希表的经典问题。通过这个问题，我们可以加深对双指针技巧和哈希表应用的理解。掌握这个问题的解法，对于解决其他相关问题非常有帮助。
LeetCode 610, 28, 23
qq_61350148的博客
06-18 909
使用mysql和java语言解决LeetCode 610, 28, 23。
leetcode 130被围绕的区域
weixin_44554979的博客
06-16 277
可以循环边界，找边界的区域（利用深搜），这些都不能被围绕，其余的，能被围绕，应该从"O"变为”X“字符分别是大写的X和大写的O，我把O当成了0。一个区域不能被围绕是这个区域有部分在边界。
leetcode139-Word Break
我的程序人生
06-18 378
这道题目用贪心肯定不行，因为字符串有多种拆分的方式，所以肯定是需要用动态规划解的，题目说如果在字典中都能找到的返回true，那么我们就用dp[i]数组来表示 从0到i的字符串是否可拆分，最终返回dp的最后一个元素即是最终的答案，而0～i可以分为0。i，如果dp[j]是可以拆分的同时S[i,j]子串也在字典中存在那么dp[i]肯定可以拆分，注意只要能找到一个字串能满足拆分需求的那就说明位置i处是可以拆分的。解释: 返回 true 因为 “leetcode” 可以由 “leet” 和 “code” 拼接成。
leetcode322零钱兑换（背包问题）
s07aser123的专栏
06-19 552
背包问题转移方程总结，动态规划
Python | Leetcode Python题解之第166题分数到小数
Mopes__的博客
06-19 395
Python | Leetcode Python题解之第166题分数到小数
Leetcode 238. 除自身以外数组的乘积
salmonwilliam的博客
06-17 338
【代码】Leetcode 238. 除自身以外数组的乘积。
LeetCode88-删除有序数组中的重复项
~单人舞~的博客
06-16 260
需要理解题意，数组本身是有序的，也就意味相同值肯定是挨着的需要理解一下为什么slow=2，是因为要从数组的第一个开始重新进行赋值。
Leetcode275 H指数II
zjshuster的博客
06-17 179
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。，可以把查找H指数的过程改成二分法，因为此题中H指数数组是已经排序好的，这样就可以实现log(N)时间复杂度。给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。基于前一题的解题思路。
贪心-区间问题
Mr_Richard的博客
06-15 786
将问题转化为求非交叉区间数量的问题（非交叉区间，如[1,3],[2,4]算1个非交叉区间，如[1,2],[3,4]算2个非交叉区间）我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是。按开始下标升序排序，然后遍历数组，相邻的两个区间能合并则进行合并；处射出一支箭，若有一个气球的直径的开始和结束坐标为。一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。返回一个表示每个字符串片段的长度的列表。
2024-06-22力扣每日一题
最新发布
Fei_WuYan的博客
06-22 61
难，寄！
LeetCode 3186 最大施法伤害
veatheroe的博客
06-17 277
LeetoCode地址: . - 力扣（LeetCode）这道题很直观，玩游戏的都懂，伤害最大化嘛！但是每个法术释放与否可能会影响总体的伤害，因此是从局部最优解找到全局最优解的动态规划问题！禁止释法的区间是+-2，且相同伤害的法术可以释放多次，所以很容易想到，将伤害相同的法术进行计数，并按照伤害的大小进行排序。这样就可以从最小的伤害开始考虑释放与否了。剩下的，直接看代码吧
char* 长度_leetcode之最后一个单词的长度
05-30
我们可以从字符串的末尾向前遍历，找到第一个非空格的字符，然后再向前遍历，直到遇到第一个空格或者字符串的开头，这个过程中计算出单词的长度即可。 具体实现可以参考下面的代码： ```c++ int lengthOfLastWord...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值