qq_33300570的博客

若发现下标为 nums[i] - 1nums[i]−1 的数字已经是负数，说明之前出现过同样的数字 nums[i]nums[i]，即找到了重复数字；从起始位置进行遍历，每次将下标为 nums[i] - 1nums[i]−1 的数字取反；当遍历到值 nums[i]nums[i] 为负数，需要忽略其负号。需要注意的是，题目中已经声明数字最多出现两次，所以这个方法可行。原地修改数组——取反。

在数组中找到一个峰值数字，‌其中峰值定义为比其相邻元素大的元素，‌可以使用二分查找算法来实现时间复杂度为O(log n)。以下是一个Java示例，‌演示如何在一个整数数组中找到任意一个峰值数字：‌。

在Java中，‌解决“最长无重复子串”的问题是一个常见的算法题。‌这个问题可以通过滑动窗口的方式来解决，‌具体步骤如下：‌。以下是一个Java实现的示例代码：‌。

Explanation: 最长自增子序列是[2,3,7,18,19]，长度为5。Explanation: 最长自增子序列是[2,3,7,101]，长度为4。给定长度为N的数组，返回最长自增子序列的长度。

给定一个排序链表，节点值均为正数，删除所有含有重复数字的节点,只保留原始链表中没有重复出现的数字。

最近阿里发布的 Java开发手册中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险Executors利用工厂模式向我们提供了4种线程池实现方式，但是并不推荐使用，原因是使用Executors创建线程池不会传入这个参数而使用默认值所以我们常常忽略这一参数，而且默认使用的参

using index ：性能好，索引覆盖，只从索引文件中获取，无需回表查询using where：在查找使用索引的情况下，需要回表去查询所需的数据using index condition：在5.6版本后加入的新特性:使用了ICP（Index Condition Pushdown）技术，在存储引擎层根据索引尽量过滤符合where条件的记录，减少返回server层的记录。是需要回表的。eg:有索引(a, b, c) select a,c,d from TABLE where a=1000 and c

力扣136 137

【算法】二叉树后序遍历（递归+非递归）

Java实现单链表的快速排序和归并排序 - morethink - 博客园在一般实现的快速排序中，我们通过首尾指针来对元素进行切分，下面采用快排的另一种方法来对元素进行切分。我们只需要两个指针p1和p2，这两个指针均往next方向移动，移动的过程中保持p1之前的key都小于选定的key，p1和p2之间的key都大于选定的key，那么当p2走到末尾时交换p1与key值便完成了一次切分。图示如下：public class Test23 { public static void mai

public class Test17 { //打印二叉树中和为某一个值的所有路径 public static ArrayList<ArrayList<Integer>> pathList = new ArrayList<>(); public static ArrayList<Integer> path = new ArrayList<>(); public static ArrayList<Array.

public class Test21 { //二叉树，left right parent父节点指针 //返回输入节点在这个树中序遍历序列里下一个节点 static class TreeNode { int val; TreeNode parent, left, right; public TreeNode(int val, TreeNode parent, TreeNode left, TreeNode right) { .

给定 BST [1,null,2,2], 1 \ 2 / 21 2 3 4 5  返回 [2]提示：如果众数超过1个，不需考虑输出顺序public class Test20 { static class TreeNode { int val; TreeNode left, right; public TreeNode(int val, TreeNode left, TreeNod

guava超时及刷新机制首先看一下三种基于时间的清理或刷新缓存数据的方式：expireAfterAccess:当缓存项在指定的时间段内没有被读或写就会被回收。expireAfterWrite：当缓存项在指定的时间段内没有更新就会被回收。refreshAfterWrite：当缓存项上一次更新操作之后的多久会被刷新。考虑到时效性，我们可以使用expireAfterWrite，使每次更新之后的指定时间让缓存失效，然后重新加载缓存。guava cache会严格限制只有1个加载操作（load.

路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。路径和 是路径中各节点值的总和。给你一个二叉树的根节点 root ，返回其 最大路径和 。输入：root = [-10,9,20,null,null,15,7]输出：42解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42以A为根节点的这棵树的最大路径和可.

输入：4，5。输出：2。输入：4，9。输出：1.从root开始遍历，如果n1和n2中的任一个和root匹配，那么root就是LCA。 如果都不匹配，则分别递归左、右子树，如果有一个 key（n1或n2）出现在左子树，并且另一个key(n1或n2)出现在右子树，则root就是LCA. 如果两个key都出现在左子树，则说明LCA在左子树中，否则在右子树。public class Test16 { static class Node { int val; ...

给定链表与数字K，根据每个节点的位置，对K取余，根据模后的值从小到大重组链表，同余数值的节点保持元素节点相对位置不变。要求只遍历一次链表输入：0-1->2->3->4k=2输出：0->2->4->1->3输入：0-1->2->3->4->5->6->7k=3输出：0->3->6->1->4->7->2->5public class

给定一个由若干 0 和 1 组成的数组 A，我们最多可以将 K 个值从 0 变成 1 。返回仅包含 1 的最长（连续）子数组的长度。输入：A = [1,1,1,0,0,0,1,1,1,1,0], K = 2输出：6输入：A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3输出：10方法一：滑动窗口法，时间复杂度O(n)思路：其实，将K个0转换为1之后，连续的1组成的子数组长度为最长，这个问题可以转换为：在数组中取一个子数组

慢走了a+x,快的是慢的2倍，得出2(a+x) = a + nc + x， n为快指针走了环的圈数化简，2a + 2x = a + nc + xa + x = nc a = nc - x a = (n-1)c + (c - x) a = kc + (c-x) ， k为常量n-1即，一个指针从头部走a步，另一个从相遇节点走k次环再走(c-x)剩余步数，即是入口节点。...

import org.apache.commons.lang.StringUtils;public class Test8 { public static final int NINE = 9; public static final char ZERO = '0'; public static void main(String[] args) { String b = "8951331230000000000000000000000001"; .

public class Test7 { // 输入： 一个长度为n的整数数组input// 输出： 一个长度为n的数组result，满足result[i] = input数组中，除了input[i] 之外的所有数的乘积，不用考虑溢出// 不能使用除法// 例如 input {2, 3, 4, 5} output: {60, 40, 30, 24} public static void main(String[] args) { int[] i.

public class TestD {// 1// 2 2// 3 4 4 3 public static void main(String[] args) { } public static boolean judgeTreeIsMirror(TreeNode head) { if (head == null) { return tru.

public class Test6 { public static void main(String[] args) { System.out.println(getUglyNumber(10)); } public static int getUglyNumber(int n) { if (n <= 0) { return 0; } int[] arr = new int[n]; .

import com.dianping.cat.util.StringUtils;import java.util.Arrays;import java.util.Comparator;public class Test5 { public static void main(String[] args) { int[] input = {3, 32, 321}; System.out.println(joinToMinNumber(input)); .

public class Test4 {// 我的想法是，每一次求一个位置上的1的个数，第一轮先求个位上的1出现的个数，第二轮求十位上1出现的个数，以此类推...这样就能保证每个位置上的1都数了一次，并且不会出现多次重复数的情况。现在以其中的某一轮循环为例：假设现在有一个数 n = abcd(a,b,c,d分别表示0 ～ 9中的任意数)。我们本次循环要数的是b所在位置上1出现的个数。也就是要求满足X1XX这个样子的数的个数。我们可以将abcd分成两个部分，一部分在b前面即a，另一部分在b后面即cd.

public class QuickSort { public static int partition(int[] data, int low, int high) { int key = data[low]; while (low < high) { while (data[high] >= key && low < high)

思路：总体类似二分查找，部分类似快排。将小于当前元素的数，都放到元素左侧。返回位置，当位置大于K-1时，在左侧找；反之在右侧找。找到第K-1个位置的数后，输出前k个即可。public class Test3 { public static void main(String[] args) { int[] arr = {3, 4, 6, 5, 3, 2, 1}; int k = 3; findKData(arr, k); } pu

public class Test { public static void main(String[] args) { int[] chars = {1, 2, 1, 4, 1, 6, 1, 8, 1, 10, 1}; System.out.println(moreThanHalfNum(chars)); } public static int moreThanHalfNum(int[] nums) { int count = .

题目描述：输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输 入字符串 abc,则打印出由字符 a,b,c 所能排列出来的所有字符串 abc,acb,bac,bca,cab 和 cba。 思路：将当前位置的字符和前一个字符位置交换，递归。public class Test { public static void main(String[] args) { char[] chars = {'a', 'b', 'c'}; List&

public static void main(String[] args) { //1 2 3 4 //10 11 12 5 //9 8 7 6 //输出：1 2 3 6 9 8 7 4 5// int[][] arr = {{1, 2, 3, 4}, {10, 11, 12, 5}, {9, 8, 7, 6}}; //1 2 3 //8 9 4 //7 6 5/.

public static int partition(int[] arr, int left, int right, int key) { if (left > right) { return -1; } int mid = (left + right) / 2; if (arr[mid] == key) { return mid; } if (...

思路：快排变种public class ArrKBigger { public static void main(String[] args) { int arr[] = {9,8,7,6,5,4,3,2,1,0}; int k = 6; System.out.println(quickSort(arr, 0, arr.length-1, k)); } public static int quickSort(int[] arr,

public class JiaoJi { static List<Integer> list1 = Lists.newArrayList(1, 2, 3, 3, 4, 6, 7, 7, 8, 9, 12); static List<Integer> list2 = Lists.newArrayList(3, 3, 4, 5, 6, 6, 10, 10, 13); public static void main(String[] args) { .

public class DeadLock { public static void main(String[] args) { Object object1 = new Object(); Object object2 = new Object(); MyThread myThread1 = new MyThread(object1,object2,true); MyThread myThread2 = new MyThread(.

public class ABC_Synch { public static class ThreadPrinter implements Runnable { private String name; private Object prev; private Object self; private ThreadPrinter(String name, Object prev, Object self) { .

public class MergeSort { public static void main(String[] args) { int[] data = {8, 7, 7, 9, 2, 5, 1, 4, 3}; mergeSort(data, 0, data.length-1); for(int i=0;i<data.length;i++){ System.out.print(data[i] + " "); .

public ListNode removeNthFromEnd (ListNode head, int n) { // write code here Stack<ListNode> stack = new Stack(); ListNode tmp, nhead; nhead = new ListNode(-1); nhead.next = head; tmp = nh...

import org.apache.commons.collections.CollectionUtils;import org.eclipse.jetty.util.BlockingArrayQueue;import scala.concurrent.forkjoin.LinkedTransferQueue;import java.util.ArrayList;import java.util.Queue;import java.util.concurrent.ArrayBlock...