lin

Leecode 101给定一个二叉树，检查它是否是镜像对称的。方法一：递归判断，类似于判断两个树是否相等，不过这次左右树交叉判断。代码： bool Check(TreeNode* p, TreeNode* q) { if (!p && !q) return true; if (!p || !q) return false; return p->val == q->val && Check(p->left, q->right) &a

思路：为了减少遍历次数，采用左右向中间走的方式，同时维护一个左侧的最大值和右侧的最大值，当前值和最大值的差值则为当前块增加的水量。int Leecode42_trap(std::vector<int>& height) { int left = 0, right = height.size() - 1; int ans = 0,left_max = 0, right_max = 0; while (left < right) { if (height[left] &l

题目：给定一个数字，将其转为罗马文字思路：直接贪心法，先从最大的M开始，如果num比1000大，那么则除以他后再比，如果除后不大于当前标识符，则除以第二大的900，依次下去，直到除到个位 I。类似于找去商店买东西找零。代码：std::string Leecode12_intToRoman(int num) { int values[] = { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 }; std::string symbols[]

题目：给定数组，数组值为可以向前进得最大次数，求跳到最后一个位置的最少步数。建设数组不含0.思路：由于存的值是当前可跳的最远的步数，那么肯定尽量跳得远咯。从头开始，维护一个上次可以跳得最远位置，和当前的可跳的最远的位置，取大的。代码：int Leecode45_jump(std::vector<int>& nums) { int maxPos = 0, end = 0, step = 0; for (int i = 0; i < nums.size() - 1; ++

Leecode 415代码：std::string Leecode415_addString(std::string num1, std::string num2) { int len1 = num1.size() - 1; int len2 = num2.size() - 1; int car = 0; std::string result = ""; while (car == 1 || len1 >= 0 || len2 >= 0) { int x = len1 >

Leecode49思路：对每个元素排序，然后用map来存储，用元素做键，同样字母的组成的字符串的列表做值。最后按值返回列表代码：class Solution { public List<List<String>> Leecode49_groupAnagrams(String[] strs) { if (strs.length == 0) return new ArrayList(); Map<String, List> ans = new Ha

Leecode 43思路：三个数组，从右往左相加，最后处理最高位有进位情况。代码：std::string Leecode43_multiply(std::string num1, std::string num2) { std::string ans; std::vector<int> a, b, c; c.resize(num1.size() + num2.size() - 1); for (int i = num1.size() - 1; i >= 0; i--) a.

Leecode 36思路：最简单暴力方法，三次便利，按行，按列，按小块。另外一种方法，一次便利，用三个hash表记录分别记录行、列、块。然后看如果出现的次数多于一次，那么返回false。代码：//貌似有点问题bool Leecode36_isValidSudoku(std::vector<std::vector<char>>& board) { std::vector<std::map<int, int>> rows; std::vecto

Leecode 46思路：全排列，一般会用回溯法代码：class Leecode46 { std::vector<std::vector<int>>Leecode46_permute(std::vector<int>& nums) { std::vector<std::vector<int>> res; backtrack(res, nums, 0, nums.size()); return res; } void

Leecode 34思路：还是二分查找，查找的不只是目标对象。第一次二分查找早左边界，第二次查找右边界。代码：class Leecode34 { std::vector<int> Leecode34_searchRange(std::vector<int>& nums, int target) { std::vector<int> no_find = { -1,-1 }; int left_index = extreamIndex(nums, t

Leecode 33思路：由于复杂度限制，故不能直接遍历查找，也不能直接用std::find，因为二者是线性查找。有序，就用二分查找。旋转一半，那么肯定有一半是有序的，另外一半可能混合的，那么就看目标是在有序的那一边还是无序的那一边。不停折半，多几次二分查找就可以了。代码：int Leecode33_search(vector<int>& nums, int target) { int n = (int)nums.size(); if (!n)

Leecode 31思想：直接排列复杂度太高。当前排列的下一个序列，就是序列从后往前，达到非降序的哪一个数，与在后一个序列中比当前数大一点的数，换了位置，然后讲最后的原来降序排列就好了。即从下面图中，a[i-1]和a[j]换，然后从a[i]到结尾重新排序（降序）代码：void Leecode31_nextPermutation(std::vector<int>& nums) { int i = nums.size() - 2; while (i >= 0 &&

代码：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* Leecode24_swapPairs(ListNode* head) { if (head ==

Leecode 22:代码：class Leecode22 { std::vector<std::string> result; std::vector<std::string> Leecode22_generateParenthesis(int n) { dfs(n, n, ""); return result; } void dfs(int left, int right, std::string curStr) { if (left == 0 &

Leecode 18思路：两数之和用双指针，三数之和，固定第一个，再用双指针，四数之和再三数之和上多家一层循环就好了，另外注意同一个位置得前后两个数字不要重复。代码：std::vector<std::vector<int>> Leecode18_fourSum(std::vector<int>& nums, int target){ sort(nums.begin(), nums.end()); std::vector<std::vector&l

Leecode 16思路：固定一个，再运用双指针。先固定第一个，然后运用双指针，一个变量记录最小差值，一个记录三个最近值得和，如果差值为0直接返回，否者返回最近得值。代码：int Leecode16_threeSumClosest(std::vector<int>& nums, int target) { int result = INT_MAX; int last_closet = INT_MAX; int len = nums.size(); if (len <

Leecode15思路：首先对数组进行排序，排序后固定一个数 nums[i]，再使用左右指针指向 nums[i]后面的两端，数字分别为 nums[L] 和 nums[R]，计算三个数的和 sum 判断是否满足为 0，满足则添加进结果集。如果 nums[i]大于 0，则三数之和必然无法等于 0，结束循环如果 nums[i]= nums[i-1]，则说明该数字重复，会导致结果重复，所以应该跳过当 sum = 0 时，nums[L]= nums[L+1] 则会导致结果重复，应该跳过，L++当 sum

Leecode 11思路：毫无疑问，盆子越宽装的越多，那么从两边向中间靠，谁短谁移动，直到相遇。代码int Leecode11_maxArea(std::vector<int>& height) { int max_area = 0; for (int i = 0, j = height.size() - 1; i <= j;) { int current_area = (j - i) * std::min(height[j], height[i]); max_a

Leecode8代码：如下，很简单，一看就明白的。int Leecode8_myAtoi(std::string str) { int res= 0; int i = 0; int flag = 0; while (str[i] == ' ') i++; if (str[i] == '-') flag = -1; if (str[i] == '+' || str[i] == '-') i++; while (i < str.size() && isdigi

Leecode 5最长回文串方法一：动态规划法，对于一个子串而言，如果它是回文串，并且长度大于 22，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串 "ababa’’ 如果我们已经知道 `bab’'是回文串，那么ababa一定是回文串，这是因为它的首尾两个字母都是 “a”。边界条件就是i=j的时候，肯定是回文串，如果为2，当两个字符相同时候也为回文串。代码std::string Leecode5_longestPalindrome(std::string s) { int n

Leecode 3给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。方法一：SET最长子串，就需要直到开始和结束，开始用一个字符表示，另外一个一直吵右走，直到遇到重复的串。重复的串采用unordered_set来保证，如果再set里面找到了，那么就移动左侧开始位置。同时查找当前的串长度和最大长度谁大，更新最大长度。代码：int Leecode3_2_lengthOfLongestSubString(std::string s) { if (s.size() == 0) return

Leecode 2从头开始加，用一个carry代表进位，有进位，下一个节点就为两个节点相加再加上进位值。给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。方法一：代码ListNode* Leecode2_addTwoNumbers(ListNode* l1, ListNode* l2) {

Leecode 198你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。方法一：动态规划由于不可以在相邻的房屋闯入，所以在当前位置 n 房屋可盗窃的最大值，要么就是 n-1 房屋可盗窃的最大值，要么就是 n-2 房屋可盗窃的最大值加上当前房屋的值，二者之间取最大值

Leecode 110给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。方法一：树最长用的递归方法，代码：int height(TreeNode* root) { if (root == NULL) return 0; int l = height(root->left); int r = height(root->right); if (l < 0 || r < 0 |

Leecode 108将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。方法一：递归法，每次选择中间作为root,类似于二分法。树类的算法大多可以用递归解决。代码： TreeNode* Leecode108_sortedArrayToBST(std::vector<int>& nums) { if (nums.size() == 0) return NULL; int

Leecode 107给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）方法一：用栈的方法，先将当层入栈，取值，最后插入结果数组，每次插入到最前面，保证倒叙，最后插入的叶子再最前面。代码：std::vector<std::vector<int>> Leecode107_levelOrderBottom(TreeNode* root) { std::vector<std::vector<int>&g

Leecode 104给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。方法一：深度优先法，通过深度优先搜寻。从根节点开始，返回左侧和右侧的深度，然后返回最大值，由此递归，直到到达叶子。从叶子节点到根节点深度回溯，直到到达根节点。代码： int Leecode104_maxDepth(TreeNode* root) { if (root == NULL) return 0; int depth_L = Leecod

Leecode 100给定两个二叉树，编写一个函数来检验它们是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。代码：直接递归遍历，先看是否空，是否同时空，再看val，最后递归，左右树判断。 bool Leecode100_isSameTree(TreeNode* p, TreeNode* q) { if (p == NULL && q == NULL) return true; if (p == NULL || q == NULL) return fa

Leecode 88给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。示例输入：输入:nums1 = [1,2,3,0,0,0], m = 3nums2 = [2,5,6], n = 3输出: [1,2,2,3,5,6]代码：习惯简单用库函数的方法，由于输入长度m+n, n，故直接把后面的值填到前面的数组，再sort一下就好了。 void Leecode88_merge(std::vector<

Leecode 83给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。方法：比较简单，直接两个指针，一个指向前一个结点，一个指向当前节点，比较值，详情见代码 ListNode* Leecode83_deleteDuplicates(ListNode* head) { if (head == NULL || head->next == NULL) return head; ListNode* pre = head; ListNode* cur = head->n

Leecode 70假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶？方法一：简单讲，直接写出前面几个，就能看出来是一个斐波拉契数列。代码： int Leecode70_climbStairs(int n) { if (n <= 2) return n; int a = 1, b = 1; for (int i = 1; i < n; i++) { int temp = b; b = a + b;

Leecode 69实现 int sqrt(int x) 函数。方法一：直接return, 当然这样可能会被打。代码： int Leecode69_mqSqrt(int x) { return sqrt(int x); }方法二：数学公式法，x\sqrt xx​ = e0.5log(x)e^{0.5}log(x)e0.5log(x)，注意由于浮点数和整数转换带来的误差，最后判断结果和结果+1的大小。int Leecode69_mqSqrt(int x) { if (x == 0) re

Leecode 67给你两个二进制字符串，返回它们的和（用二进制表示）,输入为 非空 字符串且只包含数字 1 和 0。例如：输入: a = "1010", b = "1011"输出: "10101"方法一：直接库函数，python或者java有直接的库可以调用代码：# pythonclass Solution: def addBinary(self, a, b) -> str: return '{0:b}'.format(int(a, 2) + int(b,

Leecode 58 :给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。如果不存在最后一个单词，请返回 0方法一: 最简单的方法，python思维，直接字符串切割split,返回最后一个值的size。用到c++11的 #include<regex>代码：int Leecode58_lengthOfLastWord(std::string s) { if (s.length() == 0

leecode 53 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。方法一：最简单的方法，维护一个最大值和一个当前和，当最大值比当前和小则更新最大值，当前和为负数，且当前值比当前和大，更新当前和为当前值。代码：int Leecode53_maxSubArray(std::vector<int>& nums) { if (nums.size() <=1) return nums.size()==1 ? nums

题目： 给定一个 32 位有符号整数，将整数中的数字进行反转。示例输入: 123输出: 321输入: -123输出: -321输入: 120输出: 21注意:假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231, 231 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。思路：原数对10取模，然后除以10，直到为0。取得各位数，然后乘以10...

题目： 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。例如:给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7返回其层次遍历结果：[ [3], [9,20], [15,7]]代码：/** * Definition for a binary t...

思路：当root非空的时候三种情况1）两个节点均在root的左子树，此时对root-&amp;amp;amp;gt;left递归求解2）两个节点均在root的右子树，此时对root-&amp;amp;amp;gt;right递归求解；3）两个节点分别位于root的左右子树，此时为root。代码TreeNode* lowstCommonAncesstor(TreeNode* root,TreeNode* p,TreeNode* q)...

题目：给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置。输入: [2,3,1,1,4]输出: true解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。输入: [3,2,1,0,4]输出: false解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度...

题目：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。示例:给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1]参考答案：分析：由于是有序的数组，那么直接首尾元素相加，如果大于target，那么尾部元...