- 博客(47)
- 收藏
- 关注
RSS订阅原创 leetcode-java-101. Symmetric Tree
思路一： 递归：1ms 先判断左右子节点是否相等，不等就返回false 相等则判断左节点的左孩子和右节点的右孩子是否相等，且判断左节点的右孩子和右节点的左孩子是否相等。 思路二： 迭代public class Solution { public boolean isSymmetric(TreeNode root) { if(root == null) {
2016-06-30 21:21:04
265
原创 leetcode-java-98. Validate Binary Search Tree
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ public class Solution {
2016-06-30 15:21:23
491
原创 leetcode-java-100. Same Tree
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {
2016-06-30 11:41:18
257
原创 leetcode-java-96. Unique Binary Search Trees
思路：当有n个节点时(1--n),任何一个数都可以当成根节点，左边j个节点，右边是n-j-1个节点所以就有nums[n] = nums[0]*nums[n]+nums[1]*nums[n-1]+nums[2]*nums[n-2]+...+nums[n]*nums[0];因此我们需要先求出nums[0]--nums[n-1]最后返回nums[n]即可public class Solution {
2016-06-30 10:08:42
671
原创 leetcode-java-104. Maximum Depth of Binary Tree
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Solution {
2016-06-29 22:13:34
100
原创 java--数据结构--二叉树遍历
使用递归和迭代（借用栈）实现二叉树先序，中序，后序遍历 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; }
2016-06-29 22:01:17
376
原创 leetcode-java-144. Binary Tree Preorder Traversal
使用循环来解决，递归和迭代都是循环 递归：递归重复调用自身实现循环 迭代：循环代码中参与运算的变量同时是保存结果的变量，当前保存的结果作为下一次循环计算的初始值 普通循环： 思路一： 使用递归 1ms 思路二： 使用迭代 2ms 题上都说了，递归简单，让我们来使用迭代吧！迭代需要借助栈来实现 前序遍历时根左右，则入栈顺序是右左根public class Solution {
2016-06-29 16:46:14
507
原创 leetcode-java-318. Maximum Product of Word Lengths
思路： 1.整数数组来保存每个字符串的字符是否存在 2.两重循环整数数组，通过&两个数检查是否两个字符串是否有重复字符public class Solution { public int maxProduct(String[] words) { int len = words.length, total = 0; int[]
2016-06-29 14:44:41
378
原创 leetcode-java-151. Reverse Words in a String
思路： 存储在一个数组中，倒置数组，但是空间是O(n) 误区：本来想直接首尾交换数组，// for(;i < len/2;i++) {// String temp = strings[i];// strings[i] = strings[len-1-i];// strings[len-1-i] = temp;// }// result = String
2016-06-29 09:46:37
542
原创 leetcode-java-166. Fraction to Recurring Decimal
思路: 如何循环求数：每次都作除，然后取整数部分，余数*10 如何判断重复：当余数重复时，则就会是重复部分的出现，所以用hashmap存储余数(key)和索引位置，当余数(key)重复，则结束循环得到索引值方便加() 如何处理正负数：先判断符号，转换成正数 如何溢出处理：如果输入为Integer.MIN_VALUE，取绝对值后会溢出，则先转换成longpublic class Solutio
2016-06-28 16:08:20
362
原创 leetcode-java-137. Single Number II
方法一： 用的容器map解决的问题，但是19ms 方法二： 参考别人的做法 可以给数组排序，然后判断挨着的三个是否相同public class Solution { public int singleNumber(int[] nums) { Map<Integer,Integer> map = new HashMap<Integer,Integer>();
2016-06-28 11:35:02
773
原创 leetcode-java-268. Missing Number
方法一： 排序之后遍历数组 方法二： 数学方法(较快1ms) 比如[0,1,3]就是1+2+3-数组和public class Solution { public int missingNumber(int[] nums) { int len = nums.length, result = 0, i = 0;
2016-06-28 11:14:47
506
原创 leetcode-java-343. Integer Break
本题就是整数拆分求最大乘积： 1.用数学方法做 4 4 5 3*2 6 3*3 7 3*4 8 3*3*2 9 3*3*3 10 3*3*4 11 3*3*3*2 12 3*3*3*3 13 3*3*3*4 发现，若是3的倍数
2016-06-27 10:55:05
271
原创 leetcode-java-347. Top K Frequent Elements
思路： 1.先通过map统计 2.对map的value排序 3.取出map中的前k个keypublic class Solution { public List<Integer> topKFrequent(int[] nums, int k) { List<Integer> list = new ArrayList<Integer>(); Map<Int
2016-06-26 20:52:57
128
原创 java--Collection和Collections
1.java.util.Collection 是一个集合接口 2.java.util.Collections 是一个包装类（工具类/帮助类）。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，用于对集合中元素进行排序、搜索以及线程安全等各种操作，服务于Java的Collection框架。 3.Collections包装类的sort方法 Collection.sor
2016-06-26 20:31:00
263
原创 leetcode-java-122. Best Time to Buy and Sell Stock II
public class Solution { public int maxProfit(int[] prices) { int len = prices.length, sum = 0, i = 0; for(;i < len - 1;i++) { if(prices[i+1] > pri
2016-06-26 19:36:25
204
原创 leetcode-java-238. Product of Array Except Self
思路： 1.当0的个数大于等于2时，返回全为0的数组 2.当0的个数为1时，0对应的返回total，其他的为0 3.当无0时，total处于当前数public class Solution { public int[] productExceptSelf(int[] nums) { int len = nums.length, total = n
2016-06-26 19:24:03
329
原创 leetcode-java-260. Single Number III
public class Solution { public int[] singleNumber(int[] nums) { Map<Integer,Integer> map = new HashMap<Integer,Integer>(); int len = nums.length, len1 = 0; int[]
2016-06-26 16:48:54
321
原创 leetcode-java-136. Single Number
public class Solution { public int singleNumber(int[] nums) { Map<Integer,Integer> map = new HashMap<Integer,Integer>(); int len = nums.length, num = 0; for(int i
2016-06-26 16:31:45
401
原创 leetcode-java-338. Counting Bits
public class Solution { public int[] countBits(int num) { int[] result = new int[num+1]; for(int i = 0 ;i < num + 1;i++) { result[i] = numberOfOne(i); } r
2016-06-26 15:57:54
240
原创 leetcode-java-225. Implement Stack using Queues
class MyStack { // Push element x onto stack. List<Integer> queue1 = new LinkedList<Integer>(); List<Integer> queue2 = new LinkedList<Integer>(); public void push(int x) { if(!qu
2016-06-15 22:04:03
590
原创 leetcode-java-58. Length of Last Word
思路： 1.先处理最后的空格，跳过空格 2.倒着遍历字符串，不为空是conut++，但是空则breakpublic class Solution { public int lengthOfLastWord(String s) { int len = s.length(), i = len - 1, count = 0;
2016-06-14 21:54:42
820
原创 leetcode-java-198. House Robber
public class Solution { public List<List<Integer>> generate(int numRows) { List<List<Integer>> list = new ArrayList<List<Integer>>(); List<Integer> listF = new ArrayList<Integer>();
2016-06-12 21:21:50
330
原创 leetcode-java-198. House Robber
思路： 考查动态规划，基本思路是当前节点处最大值curMax = Math.max(curMax, curPrePreMax + cur)public class Solution { public int rob(int[] nums) { int curMax = 0, curPrePreMax = 0; for(int c
2016-06-11 16:04:40
245
原创 leetcode-java-34. Search for a Range
/*复杂度是O(n) */public class Solution { public int[] searchRange(int[] nums, int target) { int len = nums.length, i = 0; ArrayList<Integer> list = new ArrayList<Integer>
2016-06-10 20:59:27
410
1
原创 leetcode-java-31. Next Permutation
思路： 123的排序是： 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 next_permutation函数将按字母表顺序生成给定序列的下一个较大的排列，直到整个序列为降序为止 归纳分析这个过程： 假设m个元素的序列pn，下一组较大排列是pn+1 1.若pn最后两个元素构成一个最小的增序序列，直接反转最后两个元素得到pn+1 2.若后面最多s个元素构
2016-06-10 19:23:20
440
原创 leetcode-java-26. Remove Duplicates from Sorted Array
思路： 数组中和前一个不重复的加到数组中即可public class Solution { public int removeDuplicates(int[] nums) { int len = nums.length, index = 0, i = 1; for(;i < len;i++) {
2016-06-10 14:00:41
284
原创 leetcode-java-20. Valid Parentheses
思路： 本题用栈实现 读到一个字符串时判断，如果栈顶和当前这个字符满足左右括号匹配，则弹出，否则压栈。 若最后栈顶为空，则说明匹配成功。public class Solution { public boolean isValid(String s) { Stack<Character> stack = new Stack<Character>();
2016-06-10 13:55:41
683
原创 leetcode-java-22. Generate Parentheses
本题明显用递归： 递归就是把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解 本题就是用递归，也就是判断每个字符应该是(还是) left>0时—-字符串中添加字符( right>0且leftpublic class Solution { public List<String> generateParenthesis(int n) { ArrayLis
2016-06-09 21:28:09
954
1
原创 leetcode-java-16. 3Sum Closest
思路： 先升序排序，然后用第一重for循环确定第一个数字。 然后在第二重循环里，第二、第三个数字分别从两端往中间扫。 如果三个数的total等于target，返回target。 如果三个数的total大于0，所以第三个数往左移。 如果三个数的total小于0，说明需要减小，所以第二个数往右移， 这时更新closeTarget 时间复杂度：O(n2)public class Soluti
2016-06-07 21:47:12
896
原创 leetcode-java-5. Longest Palindromic Substring
思路一： 两层循环字符串，得到子字符串，随后验证字符串是否为回文需要一层循环，时间复杂度是O(n^3) 思路二： １.遍历字符串选定中心点 ２.根据中心点左右扫描，直到不是回文停止，返回长度 ３.更新回文长度，最后返回最长字串 时间复杂度是O(n^2)public class Solution { public String longestPalindrome(String s
2016-06-07 21:14:05
512
原创 leetcode-java-3. Longest Substring Without Repeating Characters
思路： 用HashMap动态存储字符串的每个不重复的子字符串； 当有重复字符出现时，动态更新子字符串的最大值和更新HashMappublic class Solution { public int lengthOfLongestSubstring(String s) { HashMap<Character,Integer> map = new HashMap<Charact
2016-06-07 10:23:34
522
原创 leetcode-java-168. Excel Sheet Column Title
思路： 其实就是十进制转换成26进制public class Solution { public String convertToTitle(int n) { String s = ""; while(n > 0) { s = (char)((n-1) % 26 + 'A') + s; n = (n-1)/26
2016-06-06 21:41:27
279
原创 leetcode-java-121. Best Time to Buy and Sell Stock
思路： 要获得最大利益，其实就是找到相差最大的两个数。 所以用动态规划，找出当前数组中最小的值和当前最大利益public class Solution { public int maxProfit(int[] prices) { int maxProfit = 0, len = prices.length, i = 1;
2016-06-05 10:32:24
526
原创 leetcode-Java-202. Happy Number
思路： 使用递归的思路比较简单。 但是需要注意小于10的数中，1和7都是happy number，容易忽略7，可以验证一下public class Solution { public boolean isHappy(int n) { int m = 0; if(n == 1 || n == 7) { return true;
2016-06-05 09:55:42
309
原创 leetcode-Java-70. Climbing Stairs
思路： 其实可以用f(n) = f(n-1) + f(n-2);但是递归效率不高 本题用for循环替代递归public class Solution { public int climbStairs(int n) { int[] count = new int[n+1]; if(n==1) return 1; if(n=
2016-06-04 21:59:53
234
原创 leetcode-Java-242. Valid Anagram
思路： 转换成字符数组，排序两个字符串，直接比较看是否完全相等public class Solution { public boolean isAnagram(String s, String t) { char[] ch1 = s.toCharArray(), ch2 = t.toCharArray(); int len1 = s
2016-06-04 21:35:05
232
原创 leetcode-Java-234. Palindrome Linked List.java
思路一： 遍历链表，存储在数组中，然后正序链表且数组倒叙检查。 时间复杂度：o(n),空间复杂度：o(n) 思路二： 遍历链表，利用栈先进后出的性质，把链表前半段放入栈中，逐个弹出和链表后半段比较。（当然也可以全部放入栈） 时间复杂度：o(n),空间复杂度：o(n)–用了n/2的栈空间 思路三： 反转链表法，链表前半段原地翻转，再将前半段和后半段依次比较，判断是否相等。 时间复杂度：
2016-06-04 15:56:31
308
原创 leetcode-Java-83. Remove Duplicates from Sorted List
这个题目很简单， 只要考虑链表是null的处理情况public class Solution { public ListNode deleteDuplicates(ListNode head) { ListNode node = head; if(head == null || head.next ==null) { return h
2016-06-04 11:30:50
372
原创 leetcode-Java-141. Linked List Cycle.java
思路： 方法1.可以使用hashset，重复返回true 方法2：使用两个指针，fast和slow，两个指针重合时 public class Solution { public boolean hasCycle(ListNode head) { if (head == null) return false; HashSet<
2016-06-04 10:58:45
528
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人