qq_45981158的博客

强烈推荐归并排序讲解视频（新手非常友好的讲解）首先我么们明确归并排序的主要思想：第一：分治法 进行数组的局部排序第二： 合并两个有序的数组public class MergeSort { public static void main(String[] args) { int[] nums = {1,2,4,3,6,5,9,0,7,7}; mergeSort(nums,0,nums.length-1); for (int i = 0; i &.

面试可愿意考这玩意了！！！快排思想：先找一个中间的标靶，然后遍历数组将>标靶的元素放到标靶右边将< 标靶的元素放到标靶左边然后递归的排序左右两边 public static void quick_sort(int[] nums ,int left ,int end){ if(left >= end) return; int pivot = nums[left+end >>1]; int i = left -1;

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode reverseList(ListNode head) { ListNode next = null; .

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。函数 myAtoi(string s) 的算法如下：读入字符串并丢弃无用的前导空格检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。将前面步骤读入的这些数字转换为整数（即，“123” -

力扣 243场竞赛–第二题class Solution { public String maxValue(String str, int target) { /** 思路： 从前向后遍历 如果是正数>0 ，那我们插入的位置应该是第一个 <x的位置 所以我们寻找第一个比x小的元素，在它前面插入 如果是负数<0 ，那我么插入的位置应该是第一个 >x的前面的位置 所以我们寻找第一个比大于的元

思路如下：遍历一遍数组其中过程设立左右两个指针进行判断遍历我们设置 left为做指针 right为右指针因为已经有序了 当nums[i]为正数的时候就不可能 在以后的数字中找到和为0nums[i]+nums[left]+nums[right] =0 添加结果 <0说明左边太小 left++ >0说明右边太大 right–注意为零后我们仍然不能就此退出当前，有可能下面还有使结果为零的组合所以任然要继续left和right指针移动 但是当有重复的要掠过因为if(i&.

class Solution { public int numDecodings(String s) { /* 动态规划： 我们解密字符串的方式 前i个指的是 0 到 i-1 设总共有i个字符 s的前i个字符的解密方式有：最后一个字符为下表i-1 1.最后一个字符进行解密方式 + 前i-1个字符进行解密的和（0到 i-2） 前提下标i-1的字符可以正常解密 2.最后两个字符进行解.

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。‘.’ 匹配任意单个字符‘*’ 匹配零个或多个前面的那一个元素所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。我们做这道题的整体思路：根据题意得知：我们要判断给定输入串s ,和模式串的匹配：若当前的输入字符不是 * ，并且和给定模式的字符匹配的时候，我们就可以看这个字符之前的那些字符是否匹配，如果匹配就是true，否则就是false ,这就引出了我们的动态规划的思想判断当前字符是否匹配

深度优先遍历，寻找到每一堆联通的东东，进行计数class Solution { public int numIslands(char[][] grid) { /* 思路： 深度优先遍历 我们寻找每一个'1'相连的所有的岛屿的数量，遍历到一个岛屿的堆，就将访问过的设置为0 */ int res = 0 ; if(grid.length == 0 || grid[0].length ==

class Solution { public void solve(char[][] board) { /*大雪菜哥的想法也是妙啊！ 我是真的粉了,等我有钱了，，一定去支持你！！！ 思路： 首先我们遍历四条边，在四条便上面寻找为‘O’的点 顺着为O的点开始上下左右深度遍历，所是能够遍历到的点都是不能够被包围的 我们记下来然后整个数组再遍历一遍，我们所有没有被记录下来的点就是能够被包围消灭的了 .

原题链接思路：遍历数组，进行扫描，两两字符串比较，取得公共子串，作为目前的最优解，拿上一次的最优解的公共子串和下一个字符串继续取公共部分！！！class Solution { public String longestCommonPrefix(String[] strs) { if(strs.length == 0||strs ==null) return ""; //遍历数组，进行两两取公共前缀 String prefix=strs[0];

class Solution { public boolean isValid(String s) { Stack<Character> stack = new Stack<>(); char[] chars=s.toCharArray(); for(char c: chars){ if(c == '(') stack.push(')'); else if (c=='{') st.

class Solution { public int[] searchRange(int[] nums, int target) { /** 思路： 查找第一次 >= target的为止 查找最后一次<=target的为止 */ if(nums.length ==0 ) return new int[]{-1,-1}; int l = 0 ; int r =.

思路：二分查找，查找数组元素值 <= 旋转数组中最后一个元素的组左边的为止的数，就是最小的元素class Solution { public int findMin(int[] nums) { int l = 0 ; int r = nums.length -1; int target = nums[r]; while(l < r){ int mid = l+r >>1; i.

两数之和问题源链接–来自leetcode问题描述：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。示例：给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1]代码：暴力法class Solution { public int[]

今天又学了一招优先队列/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next =

题目来源：力扣罗马数字转换思路：将数值和符号利用键值对的形似存储，利用Linkedhashmap的有序，从大到小找到最适合的数与给定的数值相减，因为默认是寻找从左到右最大到最小，所以每一步都贪心最好了class Solution { public String intToRoman(int num) { String ans=""; LinkedHashMap<Integer, String> map = new LinkedHashMap<

class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); ListNode cur = pre; int carry = 0; while(l1 != null || l2 != null) { int x = l1 == null ? 0 : l1.val;

思路：前后指针维持一定的距离，然后维持这个距离一起向前跑步，当前指针到了末尾那么后面那个指针所指向的就是我们要操作的重点在于yummy指针的预设/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * L.

链接在下面，具体有大佬讲解！！！链接：详细讲解！！！大佬讲解，学习一下来源：力扣（LeetCode）public class KMP { private int[][] dp; private String pat; public KMP(String pat) { this.pat = pat; int M = pat.length(); // dp[状态][字符] = 下个状态 dp = new int[M]

class Solution { /* 分析： 最值型动态规划 max min 计算型动态规划 ++ 存在型的动态规划 and or 分析状态： 跳到最后一个位置的前提是： 能够跳到前一步的位置，并且前一步的位置的值能够跳到最后就可以 当然可能有多个结果可以让我们跳到最后 我们这里是存在型的动态规划 子问题： 那我们就转化为了如何跳到前一个位置 分析边界条件： 第一个位置 f[0].

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。利用字符串的遍历来对比，双指针移动来比较是否相等class Solution { public boolean isPalindrome(int x) { if (x < 0) return false; String stra = String.valueOf(x

问题源于力扣无重复字符的最长子串给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。示例 1:输入: “abcabcbb”输出: 3解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。示例 2:输入: “bbbbb”输出: 1解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。示例 3:输入: “pwwkew”输出: 3解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。请注意，你的答案必须是 子串 的长度，“pwke” 是一个子

颠倒给定的 32 位无符号整数的二进制位思路public class Solution { // you need treat n as an unsigned value public int reverseBits(int n) { int ans= 0; for(int i = 0; i < 32; i++){ ans <<=1; ans += n&1;

原题链接特点：字符串的从前向后代表的数应该是逐渐减小的，所以我们不仅要考虑单个字符代表的数，还要向后多看一个，以免出现两个字符组合的情况，但是两个字符的组合特点，前一个字符单独代表的数一定比后面那个单独代表的数值小，我们利用这一点判断两个字符组合的情况时间空间复杂度过高，我的算法并不好，大家借鉴的看一下吧！！！class Solution { public int romanToInt(String s) { Map <String ,Integer> map =

我要进阿里！！！努力！！！思路： 队列的方法解决 我们声明一个队列来进行循环的拿出增加和修改 先将字母数字的对应关系放入到Map中 描述 数字字符 和 对应的字符串数组 的关系 遍历数字串 取出每一个元素 将对应的字符串的数组拿出 跟队列里面的元素进行一一组合 再重新放入 知道遍历完数字串 结束返回代码：class Solution { public List<Strin

思路：固定一端后使用双指针不断探索中间的最优解复杂度O（n^2）class Solution { public int threeSumClosest(int[] nums, int target) { Arrays.sort(nums); int ans=nums[0] + nums[1]+nums[2]; for(int i = 0; i< nums.length;i++){ int start = i+1;

class Solution { public boolean check(String str , String time){ for(int i = 0 ; i < time.length(); i++){ if( !(str.charAt(i) == time.charAt(i)|| time.charAt(i)=='?')) return false; } return true; } p.

思路：外层两层循环每次固定两个数+双指针 遍历中间的数 不断寻找最优答案class Solution { public List<List<Integer>> fourSum(int[] nums, int target) { //双重循环 + 双指针遍历啊 List<List<Integer>> list = new ArrayList<List<Integer>>(); .

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { .

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { .

leetcode周赛 243–第一题class Solution { public boolean isSumEqual(String firstWord, String secondWord, String targetWord) { String first= ""; String second = ""; String target = ""; for(int i = 0 ; i < firstWord.length()

一看就会，一写就废的递归！！！/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.nex

不同路径class Solution { public int uniquePaths(int m, int n) { /* 如何做？ 动态规划 重叠子问题 计算型动态规划 确定状态： 到 右下角(m,n)的格子的路径 = 到（m-1,n）的路径 + 到(m,n-1) 的路径和 思考为什莫？ 1.判断有无重复 ？ 2 .判断有无遗漏？ 我们每次智能向右 向下走 所以到达某个格子一定是没有重复的

class Solution { public int compareVersion(String s1, String s2) { /* 比较两个字符串的版本号 首先寻找两个字符串中两个.中间的那一段连续的数字 然后将其转化为 整数int类型 然后进行比较 */ int x = 0 ; int y = 0 ; int i ; i..

class Solution { public int[][] floodFill(int[][] image, int sr, int sc, int newColor) { /*1 1 1 2 2 2 1 1 0 ----> 2 2 0 1 0 1 2 0 1 思路还是深度优先搜索 找和原来位置相同的数一直找下去一篇 替换成新的数 .

class Solution { public String countAndSay(int n) { /* 描述当前的字符串生成新的字符串 如何描述？ 我们首先看连续的相同的字符的个数，统计次数，加到新的描述串 */ String init = "1"; for(int i = 0 ; i < n-1 ; i++){//总共进行n次描述 .

leetcode-最长回文子串问题源链接给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。示例 1：输入: “babad”输出: “bab”注意: “aba” 也是一个有效答案。示例 2：输入: “cbbd”输出: “bb”动态规划方法：class Solution { public String longestPalindrome(String s) { if (s.length() == 0)

class Solution { public String reverseWords(String s) { //整体思路 每个单词反转 然后整个字符串再反转就可以得到答案 //反转字符串 使用Stringbuilder的reverse方法 /* 思路：首先找到不是以空格开头的字符串的起点 然后向下寻找一段连续的非空格的单词 反转 拼接 最后整体反转 */ .