历乱的日记簿

1、删除链表的倒数第N个节点注意三个点：1、假如链表为空，那么自然返回空；另外，假如只有一个节点，那么也应该直接返回空；2、slow应该停在被删除节点的前一个节点的位置；3、假如n在还>0时fast已经为空，那么说明要删除的节点是头结点，应该返回head.next。（例如1->2->3，删除倒数第3个节点）class Solution { public ListNode removeNthFromEnd(ListNode head, int n) {

1、x的平方根实现 int sqrt(int x) 函数。注意溢出的情况class Solution { public int mySqrt(int x) { if(x < 2){return x;} int left = 0,right = x; while(left <= right){ int mid = left +(right - left)/2; if(x/mid >

1、最长连续序列class Solution { public int longestConsecutive(int[] nums) { if(nums.length == 0){return 0;} Set<Integer> numsSet = new HashSet<>(); for(int i = 0;i < nums.length;i++){ numsSet.add(nums[i]);

1、最小的K个数方法一：快排方法二：归并方法三：堆//第二遍用快排class Solution { public int[] getLeastNumbers(int[] arr, int k) { if(k >= arr.length){return arr;} if(k == 0){return new int[0];} quickSort(arr,0,arr.length-1); return Arrays.co

1、删除链表的节点class Solution { public ListNode deleteNode(ListNode head, int val) { if(head == null){return head;} ListNode pre = new ListNode(0); pre.next = head; ListNode cur = pre; while(cur!=null){ if

1、二进制中 1 的个数public class Solution { // you need to treat n as an unsigned value public int hammingWeight(int n) { int cnt = 0; while(n !=0){ n &= (n-1); cnt++; } return cnt; }}2、数组

1、数组中重复的数字class Solution { public int findRepeatNumber(int[] nums) { int n = nums.length; int[] num = new int[n]; for(int i = 0;i < nums.length;i++){ num[nums[i]]++; if(num[nums[i]] > 1){

1、矩阵中的路径class Solution { public boolean exist(char[][] board, String word) { char[] words = word.toCharArray(); for(int i = 0; i < board.length; i++) { for(int j = 0; j < board[0].length; j++) { if(

1、斐波那契数列（动态规划版）class Solution { public int fib(int n) { if(n == 0 || n == 1){return n;} int[] dp = new int[n+1]; dp[0] = 0; dp[1] = 1; for(int i = 2;i <= n;i++){ dp[i] = dp[i-1]+dp[i-2];

1、LRU缓存机制2、反转链表整个链表翻转可以1、头插法；2、翻转指针；3、递归4、用栈class Solution{ public ListNode reverseList(ListNode head){ if(head == null||head.next ==null){return head;} ListNode pre = new ListNode(0); pre.next = head; ListNode

1、零钱兑换分析：用回溯用的不好的话很容易超时，最好是用动态规划。在这里插入代码片

1、乘积最大子数组分析：因为有负数的存在，最大值随时可能变成最小值，最小值也随时可能变成最大值。因此需要保存最小值，碰到负数的时候需要将最大值和最小值交换。2、零钱兑换3、根据身高重建队列我愿称之为拐弯抹角第一名。分析：首先根据身高进行排序，然后依次根据k值来确定插入的位置（假如k为0，说明该数对是当前的第一个数对，假如为3，说明该数对的前边应该有3个数对）class Solution { public int[][] reconstructQueue(int[][]

1、K个一组翻转链表2、无重复字符的最长子串class Solution { public int lengthOfLongestSubstring(String s) { int max = 0; LinkedList<Character> list = new LinkedList<>(); for(int i = 0;i < s.length();i++){ if(!list.contai

1、合并区间分析：首先要根据区间左界的大小排序，排序之后主要就是判断：该区间的右端大于后一个区间的左端class Solution { public int[][] merge(int[][] arr) { //首先按照区间的上界排序 if(arr == null || arr.length<=1){return arr;} List<int[]> list = new ArrayList<>();

一、链表专题1、反转链表（剑指offer 24）分析：整个链表翻转有两种方法——头插法 和 指针反转两者都要注意一个置空的操作，避免出现环**头插法图解：**//头插法class Solution { public ListNode reverseList(ListNode head) { if(head == null || head.next == null){return head;} ListNode pre = new ListN

1、二叉搜索树的第k个结点输出第k小的结点分析：1、中序遍历二叉搜索树是节点值的升序排列2、利用ArrayList的随机存取//中序遍历public class Solution { ArrayList<TreeNode> res = new ArrayList<>(); TreeNode KthNode(TreeNode pRoot, int k) { if(pRoot == null || k == 0){return null;}

第一题：矩阵元素查找分析：从右上角元素X(n,m)开始找，因为这样的话不用判断边界import java.util.*;public class Solution { public int[] findElement(int[][] mat, int n, int m, int x) { //从左上角出发(这样的话，不用判断边界) int i = 0,j = m-1;//假如比左上角大，那么i++(往下);假如比左上角小，那么j--(往左)

1、判断二叉树是否为平衡二叉树分析：方法一：最直观的做法是，定义一个求高度的函数，然后放在主函数判断根节点的左右子树是否也符合高度差<=1方法二：剪枝，从小到上遍历树。public class Solution { public boolean IsBalanced_Solution(TreeNode root) { if(root == null){return true;} return Math.abs(dfs(root.left)-dfs(root.right)) &

【第一题】括号生成分析：class Solution { List<String> res = new ArrayList<>(); public List<String> generateParenthesis(int n) { if(n <= 0){ return res; } getParenthesis("",n,n)

【第一题】礼物的最大价值【第二题】二叉搜索树与双向链表其实就是中序遍历，将节点串在一起.class Solution{// 保存中序遍历的结果 private List<Node> list = new ArrayList<>(); public Node treeToDoublyList(Node root){ if(root == null){return null;} inOrder(root); Node p = list.get(0); No

【第一题】三个数的最大乘积分析：注意注意！有负数出没！！方法1：1.最小的两个负数相乘，再乘以最大的正数，得出sum1；2.直接让三个最大的正数相乘，得出sum2；3.比较sum1和sum2，返回更大的那个。时间主要消耗在了这个排序上面。方法二：线性扫描（找最小的两个数和最大的三个数）//执行用时：12 ms, 在所有 Java 提交中击败了69.75% 的用户//内存消耗：39.8 MB, 在所有 Java 提交中击败了71.82% 的用户class Solution { p

【第一题】前序遍历构造二叉搜索树分析：首先思路是这样的，每从数组中取出一个数，就从根节点开始比较，假如比根节点小，那么就从根节点的左子树找位置，否则在右子树找位置，直到找到一个空位子插入。现在问题在于,没有递归向下找节点，而是一味代替根节点的左右子树！class Solution { TreeNode pre; public TreeNode bstFromPreorder(int[] preorder) { if(preorder.length == 0){retu

【第一题】二叉树的层平均值分析：涉及到一层一层，应想到层序遍历（Queue）//执行用时：2 ms, 在所有 Java 提交中击败了98.96% 的用户//内存消耗：40.3 MB, 在所有 Java 提交中击败了70.87% 的用户class Solution { public List<Double> averageOfLevels(TreeNode root) { Queue<TreeNode> q = new LinkedList<&g

【第一题】生成交替二进制字符串的最少操作数分析：方法一：双指针方法二：直接和前一个字符异或，假如为1，则该位取反注意，这里是字符串，不能更改，并且也不能进行位运算!!另外，是输出修改的最少操作数！所以不仅要跟0101…比较，还得跟1010…比较。//因为要取到最小操作数，因此不仅要跟10101比较，还得跟01010比较。//执行用时：3 ms, 在所有 Java 提交中击败了85.14% 的用户//内存消耗：38.6 MB, 在所有 Java 提交中击败了34.72% 的用户class S

【第一题】唯一元素的和List item分析：方法一：去重两个结构，哈希表和集合；方法二：排序比较（双指针）方法三：桶排序但是要注意的是，重复的话，要把之前加上的减掉，例如说之前出现了1，加进了sum，后边再出现1，就要减掉，而且之后再出现，就不能加。因此有两种解决方法：1.哈希表；2.集合（存储重复过的元素）；//哈希表好慢！//执行用时：2 ms, 在所有 Java 提交中击败了34.95% 的用户//内存消耗：36.3 MB, 在所有 Java 提交中击败了14.31% 的用户

【第一题】第三大的数分析：如何一次遍历找出最大的三个值，或者最小的三个值——传递操作。//执行用时：1 ms, 在所有 Java 提交中击败了88.20% 的用户//内存消耗：38.6 MB, 在所有 Java 提交中击败了13.50% 的用户class Solution { public int thirdMax(int[] nums) { if(nums.length == 1){ return nums[0]; }

【第一题】是否所有的1都至少相隔k个元素分析：双指针。两个指针指向相邻的两个1，下标相减假如都>3，那么符合。//不是吧阿sir，这么慢吗？//执行用时：3 ms, 在所有 Java 提交中击败了11.40% 的用户//内存消耗：48.3 MB, 在所有 Java 提交中击败了61.52% 的用户class Solution { public boolean kLengthApart(int[] nums, int k) { if(nums.length == 1){

【第一题】合并两个有序数组分析：方法一：双指针，倒序比较，倒序插入；方法二：将nums2的数存入nums1，然后排序第1种方法，假如nums1.length > m+n的话就不行。 输入用例： [1,2,3,0,0,0,0] 4 [2,5,6] 3 最后的结果是[1,2,3,0,2,5,6]，虽然说给出的答案也是这个，但是好像并不是有序的//执行用时：1 ms, 在所有 Java 提交中击败了25.19% 的用户//内存消耗：38.4 MB, 在所有 Java 提交中击败了77.02%

【第一题】丢失的数字分析：1.位运算异或。2.求和。由1到n项的数列和-目前的sum3.哈希表/桶//1.位运算异或。//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户//内存消耗：38.9 MB, 在所有 Java 提交中击败了63.68% 的用户class Solution{ public int missingNumber(int[] nums){ int res = nums.length; for(int i =

【第一题】重新排列字符串分析：方法一：直接按照indices数组中的顺序将其存入新数组即可；方法二：哈希表，存储字符及字符顺序的映射关系。class Solution { public String restoreString(String s, int[] indices) { char[] ret = new char[s.length()]; for(int i = 0;i < indices.length;i++){ r

【第一题】稀疏数组搜索分析：有序数组+查找——>立即推 二分查找。//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户//内存消耗：38.5 MB, 在所有 Java 提交中击败了41.04% 的用户class Solution { public int findString(String[] words, String s) { int left = 0,right = words.length-1; return find

【第一题】棒球比赛分析：//执行用时：2 ms, 在所有 Java 提交中击败了92.45% 的用户//内存消耗：37.5 MB, 在所有 Java 提交中击败了84.81% 的用户class Solution { public int calPoints(String[] ops) { int[] arr = new int[ops.length]; int i = 0; for(String s:ops){ swi

【第一题】删除链表的节点分析：双指针。//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户//内存消耗：37.9 MB, 在所有 Java 提交中击败了70.57% 的用户class Solution { public ListNode deleteNode(ListNode head, int val) { if(head == null){ return head; } ListNode

【第一题】返回倒数第k个节点分析：返回倒数第k个节点——先让一个快指针走k步，然后，慢指针出发，两者一起往前，直到快指针达到终点，此时慢指针指向的节点即为倒数第k个。//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户//内存消耗：36.3 MB, 在所有 Java 提交中击败了33.12% 的用户class Solution { public int kthToLast(ListNode head, int k) { ListNode i = h

【第一题】独一无二的出现次数分析：方法1：构建哈希表<Integer,Integer>，表示出现次数与元素的映射。将出现次数假如集合，假如有相同的元素在集合中，就会添加失败public boolean uniqueOccurence(int[] arr){ Map<Integer,Integer> map = new HashMap<>(); for(int i = 0;i < arr.length;i++){ map.put(arr[i],map.

【12.18】————————————————————————————————————————————【第一题】只出现一次的数字分析：不需要额外空间的方法，就往位运算上想。//异或//执行用时：1 ms, 在所有 Java 提交中击败了99.91% 的用户//内存消耗：38.6 MB, 在所有 Java 提交中击败了80.24% 的用户class Solution{ public int SingleNumber(int[] nums){ int single = 0; for(i

【12.14】第一题：二进制求和分析：手动模拟进位。难点:1.假如两个数位数不相同，需要高位补零。2.只有高位对齐，如何让他们低位对齐？3.buf append的是字符不是数字，如何进行转换？class Solution { public String addBinary(String a, String b) { int c = 0; StringBuffer buf = new StringBuffer(); int n = Math

【第一题】验证回文字符串II分析：双指针，i从开头遍历，j从末尾遍历，一个一个比较，碰到不相同的字符跳过，继续往前，碰到第二个不相同的字符，返回false。这里问题就在于，当字符不相等的时候，是哪个指针往前走？分为两种情况：1.i向前走，判断是否为回文；2.j向前走，判断是否为回文。这里可以设计成一个递归判断。//执行用时：9 ms, 在所有 Java 提交中击败了56.24% 的用户//内存消耗：38.8 MB, 在所有 Java 提交中击败了94.35% 的用户//Q:为啥是(i,j

【11.30】【第一题】旋转数字分析：2、5、6、9这些数都可以旋转180度，并且旋转之后的数字不是它本身。有效数字：0、1、2、5、6、8、9无效数字：3、4、7万能数字：2、5、6、9有效数字-万能数字=搭配数字：0、1、8情况如下：1）含有无效数字，则不是好数；2）只含有万能数字，则一定是好数；3）万能数字+搭配数字的组合，则一定是好数。总结： 第一点：不能含有无效数字； 第二点：至少含有一个万能数字。方法一：消消乐替换。用字符串替换的方法会很慢，但是简洁容易理解；另外也可以用

【11.23】第一题：生成每种字符都是奇数个的字符串分析：假如给定的整数为奇数，那么直接输出n个a即可；假如给定的整数为偶数，则输出（n-1）个a，一个b即可。这道题的可扩展性太高，可任意发挥。//执行用时：1 ms, 在所有 Java 提交中击败了96.17% 的用户//内存消耗：35.8 MB, 在所有 Java 提交中击败了84.92% 的用户class Solution { public String generateTheString(int n) { c