AIJXB的博客

public int search(int[] nums, int target) { if (nums.length == 0) { return -1; } if (nums.length == 1) { return target == nums[0]?0:-1; } int i = 0; int j = nums.length-1; wh..

//括号生成 //回溯法 public List<String> generateParenthesis(int n) { List<String> result = new ArrayList<>(); if (n == 0) { return result; } backResult(result,new StringBuffer(),0,0,n); ..

//回溯法 public List<String> letterCombinations(String digits) { List<String> result = new ArrayList<>(); if (digits.length() == 0) { return result; } Map<Character,String> map = new Has.

public static List<List<Integer>> threeSum2(int[] nums) { List<List<Integer>> result = new LinkedList<>(); if (nums == null||nums.length<3) { return result; } Arrays.sort(nums);..

public int maxArea(int[] height) { //采用双指针，从最两边开始 int l = 0; int r = height.length-1; int max = 0; while (l<r) { //记录当前的一个容量然后用max记录当前最大值 int area = Math.min(height[l],height[r])*(r-l);...

public boolean isPali(String s) { int i = 0; int j = s.length()-1; while (i<j) { if (s.charAt(i) != s.charAt(j)) { return false; } i++; j--; } ret..

public int lengthOfLongestSubstring(String s) { if (s.length() == 0) { return 0; } Map<Character,Integer> map = new HashMap<>(); int max = 0; int left = 0; for (int i = 0;i<s.leng..

第一种暴力解法，双重循环遍历找到答案然后返回 public int[] twoSum(int[] nums, int target) { int[] arr = new int[2]; for (int i = 0;i<nums.length;i++) { for (int j = i+1;j<nums.length;j++) { if (nums[i]+nums[j] == target) { .

解题思路，找出最优解的规律当target等于1，2，3的时候，结果是固定的当target大于3的时候，可以看以下数据target=4, 最优解：2 2target=5, 最优解：3 2target=6, 最优解：3 3target=7, 最优解：3 2 2target=8, 最优解：3 3 2target=9, 最优解：3 3 3target=10,最优解：3 3 2 2target=11,最优解：3 3 3 2target=12,最优解：3 3 3 3target=13,最优解：.

public class Main { //矩阵中的路径 public int[][] visit; public boolean hasPath(char[] matrix, int rows, int cols, char[] str){ visit = new int[rows][cols]; char[][] array = new char[rows][cols]; //将字符串中的每个字符放入二维数组中 f.

int index = -1; String Serialize(TreeNode root) { if (root == null) { return "#"; } return root.val+","+Serialize(root.left)+","+Serialize(root.right); } TreeNode Deserialize(String str) { String[].

public ListNode deleteDuplication(ListNode pHead) { if (pHead == null||pHead.next == null) { return pHead; } ListNode newHead = new ListNode(-1); newHead.next = pHead; ListNode pre = newHead; ...

如图，链表起点为a,环的入口点为b，设两个快慢指针从a开始，一个一次走两个节点，一个一次走一个，那么最终他们肯定会相遇的，假设相遇点为c，那么根据推算，有c到b的距离即图中红线部分，长度等于a到b,所以我们再设一个指针指向a,让之前设置的慢指针接着c开始，两个一人走一步，那么最终相遇的点就是环的入口即b。 public ListNode EntryNodeOfLoop(ListNode pHead) { if (pHead == null||pHead.next == null..

方法一： public boolean duplicate(int numbers[],int length,int [] duplication) { ArrayList<Integer> list = new ArrayList<>(); for (int i = 0;i<length;i++) { if (list.contains(numbers[i])) { duplic.

用链表模拟 public int LastRemaining_Solution(int n, int m) { if (n<1||m<1) { return -1; } ArrayList<Integer> list = new ArrayList<>(); for (int i = 0;i<n;i++) { list.add(i); .

import java.util.*;public class Solution { public boolean isContinuous(int [] numbers) { if(numbers.length == 0){//长度为0返回false return false; } Arrays.sort(numbers);//数组排序 int count = 0; int x = 0; .

public int StrToInt(String str) { //字符串为空 if (str == null||str.length() == 0) { return 0; } //字符串只包含+或者- if ("+".equals(str)||"-".equals(str)) { return 0; } //判断如果字符串开头是+或者...

执行加法 x ^ y进位操作 ( x & y ) << 1 public int Add(int num1,int num2) { int a = num1^num2; int b = (num1&num2)<<1; while (b != 0) { num1 = a; num2 = b; a = num1^num2; ..

public String ReverseSentence(String str) { //需要将多个空格的情况考虑进来 if (str == null||str.length() == 0||str.trim().equals("")) { return str; } String s = ""; String[] arr = str.split(" "); for (int i...

首先我们必须知道，在最外层的两个数乘积就是最小的，所以我们可以用双指针，一个从0开始，一个从数组最后一个元素开始，向中间寻找，那么第一个找到的满足条件的结果就是最终结果。 public ArrayList<Integer> FindNumbersWithSum(int [] array, int sum) { int i = 0; int j = array.length-1; ArrayList<Integer> list = ne.

public class Solution { public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) { ArrayList<ArrayList<Integer>> result = new ArrayList<>(); for (int i = 1;i<sum;i++) { int tmp .

public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) { Arrays.sort(array); Stack<Integer> stack = new Stack<>(); for (int i = 0;i<array.length;i++) { if (stack.empty() || stack.peek()!=ar..

如何让本来长度不相等的变为相等的？假设链表A长度为a， 链表B的长度为b，此时a != b但是，a+b == b+a因此，可以让a+b作为链表A的新长度，b+a作为链表B的新长度。 public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) { if (pHead1 == null||pHead2 == null) { return null; } Li.

如果两个区间为[4, 3] 和[1, 2]那么逆序数为(4,1),(4,2),(3,1),(3,2)，同样的如果区间变为有序，比如[3,4] 和 [1,2]的结果是一样的，也就是说区间有序和无序结果是一样的。但是如果区间有序会有什么好处吗？当然，如果区间有序，比如[3,4] 和 [1,2]如果3 > 1, 显然3后面的所有数都是大于1， 这里为 4 > 1, 明白其中的奥秘了吧。所以我们可以在合并的时候利用这个规则。 public int count = 0; publ.

public String PrintMinNumber(int [] numbers) { String result = ""; ArrayList<Integer> list = new ArrayList<>(); for (int n:numbers) { list.add(n); } Collections.sort(list, new Comparator&l...

典型的动态规划。dp[n]代表以当前元素为截止点的连续子序列的最大和，如果dp[n-1]>0，dp[n]=dp[n]+dp[n-1]，因为当前数字加上一个正数一定会变大；如果dp[n-1]<0，则从dp[n]重新开始再不停加，因为当前数字加上一个负数一定会变小。使用一个变量max记录最大的dp值返回即可。public int FindGreatestSumOfSubArray(int[] array) { if (array == null || array.length =.

如果两个数不相等，就消去这两个数，最坏情况下，每次消去一个众数和一个非众数，那么如果存在众数，最后留下的数肯定是众数。用一般的排序也可以完成这道题目，但是如果那样完成的话就可能太简单了。用preValue记录上一次访问的值，count表明当前值出现的次数，如果下一个值和当前值相同那么count++；如果不同count–，减到0的时候就要更换新的preValue值了，因为如果存在超过数组长度一半的值，那么最后preValue一定会是该值。 public int MoreThanHalfNum_S.

我们新建一个辅助method，用于不停的循环向下寻找所有可能的排列组合。在这个辅助method里，有三个arguments。第一个是str，即当前我们剩下可以取的string，第二个是cur，即我们当前所拥有的字符串，第三个是result，是我们符合条件的字符串的合集。在这个辅助method中，我们首先需要检测，我们还有没有能取的string，如果没有，我们便可以开始确认我们当前所拥有的字符串有没有被放进最后的Arraylist result中，如果没有，我们便将他加进去。接下来，当我们还有能取的str.

思路：目标值 = 目标值 - 当前节点值共有几种情况：0，当节点为空，return1，当目标值小于0，return2，当目标值为0 并且 节点下无其他节点节点下无其他节点说明是叶子节点，并且路径值的和满足了目标值，添加到结果中 并且return3，当目标值大于0，继续递归 public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) { ArrayList<.

我这里借鉴一位大佬的很奇妙的思路：遍历的时候，如果遇到比最后一个元素大的节点，就说明它的前面都比最后一个元素小，该元素后面的所有值都必须大于最后一个值，这两个条件必须都要满足。否则就说明该序列不是二叉树后序遍历。 public boolean VerifySquenceOfBST(int [] sequence) { if (sequence.length == 0||sequence == null) { return false; } .

新建一个栈，将数组A压入栈中，当栈顶元素不相等时说明他不是立马出栈，就先将它入栈，当栈顶元素等于数组B时，就将其出栈，当循环结束时，判断栈是否为空，若为空则返回true. public boolean IsPopOrder(int [] pushA,int [] popA) { if (popA.length == 0 || pushA.length == 0 || popA.length!=pushA.length) { return false; .

用两个栈，stack用来存所有的元素,getMin用来存加入新的元素后当前栈中对应的最小值。两个栈中的元素数量始终保持一致，当新的元素小于栈顶元素时，向getMin栈顶push新来的元素，否则，向getMin栈顶加入原栈顶元素。执行“pop”方法时，两个栈同时弹出各自的栈顶元素。 public Stack<Integer> stack = new Stack<>(); public Stack<Integer> getMin = new Stack<.

定义四个变量代表范围，up、down、left、right向右走存入整行的值，当存入后，该行再也不会被遍历，代表上边界的 up 加一，同时判断是否和代表下边界的 down 交错向下走存入整列的值，当存入后，该列再也不会被遍历，代表右边界的 right 减一，同时判断是否和代表左边界的 left 交错向左走存入整行的值，当存入后，该行再也不会被遍历，代表下边界的 down 减一，同时判断是否和代表上边界的 up 交错向上走存入整列的值，当存入后，该列再也不会被遍历，代表左边界的 left 加一，同时.

public ListNode ReverseList(ListNode head) { ListNode cur = head; ListNode prev = null; ListNode newHead = null; while (cur != null) { ListNode curNext = cur.next; if (curNext == null) { ...

思路：参考快速排序i++往前走碰到偶数停下来，j = i+1若 a[j]为偶数，j++前进，直到碰到奇数a[j]对应的奇数插到a[i]位置，j经过的j-i个偶数依次后移如果j==len-1时还没碰到奇数，证明i和j之间都为偶数了，完成整个移动通俗一点讲，就是先找到一个偶数位于位置i，再找到一个奇数位于j，用一个变量temp记录当前偶数值，把奇数放到偶数位置，然后把[i+1,j-1]的元素都向后移动一位，最后再把temp赋值到i+1的位置，这一次操作就算完成了。此处借用大佬图片帮助记忆~~.

f[n] = f[n-1] + f[n-2] + … + f[0]那么f[n-1] 为多少呢？f[n-1] = f[n-2] + f[n-3] + … + f[0]所以一合并，f[n] = 2*f[n-1]，初始条件f[0] = f[1] = 1 public int JumpFloorII2(int target) { if (target == 0) { return 0; } if (target == 1) { .

这题一般人会直接用递归去处理：public class Solution { public int Fibonacci(int n) { if(n<=1){ return n; } return Fibonacci(n-1) + Fibonacci(n-2); }}但我们知道递归是很消耗内存和时间的，这里我们给出优化：sum 只在每次计算第 n 项的时候用一下，其实还可以利用 sum 存储第 n-1 项.

第一种解法就是暴力求解，遍历寻找最小值，但这并没有达到出题人的意思。这题意在让我们使用二分查找：这种二分查找难就难在，arr[mid]跟谁比.我们的目的是：当进行一次比较时，一定能够确定答案在mid的某一侧。一次比较为 arr[mid]跟谁比的问题。一般的比较原则有：如果有目标值target，那么直接让arr[mid] 和 target 比较即可。如果没有目标值，一般可以考虑 端点这里我们把target 看作是右端点，来进行分析，那就要分析以下三种情况，看是否可以达到上述的目标。情况1，a.

/** * Definition for binary tree * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution { int index = 0; public TreeNode reConstructBinaryTree(int.

增加列：alter table tableName add columnName varchar (30)删除列：alter table tableName drop column columnName