shenzhu0127-CSDN博客

原创 LeetCode - 208. Implement Trie (Prefix Tree)

https://leetcode.com/articles/implement-trie-prefix-tree/知识点：1. 新的数据结构，非常有用，记一下

2016-07-22 22:12:59 449

原创 LeetCode - 299. Bulls and Cows

我们可以使用一个HashMap来记录character和其出现的次数，如果secret.charAt(i) == guess.charAt(i)，那么bull++；如果secret.charAt(i) != guess.charAt(i)的时候，secret扫过数字，相应的count加一，guess扫过数字，相应的count减一。若是mark[secret.charAt(i) - '0'] 小

2016-07-22 13:29:34 429

原创 LeetCode - 328. Odd Even Linked List

这道题目的思路同样也比较巧妙，在这道题目的解法中，我们并不是一个一个地去移动node，而是分别将odd nodes和even nodes串成两个Linked List，然后再将odd list尾部的next结点指向even nodes结点的头部即可，图片分析如下：代码如下：/** * Definition for singly-linked list. * public cla

2016-07-22 11:50:51 456

原创 LeetCode - 304. Range Sum Query 2D - Immutable

前面已经做过一道Range Sum Query - Immutable的题目，当时我们采用的方法是新建一个数组存储nums中从0到当前index的元素的和，这样在sumRange方法中我们可以在O(1)的时间中得到结果，在题目要求的sumRange多次调用的情况下非常方便。这里我们同样想要采用相似的方法，于是我们需要另外新建一个二维数组来存储和而不是单个的元素，2D情况下的sumRange分析

2016-07-22 11:39:04 1109

原创 LeetCode - 225. Implement Stack Using Queues

题目要求使用Queue来实现Stack，我们都知道Queue是FIFO，而Stack是FILO，为了解决这个问题，我们只要在add元素进Queue的时候把之前加进去的元素都poll出来然后再重新add进Queue即可，这样就是实现了FILO的操作。具体的函数实现见下面：整体的代码如下：class MyStack { Queue queue; public

2016-07-22 11:33:33 1050

原创 LeetCode - 292. Nim Game

这道题目只要仔细思考分析问题的规律，就可以发现解题的方法：代码如下：public class Solution{ public boolean canWinNim(int n){ return n % 4 != 0; }}

2016-07-22 00:03:27 424

原创 LeetCode - 150. Evaluate Reverse Polish Notation

我们都知道计算逆波兰表达式需要使用Stack，所以这道题目要使用一个Stack数据结构：我们把遇到的数字push进stack里面，而每次遇到四种运算符号的时候，我们就把相应的运算数pop出stack，而在计算之后再将结果push进stack。最后stack中剩下的就是整个运算的结果，pop出即可，代码如下：public class Solution { public int evalR

2016-07-21 22:59:32 626

原创 LeetCode - 147. Insertion Sort List

Insertion Sort的思想是逐步将后面的元素插入到前面相应的位置中来，知道了Insertion Sort的这个思想，我们可以将这种方法用到Linked List上面。另外，由于Linked List的头部或许发生改变，所以我们需要使用dummyNode。总的来说，在这道题目中，我们使用了三个指针，prev，curr和next。其中curr指向我们要插入到前面的元素，prev和prev.

2016-07-21 22:51:20 1168

原创 LeetCode - 151. Reverse Words in a String

第一种方法是使用Java的内置方法，非常巧妙，代码如下：public class Solution { public String reverseWords(String s) { if(s == null || s.length() == 0) return s; String[] words = s.trim().split(" +

2016-07-21 22:33:56 1253

原创 LeetCode - 143. Reorder List

这道题目总的来说可以分三步，第一步是找到Linked List的中点，第二部是翻转Linked List的后半部分，第三部就是把Linked List按照题目的要求进行reorder，现在大的思路已经明确，接下来我们所需要的就是思考这三步怎样实现。1->2->3->4->5->6首先第一步的话，我们可以使用slow runner/fast runner来实现。对于第二步来说，假设题目中的L

2016-07-21 22:14:27 459

原创 LeetCode - 303. Range Sum Query - Immutable

这道题目让实现一个方法计算数组中两个index之间的数字的和，看似非常简单，只要把之间所有的数字加起来即可。但是题目中给出的一个note是这个方法会调用很多次，所以我们希望找到一种在时间复杂度上更加有效的方法。我们可以另外申请一个数组，数组从index为1开始，都是num[i] + nums[i - 1]，这样这个新的数组index为i的元素都是nums数组中从0到i的数字的和。所以在实现新的

2016-07-21 22:01:55 329

原创 LeetCode - 284. Peeking Iterator

在已有的类的基础上实现功能更为强大的一个子类，这时我们可以把父类作为子类的一个attribute，通过这个attribute来使用父类的一些methods(对于这道题目是implements interface)。既然这道题目要求实现的方法都与下一个有关，我们可以使用一个指针指向下一个需要返回的元素。对于constructor，我们只要对类里的变量进行初始化，将next指针指向下一个需要返回的

2016-07-21 21:45:33 413

原创 LeetCode - 134. Gas Station

首先我们经过思考可以发现这道题目有两个性质：1. 如果从A点没有办法到达B点，那么从A和B之间的任何点出发都无法到达B点2. 如果circle中总的gas大于总的cost，那么一定会存在一个解根据以上的思路，我们可以写程序。首先假设从index为0的地方开始出发，在每一次模拟走向下一个结点的时候都计算sumGas和sumCost，并且计算当前的gas能否足以支撑到达下一个结点，计算方法

2016-07-21 21:35:25 352

原创 LeetCode - 160. Intersection of Two Linked Lists

代码如下：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */

2016-07-21 12:40:42 322

原创 LeetCode - 162. Find Peak Element

题目中给出了一个很重要的假设，就是数组左侧左边和右侧右边的数都是负无穷大，所以我们可以采用一个很方便的算法进行计算。我们从index为1的时候开始扫描整个数组，比较nums[i]和nums[i - 1]的大小，如果nums[i]比较小的话，那么nums[i - 1]就是peak element，直接返回i - 1即可，因为题目中假设数组左侧的左边是负无穷大，所以如果nums[1] < nums

2016-07-21 11:38:28 275

原创 LeetCode - 165. Compare Version Numbers

比较两个版本号的大小，首先自然是把两个String以"."分离开来，然后对它们一个一个进行比较。注意当其中的一个版本号长度比较小的时候，就在比较中将它设置为0，整体的代码如下：public class Solution { public int compareVersion(String version1, String version2) { String[] ver

2016-07-21 11:30:39 378

原创 LeetCode - 172. Factorial Trailing Zeroes

注意可能的重复出现，上面解释的不是很清楚，比如说25，25 = 5 * 5，而25中的这个5已经在n / 5的时候已经计算过一次，所以只要计算n / 25即可；下一个125中是3个5相乘，而其中两个5已经计算过了，所以这时只要计算n / 125即可。整体的代码如下：public class Solution { public int trailingZeroes(int n) {

2016-07-20 22:50:51 308

原创 LeetCode - 173. Binary Search Tree Iterator

要求实现Binary Search Tree的hasNext()和next()操作，最小的元素自然是从root开始一直找左子树左子树直到为空，这是我们找到了我们需要的第一个元素，但是接下来的元素怎么办呢？Binary Search Tree又没有回退的指针，就没办法了，这样是不行的，所以我们必然要采取某种方法记录一路寻找下来的路径上的元素，这里我们采用了Stack，它具有后进先出的功能，符合我们逻

2016-07-20 22:20:42 298

原创 LeetCode - 171. Excel Sheet Column Number

这道题目是上一道题目LeetCode - 168. Excel Sheet Column Title相反，是把字符串转化为相对应的数字。通过上道题目的分析和答案我们可以发现，我们只要把每个字符转化为相应的数字，乘以26，然后再继续转化下一个字符即可。注意与上道题目一样，这道题目也有一个小的陷阱，使用char - 'A'得到的是index而不是转化成的数字，需要再加上1。这道题目的算法也是有辗转

2016-07-20 22:10:19 302

原创 LeetCode - 168. Excel Sheet Column Title

我们可以注意到以下几点：(char)(n % 26 + 'A')得到的是转化后的第一个元素n /= 26得到的是转化出最右边的一个字符之后剩下的需要转化的数字所以我们可以重复上面的步骤直到n = 0，代码如下：public class Solution { public String convertToTitle(int n) { StringBuilder

2016-07-20 22:00:04 278

原创 LeetCode - 169. Majority Element

这道题的目的是找到数组中出现次数大于一半的数字，一开始的想法是使用一个HashMap记录各个数字出现的次数，然后从中找到出现次数大于nums.length / 2的数字，这种方法比较直接，但是使用了O(n)的额外空间，算不上是最好的方法。LeetCode的discuss版里有人提出了一个更好的解法，我们首先把majority element设置为数组的第一个数字，并且把数字出现的次数设置为co

2016-07-20 21:51:26 276

原创 LeetCode - 179. Largest Number

这道题目的解答非常聪明而巧妙，我们先来看下面的一个例子：str1 = "338"str2 = "9"s1 = str1 + str2 = "3389"s2 = str2 + str1 = "9338"明显9338 > 3389，所以这时我们选择str2在前是明智的。根据上面的分析，我们可以设计出一个比较大小的规则，使得如果上面的情况发生的话，有str1 接口提供了这种功能，

2016-07-20 17:44:24 471

原创 LeetCode - 189. Rotate Array

题目中要求翻转一个数组，注意题目给出的k可能大于数组的长度，所以首先要进行一个预处理，就是k = k % nums.length。解决了这个问题之后，我们可以来考虑翻转的问题，仔细观察后发现，可以用三次翻转数组来解决问题：首先将整个数组反转，接着翻转前k个元素，最后翻转k到第nums.length个元素，这样就可以实现题目中要求的翻转。注意这种方法不仅仅适用于数组，还可以用同样的思路翻转链表，

2016-07-20 10:01:32 350

原创 LeetCode - 199. Binary Tree Right Side View

题目要求写出Binary Tree从右侧看的情况，我们首先可以想到的是基于Level Order Traversal的方法，我们只需要将每一层最右侧的节点加入结果中即可，这种思路的代码如下：public class Solution{ public List rightSideView(TreeNode root){ // Reverse level traversal List r

2016-07-19 22:37:16 257

原创 LeetCode - 200. Number of Islands

和前面一道在矩阵里搜索的题目一样，不过记不太清楚是哪一道题目了，算法都是对matrix中的所有元素进行DFS搜索。每当发现一个'1'也就是找到一个岛的时候，就使用DFS把与它相连的所有为‘1’的元素都设置为‘0’，防止接下来的重复搜索，代码如下：public class Solution { public int numIslands(char[][] grid) {

2016-07-19 21:02:37 216

原创 LeetCode - 201. Bitwise AND of Numbers Range

首先我们要明白的一点是二进制表示的奇数和偶数的AND操作最后一位一定是0，而如果m = n。当m >= n的时候，m和n之间不再有一个奇数和一个偶数，所以这时候我们就初步得到了答案，又因为在寻找这一步的过程中我们把m和n都向右移动了moveNumer位，所以最后的答案还要把刚刚得到的数字向左移动moveNumber位，代码如下：public class Solution { publi

2016-07-19 18:15:30 233

原创 LeetCode - 205. Isomorphic Strings

这道题目的解法非常巧妙，在Java中使用char本身作为数组的index，这样行得通是因为char的表示方法是ASCII，每一个char都会对应一个int，ASCII一共有256个，所以使用一个长度为256的数组来作为HashMap使用。又因为题目中给出了String s和String t的长度是一样的，所以我们可以在一个循环之中同时扫描两个字符串，在循环之中，首先检查两个字符串的当前字符所对应的

2016-07-19 16:54:26 245

原创 LeetCode - 257. Binary Tree Paths

这道题目和前面的Path Sum, Path Sum II, Combination Sum, Combination Sum II, Subsets, Subsets II题目的思路和做法是一样的，需要放在一起多看。但是这道题目与前面不同有一个不太一样的地方，在递归函数中的结尾，只要把前面加进来的一个元素删除就可以了，但是这道题目不仅需要加入元素，还需要加入->，所以删除的方法也不太一样，只要使

2016-07-19 13:26:51 224

原创 LeetCode - 113. Path Sum II

递归地向左子树和右子树寻找，并且在递归调用的时候要注意sum的变化，这个类型的题目以前做过很多个，比如Subsets, Subsets II, Combination Sum, Combination Sum II，这几道题目一定要放在一起看，从而理解这种思想。代码如下：/** * Definition for a binary tree node. * public class Tree

2016-07-19 11:45:48 176

原创 LeetCode - 129. Sum Root to Leaf Numbers

遇到Binary Tree就要想到recursion, divide and conquer，而且这种用单个位的数字组成整个数字的问题也需要多注意一下。一开始的思路想歪了，想这是把所有的数字都算出来，然后再相加，陷入到一个圈子里出不来，后来看了discuss版才发现一直用递归的话程序非常简洁，代码如下：/** * Definition for a binary tree node. * p

2016-07-19 10:54:56 262

原创 LeetCode - 374. Guess Number Higher or Lower

这道题目并没有什么特别可说的地方，看到题目的描述就可以明白这是一个需要使用Binary Search解决的问题，所以直接使用Binary Search即可，代码如下：/* The guess API is defined in the parent class GuessGame. @param num, your guess @return -1 if my number is

2016-07-19 00:15:12 320

原创 LeetCode - 223. Rectangle Area

这道题目的思路比较直接，根据以前做数学题的经验，首先计算出两个长方形的面积，然后进行是否重叠的判断，题目里的重点就在于重叠的判断，判断的方式如下，也比较容易理解：int left = Math.max(A, E);int right = Math.min(C, G);int bottom = Math.max(B, F);int top = Math.min(D, H);

2016-07-17 21:35:07 302

原创 LeetCode - 89. Gray Code

这道题目总的来说可以进行两大步的分析，首先我们需要分析一下对于某个n的时候，会产生多少个gray code：当n = 1时，产生2个gray code；当n = 2时，产生4个gray code；当n = 3时，产生8个gray code；当n = 4时，产生16个gray code；当n = 5时，产生32个gray code；...............

2016-07-17 21:01:04 219

原创 LeetCode - 122. Best Time to Buy and Sell Stock II

相比于上一道题目Best Time to Buy and Sell Stock，这道题目可以交易多次，那么在从前向后扫描数组的过程中，只要后面一天的股票价格高于当今的股票价格，就进行股票的交易，相当于是使用了贪心的思想，代码如下：public class Solution { public int maxProfit(int[] prices) { if(prices

2016-07-17 19:26:42 159

原创 LeetCode - 121. Best Time to Buy and Sell Stock

在从头扫描数组的过程中，我们使用两个变量maxCurr和maxSoFar分别存储当前的差值和到目前为止的最大差值，其中maxCurr = Math.max(0, maxCurr += prices[i] - prices[i - 1])；这行代码的意思就是：当目前的prince差值为正的时候，我们就继续向后推进，而当prince的差值为负的时候，我们就把当前的差值设置为0。同时在每一步中比

2016-07-17 17:51:06 252

原创 LeetCode - 79. Word Search

这道题目的总体思路算是比较清晰，使用双重循环迭代给出的matrix的每一个元素，在遇到每个元素的时候检测从当前这个元素向四个方向出发的单词是不是存在。根据上面的思路我们将检测从当前这个元素出发四个方向的单词是不是存在这一过程写成另外一个函数，并且让它在第一步的函数中被调用。在matrix中从某个元素开始，寻找单词是否存在的路径的时候，我们需要将已经访问过的元素标记为不能访问，这里可以使用另外一

2016-07-17 16:19:36 2024

原创 LeetCode - 120. Triangle

题目中给出的三角形有一个树状的结构，这就可以让我们想到使用遍历之类的算法比如说DFS。但是如果我们忍者你分析一下的话，可以发现相邻的结点总是分享同一条边，也就是说，这道题目中存在重叠子问题(overlapping subproblems)。另外，假设结点x和结点y是k的孩子，只要从底层到结点x和y的最短路径长度都能够知道，那么从底层到结点k的最短路径长度可以在O(1)时间内判断出来，这就是最优子结

2016-07-17 13:45:30 300

原创 LeetCode - 6. ZigZag Conversion

对每一行都使用一个StringBuilder来存储zigzag之后每一行的字符，最后将这些StringBuilder合并并且调用toString()方法。基本的思路是上面这样，但要注意的是index的变化，这道题目zigzag的规律如下：/*n=numRowsΔ=2n-2 1 2n-1

2016-07-17 10:17:57 178

原创 LeetCode - 71. Simplify Path

这道题和罗马数字转换一样，题目的求解方法与背景联系地非常强。基本上的一些规则是，如果遇到.或者“”，就直接跳过；如果遇到..就将上面的一个路径回退。所以根据上面的思想，我们首先用一个Stack存储结果路径中的元素，使用一个Set存储..，. 和“”这种需要跳过的特殊字符，然后将题目中给出的String以/逐个分割开来进行扫描，可能的情况如下：如果遇到..且Stack不为空的话，那么回退Stac

2016-07-16 18:22:38 411

原创 LeetCode - 61. Rotate List

这道题目提供了一个很好的思路，在遇到Linked List的问题时，当看似需要我们移动很多node的时候，我们可以直接移动指向头节点的指针，而不是一个一个地去移动node。另外这道题目还有一个隐藏的陷阱，就是题目中给出的k可能是大于Linked List长度的，所以在解答这道题目的时候还要处理一下这一点。一些例子如下：[1, 2, 3]; k = 2 -> [2, 3, 1]可以直接将头节

2016-07-16 15:03:29 286

空空如也

空空如也