xiaomagezuishuai的博客

判断链表中是否有环。 用快慢指针的原因，快指针速度为2的原因，因为如果有环的话，一定会相遇，快指针的速度为2，一定会相遇。 假设有环的情况下，满指针到达成环的入口时，快指针的位置距离入环节点距离为s。 相遇时，快、慢指针走的次数为t， 距离入环节点的距离为：s+kt 慢指针距离入环节点的距离：t s+kt-t=nR。 t=(nR-s)/k-1 ，如果k等于2时，则t一定能整除，t一定是个整数 public boolean hasCycle(ListNode head) { .

循环不变式用于理解和证明算法的正确性。实际上，循环不变式并不是狭义上的一个式子，而是一个在命题，一个在算法的起始状态、运行过程中和算法结束时始终保持为真的一个命题。通过下文中的例子可以更加清晰的认识到循环不变式的意义，下面是循环不变式的三条性质： 初始化：循环的第一次迭代之前，它为真。 保持：如果循环的某次迭代之前它为真，那么下次迭代之前它仍为真。 终止：在循环终止时，不变式为我们提供一个有用的性质，该性质有助于证明算法时正确的。 注意：循环不变式的前两条性质类似于数学归纳法，证明了一个基本情况和一个归纳

编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀，返回空字符串""。 方法二的时间复杂度值得仔细推敲，https://www.zhihu.com/question/22393997 class Solution { public String longestCommonPrefix(String[] strs) { //方法一，列式比较 // int length = strs[0].length(); // StringB.

罗马数字包含以下七种字符:I，V，X，L，C，D和M。 字符 数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000 例如， 罗马数字 2 写做II，即为两个并列的 1。12 写做XII，即为X+II。 27 写做XXVII, 即为XX+V+II。 通常...

罗马数字包含以下七种字符：I，V，X，L，C，D和M。 字符 数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000 例如， 罗马数字 2 写做II，即为两个并列的 1。12 写做XII，即为X+II。 27 写做XXVII, 即为XX+V+II。 ...

两数之和 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 思路：hash表 import java.util.Map; import java.util.HashMap; class Solution { public int[] twoSum(int[] nums, int target) {

二叉树的下一节点 /* public class TreeLinkNode { int val; TreeLinkNode left = null; TreeLinkNode right = null; TreeLinkNode next = null; TreeLinkNode(int val) { this.val = val; } } */ public class Solution { public TreeLinkNode G

字符串中第一个出现的不重复的数 public class Solution { //Insert one char from stringstream int[] arr = new int[128]; //记录次数 StringBuilder sb = new StringBuilder();//记录位置 public void Insert(char ch) { sb.append(ch); arr[ch]++; } /

扑克牌顺子 class Solution { public boolean isStraight(int[] nums) { Set<Integer> repeat = new HashSet<>(); int max = 0, min = 14; for(int num : nums) { if(num == 0) continue; // 跳过大小王 max = Math.ma

两个链表对应数字相加 /** * 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 = ne

有序旋转数组查找 class Solution { public int search(int[] nums, int target) { int n = nums.length; if (n == 0) { return -1; } if (n == 1) { return nums[0] == target ? 0 : -1; } int l = 0,

回文数 class Solution { public boolean isPalindrome(int x) { // 特殊情况： // 如上所述，当 x < 0 时，x 不是回文数。 // 同样地，如果数字的最后一位是 0，为了使该数字为回文， // 则其第一位数字也应该是 0 // 只有 0 满足这一属性 if (x < 0 || (x % 10 == 0 && x !=

最长公共前缀 class Solution { public String longestCommonPrefix(String[] strs) { if (strs == null || strs.length == 0) { return ""; } else { return longestCommonPrefix(strs, 0, strs.length - 1); } } pu

快乐数 class Solution { private int getNext(int n) { int totalSum = 0; while (n > 0) { int d = n % 10; n = n / 10; totalSum += d * d; } return totalSum; } public boolean isHap

标题 集合子集 思路针对针对cur的元素有两种办法一种是取，一种是不取。t.add（） t.remove()， 继续递归。 class Solution { List<Integer> t = new ArrayList<Integer>(); List<List<Integer>> ans = new ArrayList<List<Integer>>(); public List<List&

比较版本号 class Solution { public int compareVersion(String version1, String version2) { String[] nums1 = version1.split("\\."); String[] nums2 = version2.split("\\."); int n1 = nums1.length, n2 = nums2.length; // compare versions int i1

最少跳跃数（II） 给定一个非负整数数组，你最初位于数组的第一个位置。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 你的目标是使用最少的跳跃次数到达数组的最后一个位置。 public int jump(int[] nums) { int position = nums.length - 1; //要找的位置 int steps = 0; while (position != 0) { //是否到了第 0 个位置 for (int i = 0; i < p

删除链表重复元素 题目1. 保留一个重复元素 /** * 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; t

字符串ip地址组合 思路：dfs思路 package com.dfs; import java.util.ArrayList; public class StringIP { public static final int segment_count = 4; public ArrayList<String> arrayList = new ArrayList<>(); public int[] segments = new int[segment_cou

删除链表的中间节点 删除链表的中间节点 public static LinkNode removeHalfNode(LinkNode node) { if(node==null || node.next==null) { return node; } if (node.next.next==null) { return node.next; } LinkNode fast = node.next.next; LinkNode slow = node; //重点slow指的

最短通路值 package com.juzhen; import java.util.LinkedList; import java.util.Queue; //最短通路值 public class ShortestPath { public static void main(String[] args) { int[][] array = {{1,0,1,1,1},{1,0,1,0,1},{1,1,1,0,1},{1,1,1,1,1}}; System.out.print(shortestP

子数组最大和 public static int MostSumOfZixulieMethod(int[] arrays) { if(arrays==null || arrays.length==0) { return 0; } int subsum = 0; int maxsum = Integer.MIN_VALUE; for(int i=0; i<arrays.length; i++) { if(subsum<0) { subsum = arrays

换线方法数 public static int numbersOfMethodVersionTwoOfPress(int money, int[] chargeMoney) { if (money<0 || chargeMoney==null || chargeMoney.length==0) { return 0; } int[] result= new int[money+1]; //初始化只是用一种货币的情况， result[0][0]=1；

换钱所需要的最少钱币个数 public static int mostlessMoneyNumerMethodOfPress(int money, int[] chargeMoney) { if(money<0||chargeMoney==null||chargeMoney.length==0) { return 0; } //result[0...i][0] 为0 int[] result = new int[money+1]; for(int j=1;j<=mone

最长公共子序列 package com.dynamic; //最长公共子序列 public class MostLenthCommonSubXulie { //1A2C3D4B56 public static void main(String[] args) { String string1 = "1A2C3D4B56"; String string2 = "B1D23CA45B6A"; char[] arr1 = string1.toCharArray(); char[] arr

最长回文子串 public static String longestSubStringHuiWen(char[] stringarray, String s) { if (stringarray==null || stringarray.length == 0) { return ""; } boolean[][] dp = new boolean[stringarray.length][stringarray.length]; int len = stringarray.lengt

最长递增子序列 package com.dynamic; //最长递增子序列不连续 public class MostLengthDiZengSubXulie { public static void main(String[] args) { int[] arr = {2,5,1,4,3,6,7}; int[] result = dp(arr); result = generateLIS(arr, result); for(int i=0;i<result.length;i

最长公共子串 package com.dynamic; public class MostLengthCommonSubString { public static void main(String[] args) { String string1 = "12345ABCD"; String string2 = "12345EF"; System.out.print(MostLengthCommonSubStringMethod(string1, string2)); } publi

路径总和判断是否存在到叶子结点相加等于某值 /** * 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

路径总和求出所有路径到叶子节点 给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。 叶子节点 是指没有子节点的节点。 class Solution { List<List<Integer>> arrays = new ArrayList<List<Integer>>(); public List<List<Integer>> pathSum(

二叉树路径总和个数 给定一个二叉树，它的每个结点都存放着一个整数值。 找出路径和等于给定数值的路径总数。 路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。 二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left;

矩阵包含字符串 class Solution { public boolean result=false; public boolean exist(char[][] board, String word) { int[][] visited = new int[board.length][board[0].length]; char[] a = word.toCharArray(); for(int i=0;i<board.length

题目：给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 思路：使用二叉树前序递归遍历。 /* public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } }

a的b次幂 public static float method(int a, int b) { float res = 0.0f; if(b==0) { return 1; } if(b<0) { res = 1/method(a, -b); return res; } if(b%2==0) { res = method(a*a, b/2); return res; }else { res = method(a*a, b/2)*a;

大数相加 public static String bigNumberSum(String number1, String number2) { String num1 = new StringBuffer(number1).reverse().toString(); String num2 = new StringBuffer(number2).reverse().toString(); int num1Length = num1.length(); int num2Length = nu

两数相加 public class TwoNumberAdd { public static void main(String[] args) { int number1 = 10; int number2 = 12; while (number2!=0){ int temp = number1^number2;//no jinwei number2 = (number1&number2)<

进制转换 package com.special; import com.sun.xml.internal.ws.encoding.MtomCodec; //m public class NumberMToNJinzhi { public static void main(String[] args) { int m =1000; int n = 5; System.out.println(MToN(-1000, 5)); } public s

合并二叉树 import java.util.*; /* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */ public class Solution { /** * * @param t1 TreeNode类 * @param t2 TreeNode类 * @return TreeNo

最大数 import java.util.*; public class Solution { /** * 最大数 * @param nums int整型一维数组 * @return string字符串 */ public String solve (int[] nums) { // write code here ArrayList<String> list = new ArrayList<St

最长递增路径 import java.util.*; public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * 递增路径的最大长度 * @param matrix int整型二维数组 描述矩阵的每个数 * @return int整型 */ public int maxLength; public int solve (int[][] matrix) {