- 博客(91)
- 资源 (3)
- 收藏
- 关注
RSS订阅原创 LeetCode82题：删除链表中的重复元素II（Java）
题目描述：解题思路： 定义一个LInkedHashMap集合存放结点值，key是链表元素值，value是出现次数。首先遍历一次链表，把链表每个结点出现次数存放进map集合。定义一个空链表，然后根据key遍历map集合，如果出现次数大于1，则证明是重复元素。如果等于1，则证明不是重复元素。把不是重复的元素通过尾插法插入到新链表，最后返回新链表即可。代码实现：class Solution { public ListNode deleteDuplicates(ListNode head)
2020-10-24 23:57:46
471
原创 LeetCode234题：回文链表（Java）
题目描述：解法1： 先通过快慢指针，快指针走2步，慢指针走1步，找到链表中间结点。然后通过头插法翻转后半段链表。然后将前半段链表和后半段链表逐个比较，有不相同返回false，全部相同返回true。class Solution { public boolean isPalindrome(ListNode head) { if(head == null) return true; ListNode fast = head, slow = head, pre
2020-10-23 13:21:27
221
1
原创 LeetCode141题：环形链表（Java）
题目描述：解题思路： 判断这种链表中是否有环的情况，最好使用快慢指针的方法。快指针走两步，慢指针走一步，如果链表中不存在环，快慢指针不会相碰。如果存在环，快慢指针迟早会相碰。代码实现：public class Solution { public boolean hasCycle(ListNode head) { if(head == null) return false; ListNode fast = head; ListNode s
2020-10-11 17:32:43
214
原创 LeetCode206题：反转链表（Java）
题目描述：解法1： 这种方法是通过递归的方法复制一个新链表反转链表。首先新建一个有虚假头节点的新链表，然后递归去到旧链表的的最底部，把最底部的元素作为加入到新链表的底部。然后一层层递归，从底到顶，把元素加入到新链表底部。最后返回新链表的反转链表部分即可。 ListNode node = new ListNode(); public ListNode reverseList(ListNode head) { ListNode cur = node;
2020-10-11 17:08:10
172
原创 面试题02.01:移除重复节点（Java）
题目描述：解题思路： 因为要去除重复元素，我们可以通过set集合来存放不相同的元素。首先我们定义一个cur指针，存放head指针地址。这是因为下面head指针会发生变化。然后set集合先存放链表第一个节点值。然后遍历整个链表，判断这个节点的子节点值是否在set集合已存在。若存在，则把指针指向这个节点的子节点的子节点。若不存在，则把head指针向后移。当head为空或者head的子节点为空时，遍历结束。最后返回cur指针即可。代码实现：class Solution { public L
2020-10-09 13:25:39
171
原创 面试02.02.返回倒数第k个节点（Java）
题目描述：解题思路： 因为题目给出的是倒数第k个节点，所以我们先要遍历ListNode，算出所有层数count。然后count - k，就是这个节点顺数的层数。然后我们再遍历ListNode，每遍历一次层数减1，层数为0的时候就是要求的当前层，返回此层的数据即可。代码实现：class Solution { int count = 0; public int kthToLast(ListNode head, int k) { bianli(head);
2020-10-08 10:59:51
103
原创 面试题01.05.一次编辑（Java）
题目描述：解题思路： 根据题目意思，判断一个字符串是否能通过一次操作（可以是插入，删除，替换），得到另一个字符串。要想解决这道题，我们必须先分辨出较长的、较短的字符串。根据字符串的长度，我们可以排除一些情况。因为只能通过一次操作，所以较长字符串和较短字符串之间的长度差不能大于1。而剩下的有两种情况，一种是长度相等，一种是长度相差1。可以使用遍历的方式，判断两个字符串中有多少处不相等的地方。如果超过1处不相等的地方，则说明不能进行转换。代码实现：class Solution { pub
2020-10-06 15:46:37
153
1
原创 剑指Offer68-II：二叉树的最近公共祖先（Java）
题目描述：解题思路： 这道题和上道题不一样，上一道是二叉搜索树，所以树的元素是有规律的，而这道题是二叉树，树里面的元素是没有规律的。所以要解决这道题不能根据规律去解答，我们可以通过递归的方法去解决它。首先从上向下遍历二叉树，比较每个结点的值是否是p，q的值，然后把这个值返回到上一层。当某个结点的左右子树中分别存在p，q结点，且不在同一侧，则说明这个结点是最近公共祖先。如果p或者q结点为空，则证明p和q都在同一列，因为p，q其中有一个在最上面，所以返回后下面的就没有遍历到了。所以不为空的结点就是它
2020-09-28 11:42:23
142
原创 剑指Offer64：求1+2+...+n(Java)
题目描述：解题思路： 首先定义res存储1加到n的和。总体还是使用递归的思想，但是因为不能使用if条件判断递归跳出条件，所以这里使用&&操作跳出循环。当n大于1的时候，&&前面为true，所以可以执行sum（n - 1），如果&&前面为false，所以就跳出循环。代码实现：class Solution { int res = 0; public int sumNums(int n) { boolean x = n
2020-09-23 11:09:34
194
原创 剑指Offer63：股票的最大利润（Java）
题目描述：解题思路： 这道题可以用动态规划的方法去求最大利润。首先定义一个dp数组存放利润。假设第一天买进，因为第一天买进不卖出，所以利润为0，即dp[0] = 0;设置一个min表示最小值，因为只有设置最小值，我们才知道什么时候买进是最低价。思路是：今天卖出的利润和前一天卖出的利润进行比较，哪个利润大就存储哪天的利润。返回最后一天的利润就是股票的最大利润。代码实现：class Solution { public int maxProfit(int[] prices) {
2020-09-23 10:41:30
356
原创 ArrayList的底层源码剖析
最近也是回去看了看ArrayList相关的源码，觉得受益匪浅。还是写篇博客记录一下。 从源码的开头头看，ArrayList定义了几个属性。private static final int DEFAULT_CAPACITY = 10;private static final Object[] EMPTY_ELEMENTDATA = {};private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};tra
2020-09-22 19:52:54
125
原创 剑指Offer62：圆圈中最后剩下的数字（Java）
题目描述：解题思路： 这道题我们可以通过定义一个list集合去解决它。首先我们把所有的元素加入到list集合里，因为题目要求每次从n个数中删除第m个数，假如m是3，n是5，那么第一次删除的就是m-1下标的元素，而第二次删除的就是m-2下标开始数，第3个元素也就是m + m - 1下表的元素，但是因为此时下标已经越界了，此时我们可以通过取余去找到这个元素的下标，但是因为每次都会删除一个元素，n会不断减少，取余时n也要跟着减少才行。当list只剩最后一个，把那个元素取出来即可。代码实现：clas
2020-09-22 10:50:16
89
原创 剑指Offer61：扑克牌中的顺子（Java）
题目描述：解题思路： 首先我们要对nums数组进行排序，算出0的个数，因为在顺子中0可以相当于万能牌，可以代替任何的牌。然后我们从0后面的元素开始遍历数组，如果第i个数和第i+1个数之间相差1，则证明是连续的，此时zero减去1，表示可以用一张万能牌替代。如果相差大于1，则需要更多的万能牌。如果万能牌数量最后为负数，则证明代码实现：class Solution { public boolean isStraight(int[] nums) { Arrays.sort(
2020-09-21 12:05:01
207
原创 剑指Offer59-II:队列的最大值（Java）
题目描述：解题思路： 这道题的思路就是通过一个辅助的双端队列来实现它，而LinkedList继承了Deque接口，所以我们定义两个LinkedList即可。MaxQueue方法是创建队列，我们直接在方法里实例化对象即可。max_value方法是最取出最大值的方法，而我们下面把最大值放在双端队列里，从大到小排列，因此取头部元素即可。push_back方法是放进元素的方法，这个比较讲究。首先list1是主队列，元素直接放进去就好了。因为list2是双端队列，放的是最大值。这时候我们要判断list1先
2020-09-16 15:40:55
114
原创 剑指Offer59-I：滑动窗口的最大值（Java）
题目描述：解法1： 这种解法思路比较简单。首先构造双指针，一个在前，一个在后，这样就可以构成一个滑动窗口。因为滑动窗口的大小是k，因此我们也可以使用一个指针来完成。一个指针为i，一个指针为i+k-1；只要后指针还没到达数组底部，每次前后指针都同时前移一个单位。然后我们通过for循环比较出窗口中元素的最大值，并记录下来。最后返回记录数组即可。class Solution { int count = 0; public int[] maxSlidingWindow(int[] nu
2020-09-14 16:15:31
147
原创 剑指Offer58-II：左旋转字符串（Java）
题目描述：解法思路： 这道题是一道很简单的题目。其实只要找到要旋转的字符串，然后直接拼接在剩下的字符串的后面即可。代码实现：class Solution { public String reverseLeftWords(String s, int n) { String s1 = s.substring(0, n); String s2 = s.substring(n, s.length()); return s2 + s1;
2020-09-14 15:28:49
150
原创 剑指Offer58-I：翻转单词顺序（Java）
题目描述：解法1： 这种解法是使用截取字符串的办法。首先我们把头尾空格去掉，使用分割函数根据空格，把不是空格的内容分割出来。然后我们从分割数组的底部遍历，每遍历的一个元素，就添加到字符串缓冲区对象中，同时在后面加空格分隔，但是因为字符串最后是没有空格的，所以添加空格时要避免这种情况。最后把字符缓冲区对象转换成字符串即可。class Solution { public String reverseWords(String s) { String[] str = s.tri
2020-09-13 20:29:32
124
原创 剑指Offer57-II：和为s的连续正数序列（Java）
题目描述：解法思路： 这道题虽然是简单，可是刚做的时候也没有思路，看了题解才知道使用滑动窗口去解答这道题。之前从没了解过滑动窗口是什么，现在学到了、学到了。 根据题意，我们要找一个连续的正数序列，它的和为target。其实这个连续的正数序列，就是一个窗口。那么滑动呢？滑动的意思是，就是窗口大小的改变。其实也有点像双指针，不过上题使用的是碰撞双指针，这题不是。左指针是窗口的左边界，也就是窗口元素的最小值。右指针是窗口的右边界，也就是窗口元素的最大值。我们可以获取窗口里的元素和，与targe
2020-09-13 12:14:31
157
原创 剑指Offer57：和为s的两个数字（Java）
题目描述：解法1： 这种解法是通过HashSet去解决它。道理很简单，遍历数组，因为题目说两个数相加等于target，那我就把target减去每个数剩下值存入set中。每次存入时先判断set是否已经有存在这个数，如果有，则证明在这个数之前，有一个数和现在的数相加等于target。那么返回一个包含这两个数的数组即可。但是这种方法效率不高。class Solution { public int[] twoSum(int[] nums, int target) { Set&l
2020-09-13 12:03:54
100
原创 剑指Offer56-I：数组中数字出现的次数（Java）
题目描述解题思路： 其实这道题和它的下一题都是大同小异的，一个是目标元素只有一个，一个是目标元素有两个。使用常规解法，通过HashMap去解决它。遍历数组，把数组元素出现的次数存储在HashMap中。然后遍历HashMap，发现出现次数为1的元素，则添加到新数组里，最后返回新数组即可。但是这种解法，运行速度慢。代码实现：class Solution { int count = 0; public int[] singleNumbers(int[] nums) {
2020-09-12 16:20:00
216
原创 剑指Offer56-II：数组中数字出现的次数II（Java）
题目描述：解法1： 常规解法，使用HashMap解决。遍历数组，通过HashMap存储数组中的元素出现的次数，最后再遍历HashMap，发现出现次数为1的元素返回即可。class Solution { public int singleNumber(int[] nums) { Map<Integer, Integer> map = new HashMap<>(); for(int i = 0; i < nums.length
2020-09-12 16:13:50
216
原创 剑指Offer55-II：平衡二叉树（Java）
题目描述：解法思路： 其实这道题和上一道题求二叉树的深度差不多，我们可以定义一个布尔类型的flag，初始值为false，用来判断是否是平衡二叉树。在上道题的基础上，先求出每层左右子树的深度，然后看左右子树的深度的绝对值相差是否大于1。大于1，证明该树不是平衡二叉树，flag改为false。最后返回flag即可。 值得注意的是，我们要注意剪枝的问题，不然就会出现超时的情况。什么是剪枝呢？就好像已经知道左子树存在不符合平衡二叉树的情况，此时就没有必要再去判断右子树了,也就是剪去右子树不做判断
2020-09-12 12:02:22
88
原创 剑指Offer53-II：0~n-1中缺失的数字（Java）
题目描述：解法1： 定义一个布尔类型数组，用来判断nums数组中的哪些元素存在，初始值都为false。遍历nums数组，把数组值得布尔数组位置改为true。然后遍历布尔数组，当发现哪个位置还为false，则这个位置就是nums数组中缺失得数字。class Solution { public int missingNumber(int[] nums) { boolean[] flag = new boolean[nums.length+1]; for(in
2020-09-11 13:09:42
140
原创 剑指Offer55-I：二叉树的深度（Java）
题目描述：解题1： 这种解法是通过层序遍历去解决这道题。定义一个dep变量代表深度，定义一个队列。开始把根节点加入到队列中，然后通过for循环，把根节点移除，把这层节点的左右子树都加入到队列中，只要队列不为空，就会一直找下一层的子树。每层遍历的时候，深度加1。当队列为空时，证明这颗树全部节点已经遍历完成，此时的深度就是整棵子树的深度，返回深度即可。class Solution { public int maxDepth(TreeNode root) { int dep
2020-09-11 12:46:27
90
原创 剑指Offer54：二叉搜索树的第k大节点（Java）
题目描述：解法思路： 根据题目意思，要找二叉搜索树的第k大节点。那么我们可以想一下，如果我们要找二叉树的最小节点要怎么找呢？直接中序遍历就能找到最左的节点，最左的节点也就是最小的节点。同理，我们要找最大节点，只需要把中序遍历改一下即可，中序遍历的顺序是左 -> 根 -> 右，那么我们改成右 -> 根 -> 左。因为题目是找到第k大，那么直接判断k是否等于1，k不等于1，就k减去1，返回上一层，当k等于1，记录节点值。最后返回节点值即可。代码实现：class Solut
2020-09-11 11:11:58
148
原创 剑指Offer53-I：在排序数组中查找数字I（Java）
题目描述：解法1： 定义一个足够大的整型数组来存放数字出现的次数，遍历整型数组，把数组的每个数字变为字符，通过ascii码的方式找到对应位置存储。当有相同的数出现时，出现的次数加1。最后直接返回返回目标元素出现的元素即可。class Solution { public int search(int[] nums, int target) { int[] count = new int[100000]; for(int num : nums){
2020-09-10 20:08:16
153
原创 剑指Offer50：第一个只出现一次的字符（Java）
题目描述：解法1： 解法思路很简单，遍历字符串，通过一个有序的LinkedHashMap存放每次遍历的到字符，key是字符，value是字符出现的次数。如果map集合之前已经有存放这个字符，就在原来的字符次数上加1，如果没有出现过，则把它添加进集合。最后遍历map集合，取出第一个出现次数为1的字符即可。可是这种办法因为使用了两次for循环和哈希表，所以运行时间比较长。class Solution { public char firstUniqChar(String s) {
2020-09-10 11:12:17
123
原创 剑指Offer47：礼物的最大价值（Java）
题目描述：解法1： 这是一道经典的动态规划题目。这道题没有要求不能在原来的数组上修改，所以我们可以定义一个新数组或者在原来的数组上修改。但是一般的话，我们都是创建一个和原来数组大小一样的新数组来存放结果。 首先，我们定义一个新数组。然后使用动态规划的思想，除去第一列和第一行，其他位置都有两种方法可以到达。一种是纵向，一种是横向，我们只要取其中价值最大的一种即可。对于第一列的元素，相互之间只能是横向到达。而第一行的元素，相互之间只能是纵向到达。最终，我们返回终点的元素就是这个二维数组的最大
2020-09-08 19:00:35
227
原创 剑指Offer42：连续子数组的最大和（Java）
题目描述：解题思路： 这道题也是用到了动态规划的方法的去解决它。定义一个dp数组，用来存放输入数组的相加和。每次我们判断之前相加的和是否小于0，小于0时则说明此时加上nums[i]，还没有nums[i]本身大，所以直接dp[i]=nums[i],如果之前相加的和大于等于0，此时应该dp[i]=dp[i-1]+nums[i];此时我们还需要定义一个max值，来判断出函数的最大相加和。因为有的时候，像nums[i]是一个负数，可是加上dp[i-1]，dp[i]还是大于0，但是dp[i]没有dp[i-
2020-09-08 16:24:26
95
原创 剑指Offer46：把数字翻译成字符串（Java）
题目描述：解法思路： 其实这道题和之前的青蛙跳台阶问题很像，青蛙可以一次跳1阶，也可以一次跳2阶。这里的翻译也是，可以一次翻译一个字母，也可以一次翻译两个字母。针对这种问题，我们可以使用动态规划的方法，通过状态转移的方式去解决它。我们可以先算出前面两个元素的翻译次数，dp[0]因为元素只有一个所以只有一种翻译方式，dp[1]因为有两个元素，它可以分开一个个翻译，也可以两个一起翻译，因此dp[1]=2。从dp[2]开始，就有三个元素。想求出dp[2]的次数，可以这样看。先单独翻译第一个元素，后面两个元
2020-09-08 11:45:12
168
原创 剑指Offer40：最小的k个数（Java）
题目描述：解法1： 这种解法的思路比较简单，就是调用Arrays类中的sort排序方法，对数组进行排序，取出坐标k之前的元素即可。但是运行时间不快。class Solution { public int[] getLeastNumbers(int[] arr, int k) { Arrays.sort(arr); int[] res=new int[k]; for(int i=0;i<k;i++){ res[
2020-09-04 10:59:04
92
原创 剑指Offer39：数组中出现超过一半的数字（Java）
题目描述：解法1： 这种解法是通过map集合去实现，定义一个map集合，key是数组元素，value是数组元素出现的次数。我们遍历数组元素，当map集合中有相同数组元素的时候，就把它的出现次数加1，没有出现过，则把数组元素和出现次数1放进去。当有元素出现的次数大于数组长度的一半时，就返回此元素。class Solution { public int majorityElement(int[] nums) { int length=(int)Math.ceil(nums.
2020-09-04 10:50:19
164
原创 剑指Offer36：二叉搜索树和双向链表（Java)
题目描述：解题思路： 从题目我们可以发现，这个双向链表的顺序是中序遍历。而中序遍历的顺序是左节点、根节点、右节点。这个可以使用递归的方法去实现它。其次双向链表，我们可以通过定义两个指针head、last实现它。head表示头节点，last表示上一个节点。当遍历到第一个元素的时候，判断头节点是否为空，为空则把头节点指向第一个节点。然后判断last节点是否为空，last节点为空，则证明当前是遍历的是头节点，last节点等于头节点。如果last节点不为空，则证明当前遍历的是头节点后面的节点，此时可以
2020-09-03 11:02:28
115
原创 剑指Offer33：二叉搜索树的后序遍历序列（Java）
题目描述：解题思路： 后序遍历有个特点，就是根节点是后序遍历数组的最后一个元素。从前根节点往前，最后一个大于它的元素往后的，都是右子树的节点，而它前面的则是左子树的节点。在例子中，5是根节点，5的前面最后一个比它大的是6，所以5的右子树节点只有6，1、3、2则是5的左子树节点。然后每一个的左子树和右子树又可以拆分左右子树。当左边界大于等于右边界的时候，节点只剩下一个或者没有了，证明树已经遍历完了。代码实现：class Solution { public boolean verifyP
2020-09-02 15:13:12
119
原创 剑指Offer35：复杂链表的复制（Java）
题目描述：解题思路： 这道题跟普通的复制链表的思路一样，不同的是他有个random指向。首先创建一个新的链表，通过递归调用的方式，不断把值赋给新的链表。同时我们通过一个Map集合来保存random的指向，根据random，我们可以在Map集合中找到之前random指针指向的node节点，并把它赋值给random指针。代码实现：class Solution { Map<Node,Node> nodeMap = new HashMap<>(); publi
2020-09-02 11:26:23
191
原创 剑指Offer32-III：从上到下打印二叉树III（Java)
题目描述：解题思路： 这道题和前一题差不多，思路也是一样的，不同的是，这题多了一个排序问题。每隔一层，输出的顺序就改变一次。解决这个问题很简单，我们只需要定义一个布尔变量标志即可。每隔一层，布尔变量就取反。判断布尔变量的值，假如是反的话，就把当前层的list集合倒序即可。代码实现：/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left;
2020-08-31 08:45:11
142
原创 剑指Offer32-II：从上到下打印二叉树II（Java）
题目描述：解题思路： 这题和前面一题的思路大体不变，也是通过广度优先搜索去解决，使用队不断把下一层的元素加进去，再把索引值保存起来。不同的是，这题是要把每一层的元素作为一个集合保存起来。那我们可以定义一个辅助集合，用来保存每一层的元素。当上一层元素加进来，通过for循环，把上层的元素的子节点加入到辅助集合，然后把它的子节点加进队里。每层元素遍历完了，就把辅助集合添加到最终返回的list集合。代码实现：/** * Definition for a binary tree node. * p
2020-08-30 09:28:42
158
原创 剑指Offer32：从上到下打印二叉树（Java）
题目描述：解题思路： 通过题目，我们可以发现这是一个广度优先搜索。而实现广度优先搜索，最好的就是使用队列。首先因为我们不知道元素的个数，无法定义数组的长度，所以我们使用一个集合list来存放索引值。通过一个while循环，当队列不为空时，我们不断把当前层的元素加到list中，然后把它的子节点加到队列里。最后通过for循环，再把list里面的索引值放到数组里就好啦。代码实现：class Solution { public int[] levelOrder(TreeNode root)
2020-08-29 09:05:18
100
原创 剑指Offer31：栈的压入、弹出序列（Java）
题目描述：解题思路： 一开始想不到思路，看了题解总归想到了。首先，我们需要一个辅助栈，根据压栈序列不断压栈，但是在每次压栈的时候，我们就要根据出栈序列，如果出栈序列的元素和辅助栈的栈顶元素相等，就把他出栈。同时我们可以定义一个变量，定义出栈序列遍历到的位置。如果出栈序列是正确的，那么辅助栈最终会空，栈中元素会全部出栈。如果出栈序列不正确，那么辅助栈最终一定不为空。代码实现：class Solution { public boolean validateStackSequences(i
2020-08-28 10:06:52
186
原创 剑指Offer21：调整数组顺序使奇数位于偶数前面（Java）
题目描述：解法1： 这是一种比较暴力的解法。定义两个list集合，存放数组中的奇数和偶数。遍历数组，分别把数放进对应集合。最后从先把奇数集合里的数添加到数组里，再把偶数集合里的数添加到数组里。但是这样使用了三个for循环，所以运行时间比较长。class Solution { public int[] exchange(int[] nums) { List<Integer> list1=new ArrayList<>(); List
2020-08-19 18:04:35
163
Echarts图表使用.zip
2020-05-19
mysql-connector.zip
2020-05-19
bmob-android-sdk-master.zip
2020-05-19
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人