qq_33300570的博客

从二维数组中找字符串是否存在，而且同一个元素不能重复使用。这是字符串匹配类型题目，要记住方法。将二维数组简化成字符串，也就是字符串匹配了（依次遍历每个元素，将其当做开头，开始匹配）。4、从二维数组哪个字符开始匹配呢？遍历二维数组，依次将字符当做第一个字符跟字符串开始匹配。3、其实就是一个字符一个字符地匹配，当前字符相同，则向四周匹配。2、不能重复使用，想到用一个数组来标记每个元素的使用情况。1、可以想到的是使用回溯法。

【代码】【算法题】有环无向图，寻找导致形成环的最后一条边。

【代码】【算法题】一亿以内中文数字转int & int转中文数字。

若发现下标为 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的数组，返回最长自增子序列的长度。

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

力扣136 137

力扣1422

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

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

public class Test19 { public static void main(String[] args) { String a = "1010"; String b = "1011"; System.out.println(addBinary(a,b)); } public static String addBinary(String a, String b) { StringBuffer s1 = .

路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。路径和 是路径中各节点值的总和。给你一个二叉树的根节点 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 void inOrderRecur(Node root) { if (root == null) { return; } inOrderRecur(root.left); System.out.print(root.data + " -> "); inOrderRecur(root.right); }

递归： public void preOrderRecur(Node root) { if (root == null) { return; } System.out.print(root.data + " -> "); preOrderRecur(root.left); preOrderRecur(root.right); }非递归：

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 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)

十亿个乱序不重复的数字，输出没有出现过的数字，例如 {0,1,2,3,5,6,7,8,9,10} 中4没有。这是一个阿里算法题，当时脑子没有想到bitmap，实际中没用到的真的是想到几率小，给自己敲响警钟，这道题不难。bitmap处理几部占很多内存，又很快。o(n)就够。众所周知1byte=8位，所以1byte上的每一位都可以记录一个值的状态,0可以表示不存在，1表示存在。用与和或操作来实...

public class LianXuMaxSum { public static void main(String[] args) { int[] nums = {-3, -2, -8, -1, -1, -10, -9, -1}; System.out.println(max(nums)); } public static int max(int[] nums) { int max = nums[0]; int .

public class JiaoTiPrint { public static void main(String[] args) throws InterruptedException { Object lock = new Object(); OneThread oneThread = new OneThread(lock, 1000); ZeroThread zeroThread = new ZeroThread(lock, 1000); .

class Node { int num; Node next; public Node(int num) { this.num = num; }}public class LinkFirstNode { public static void main(String[] args) { Node node1 = new Node(1); Node node2 = new Node(2); Nod.

public class ReverseString { public static void main(String[] args) { String str="I am a student."; char[] chars=str.toCharArray(); //first reverse reverse(chars,0,chars.length-1); System.out.println(String.va.

public class JavaTest1 { public static void main(String[] args) { Node head = new Node(0); Node node1 = new Node(1); Node node2 = new Node(2); Node node3 = new Node(3); head.setNext(node1); node1.setNext(node2); node2.setNext(node3); .

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...

public class JianGeMaxSum { public static void main(String[] args) { int[] nums = {3, 2, 8, 1, -1, -10, 9, -1}; System.out.println(max(nums)); } public static int max(int[] nums) { if (nums.length == 0) { .

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...