jsh0123的博客

利用位置互换的思想很有趣比我用哈希表存的剩空间，仍需仔细研究研究public class Solution { public int firstMissingPositive(int[] A) { int i = 0; while(i < A.length){ if(A[i] == i+1 || A[i] A.length) i++

先上一个我自己的暴力解法public class Solution { public List findAnagrams(String s, String p) { int[] hash = hashPattern(p); List result = new ArrayList(); int sLength = s.length(),pL

这道题是一道动态规划的题，就是找到当前位置之前不相邻的最大值和当前值相加与相邻的值取最大值就是当前位置能取到的最大值。讨论的答案比我自己写的质量好，如下public int rob(int[] nums) { if(nums.length==0) return 0; if(nums.length==1) return nums[0]; //Initialize

这道题看似简单实际上难点在负数的补码上，由于java没有无符号整数所以我采用的方法是将负数按照2的31次方去补码然后检测位数字符串长度是8位的时候将高位加8上代码public class Solution { public String toHex(int num) { String hex = ""; int toHexNum = num;

这道题用hash思想加二维数组的思想，用第一维度记出现次数，第二维度记字符串中的位置，时间复杂度O（n）public class Solution { public int firstUniqChar(String s) { char[] sA = s.toCharArray(); int[][] alphabet = new int[26][2];

感觉我自己这个应该是最好的了public class Solution { public int[] intersect(int[] nums1, int[] nums2) { List interList = new ArrayList(); Arrays.sort(nums1); Arrays.sort(nums2);

昨天写的，今天直接附上代码public class Solution { public int[] intersection(int[] nums1, int[] nums2) { Set numSet1=new HashSet(); Set numSet2=new HashSet(); for(int m =0;m<nums1.leng

昨天出长set list map的禁果今天再次尝试了一下，不多说了直接上代码public class Solution { public boolean canConstruct(String ransomNote, String magazine) { int ranLength = ransomNote.length(),magLength = magazine.l

这道题我真的是使出了洪荒之力啊/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */publ

初试Java写Leetpublic class Solution { public String reverseString(String s) { char[] stringArr= s.toCharArray(); char newS; int last = stringArr.length-1; for(int i=0;

这道题在我面试之前问过的题，如今这道题轻车熟路public class Solution { public int trailingZeroes(int n) { int num = 0; while(n!=0){ // num += n/5; n = n/5;            num +=

典型的动态规划题，这道题我采用从后向前的思想找最大值动态规划方程式就是代码的为代码public class Solution { public int maxSubArray(int[] nums) { int[] addA = new int[nums.length]; int max = 0,i = nums.length - 1,temp = 0;

这道题是一道动态规划题基本可以变形为找每个当前元素之前出现的最小值，然后最小值与当前值做差从而求出最佳时间我的代码如下public class Solution { public int maxProfit(int[] prices) { if(prices.length == 0) return 0; int[] min

昨天怒刷n到链表题，感觉简单题没什么多余技巧，固没有总结这道题非常常见，做了好多遍了已经，最简单的动态规划一种斐波纳切数列变种题public class Solution { public int climbStairs(int n) { if(n == 1) return 1; else if(n == 2)

这道题经过暴力模拟解题发现时间复杂度巨高，然后改为求min与所有数组元素求差的和，代码如下：public class Solution { public int minMoves(int[] nums) { int length = nums.length; int steps = 0,gap = 0; //int max = Inte

记一种别人写的代码，和我的代码我的代码如下：public class Solution { public List topKFrequent(int[] nums, int k) { int length = nums.length; List result = new ArrayList(); Map hash = new Hash

这道题又涨姿势了，treemap自带接口方法lowerEntry、floorEntry、ceilingEntry和higherEntry分别返回与小于、小于等于、大于等于、大于给定键的键关联的Map.Entry对象，如果不存在这样的键，则返回null。类似地，方法lowerKey、floorKey、ceilingKey和higherKey只返回关联的键。public class Solution

同样是动态规划的思想，性能最好的用补码轮询的方法做的，效率极高，代码如下public boolean checkSubarraySum(int[] nums, int k) { Map map = new HashMap(){{put(0,-1);}};; int runningSum = 0; for (int i=0;i<nums.length;i++) {

我用set去重无重复则循环计算差值，而discuss则考虑用分钟hash贴一个我的答案public class Solution { public int findMinDifference(List timePoints) { int result = Integer.MAX_VALUE; Set set = new HashSet(timePoi

又是一道穷举改动态规划的题，根据今天的面试结果我决心把动态规划练得炉火纯青！public class Solution { public boolean canPartition(int[] nums) { // check edge case if (nums == null || nums.length == 0) { ret

这道题我用最容易想的想法就是回溯法计算分别延四个方向计算，结果时间复杂度为O(n5),结果导致时间过长代码如下public class Solution { int max = 0; public int longestIncreasingPath(int[][] matrix) { for(int i = 0;i <matrix.length;i++){

我的想法很常规，常规的动态规划的思想public class Solution { public String longestPalindrome(String s) { if(s.length() < 2 ) return s; int max = 0,len = s.length(); char[] sChar

换钱币这道题我一开始用回溯法解题，导致超时，后看到提示，改用动态规划解这个是动态规划写的答案public class Solution {    int min = -1;    public int coinChange(int[] coins, int amount) {        if(amount == 0)            return 0;   

我的答案暴力解答案用的是O(n)贴个答案public class Solution { public int maxArea(int[] height) { int max = 0; for(int i = 0; i< height.length - 1;i++){ for(int j = i+1; j<height.le

同样是层次遍历的解法，但是我的空间负责度较高，明明有next指针可以利用next做层次遍历先贴我自己的代码public class Solution { public void connect(TreeLinkNode root) { List> tree = new ArrayList>(); if(root != null)

这道题计算数组中所有元素的汉明距离我的解法很常规。结果超时，时间O(n2)这是我的答案public class Solution { public int totalHammingDistance(int[] nums) { int result = 0; for(int i = 0;i < nums.length;i++){

计算素数的个数我的想法中规中矩，就是暴力解法，贴一个答案解法，hash思想public class Solution { public int countPrimes(int n) { boolean[] notPrime = new boolean[n]; int count = 0; for (int i = 2; i < n; i+

这道题我的解法比较单一，采用hash数组的方法，discuss高票的方法采用标记负数的方法，对出现数对应的位置则表记为负数。我的答案public class Solution { public List findDisappearedNumbers(int[] nums) { int length = nums.length; int[] h

我的思想是list数组按顺序构造，讨论中高票使用数组实现，效果更好我的代码public class Solution { public String frequencySort(String s) { int length = s.length(); List[] sortList = new LinkedList[length+1];

这个题基本没什么机灵可以抖public class Solution { public ListNode deleteDuplicates(ListNode head) { ListNode p = head; ListNode q = null; while(p!=null){ q = p.next;

先贴我自己的代码递归的思想，把用过的数都记下来public class Solution { public boolean isHappy(int n) { if(n == 1){ return true; }else{ List stack = new ArrayList(); s

int maxProfit(int* prices, int pricesSize) { int max=0,i=0,muturs=0,buy=0,sell=0; for(i;i<pricesSize-1;i++){ if(prices[i]<=prices[i+1]) { if(muturs&&sell)

int comp (const void * a, const void * b) { return ( *(int*)a - *(int*)b );}bool containsDuplicate(int* nums, int numsSize) { // Sort qsort(nums, numsSize, sizeof(int), comp); // L

/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */struct TreeNode* lowestCommonAncestor(struct TreeN

int titleToNumber(char* s) { int length=strlen(s),num=0,i=0; while(i<length) { num=num+(s[i]-64)*pow(26,length-i-1);//方法一 //num=s[i]-64+num*26;//方法二 i++; }

bool isAnagram(char* s, char* t) { int ls=strlen(s),lt=strlen(t),i=0,su[26],lu[26]; memset(su, 0, sizeof(int)*26); memset(lu, 0, sizeof(int)*26); if(ls!=lt) return false; e

char* convertToTitle(int n) { char *asc1; int i=0,j,high,temp=n; while((temp-1)/26!=0)//第二种思考方式的时候这个循环将无用 { i++; temp=(temp-1)/26; } asc1 = (char *)mal

int singleNumber(int* nums, int numsSize) { int p=nums[0]; for(int i=1;i<numsSize;i++) { p^=nums[i]; } return p;}这是根据论坛上的XOR（异或）方式写的答案。^是C语言的位运算符,按位异或的意思.a^b就是拿a和

bool canWinNim(int n) { return n%4==0?false:true;}一行C语言版，纯自己想出来的。这道题难点在于，不好想规律，想出规律得心应手。2016/1/29

/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */bool isSameTree(struct TreeNode* p, struct TreeNod