<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[xing_ran_ran的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/xing_ran_ran</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; xing_ran_ran]]></copyright><item><title><![CDATA[LeetCode 热题 HOT 100 - 48. 旋转图像]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114749159</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114749159</guid><author>xing_ran_ran</author><pubDate>Sat, 13 Mar 2021 15:59:45 +0800</pubDate><description><![CDATA[思路：先以对角线（左上&lt;—&gt;右下）为轴进行翻转，再对每行左右翻转即可

参考官方解答方法三https://leetcode-cn.com/problems/rotate-image/solution/xuan-zhuan-tu-xiang-by-leetcode-solution-vu3m/


class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;//行数
      ..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 46. 全排列]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114678813</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114678813</guid><author>xing_ran_ran</author><pubDate>Thu, 11 Mar 2021 21:12:32 +0800</pubDate><description><![CDATA[思路：回溯（树形结构上的深度优先遍历）

回溯算法的复杂度主要由递归树的节点个数决定，时间复杂度是指数级别的，本质上是一种遍历的算法！

回溯算法是用一份状态变量遍历整个状态空间的方法，只需要在合适的状态做一个保存即可。这种遍历相对于广度优先是节约空间的。


class Solution {
    public List&lt;List&lt;Integer&gt;&gt; permute(int[] nums) {
        //输入数组长度
        int n = nums.len..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 39. 组合总和]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114674326</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114674326</guid><author>xing_ran_ran</author><pubDate>Thu, 11 Mar 2021 19:57:29 +0800</pubDate><description><![CDATA[思路：回溯

对于这类寻找所有可行解的题，我们都可以尝试用「搜索回溯」的方法来解决。

参考https://leetcode-cn.com/problems/combination-sum/solution/hui-su-suan-fa-jian-zhi-python-dai-ma-java-dai-m-2/




class Solution {
    public List&lt;List&lt;Integer&gt;&gt; combinationSum(int[] candidates, i..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 34. 在排序数组中查找元素的第一个和最后一个位置]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114669805</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114669805</guid><author>xing_ran_ran</author><pubDate>Thu, 11 Mar 2021 17:11:43 +0800</pubDate><description><![CDATA[思路：二分查找



1）查找目标元素在有序数组中出现的第一个位置；如果第一个位置都没有找到的话，说明目标元素在有序数组中并不存在。

2）查找目标元素在数组中出现的最后一个位置；如果找到了最后一个位置，就将第一个位置和最后一个位置封装成一个数组返回。

——时间复杂度： O(logn) ，其中 n 为数组的长度。二分查找的时间复杂度为 O(logn)，一共会执行两次，因此总时间复杂度为 O(logn)。

——空间复杂度：O(1) 。只需要常数空间存放若干变量。


class Solution {
..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 33. 搜索旋转排序数组]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114647360</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114647360</guid><author>xing_ran_ran</author><pubDate>Thu, 11 Mar 2021 15:49:01 +0800</pubDate><description><![CDATA[思路：
]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 31. 下一个排列]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114646042</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114646042</guid><author>xing_ran_ran</author><pubDate>Wed, 10 Mar 2021 21:17:37 +0800</pubDate><description><![CDATA[“下一个排列”的定义是：给定数字序列的字典序中下一个更大的排列。如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

思路：



——时间复杂度：O(N)，其中 N 为给定序列的长度。我们至多只需要扫描两次序列，以及进行一次反转操作。

——空间复杂度：O(1)，只需要常数的空间存放若干变量。


class Solution {
    public void nextPermutation(int[] nums) {
        int i = nums.length -..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 22. 括号生成]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114643809</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114643809</guid><author>xing_ran_ran</author><pubDate>Wed, 10 Mar 2021 20:42:05 +0800</pubDate><description><![CDATA[思路：回溯

参考https://leetcode-cn.com/problems/generate-parentheses/solution/pei-yang-chou-xiang-si-wei-hui-su-jie-fa-7dwu/




class Solution {
    public List&lt;String&gt; generateParenthesis(int n) {
        List&lt;String&gt; res = new ArrayList&lt;Strin..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 19. 删除链表的倒数第 N 个结点]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114640716</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114640716</guid><author>xing_ran_ran</author><pubDate>Wed, 10 Mar 2021 19:27:15 +0800</pubDate><description><![CDATA[思路：双指针

删除倒数第n个节点等价于从列表头开始数起的第(L-n+1)个节点，其中L是链表的长度





先让快指针前进两步，同时移动快慢指针，直到快指针走过最后一个节点，此时慢指针指向倒数第n+1个节点；删去慢指针的后继即可。

     


	时间复杂度：O(L)，其中L是链表的长度。
	
	
	空间复杂度：O(1)。
	

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     ...]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 17. 电话号码的字母组合]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114631421</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114631421</guid><author>xing_ran_ran</author><pubDate>Wed, 10 Mar 2021 16:56:08 +0800</pubDate><description><![CDATA[思路：回溯

1）建立数字-&gt;字母的映射关系；2）定义递归函数



（注：如果是纯字符串拼接，会生成很多临时对象，性能会略差，Java实现中是用StringBuilder做拼接的，经测试耗时0毫秒，如果是用String类型做拼接耗时是6毫秒）




class Solution {
    public List&lt;String&gt; letterCombinations(String digits) {
        List&lt;String&gt; combinations...]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 15. 三数之和]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114629686</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114629686</guid><author>xing_ran_ran</author><pubDate>Wed, 10 Mar 2021 11:15:59 +0800</pubDate><description><![CDATA[思路：排序+双指针



问题就变成：在一个排序数组中找到所有的两数之和使得其和等于一个特殊值？可以通过双指针法在O(N)时间内解决这个问题。即两个指针分别指向数组的首尾，如果和小于目标值，头指针向后移，使得和增大；如果和大于目标值，尾指针向前移，使得和减小。

——时间复杂度：O(N^2)，其中 N 是数组nums 的长度。

——空间复杂度：O(logN)。我们忽略存储答案的空间，额外的排序的空间复杂度为 O(logN)。然而我们修改了输入的数组 nums，在实际情况下不一定允许，因此也可以看成使用..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 11. 盛最多水的容器]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114629123</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114629123</guid><author>xing_ran_ran</author><pubDate>Wed, 10 Mar 2021 10:33:56 +0800</pubDate><description><![CDATA[思路：双指针

在初始时，左右指针分别指向数组的左右两端；然后我们需要移动一个指针。移动哪一个呢？直觉告诉我们，应该移动对应数字较小的那个指针（即此时的左指针）。这是因为，由于容纳的水量是由 两个指针指向的数字中较小值 * 指针之间的距离 决定的。


	时间复杂度：O(N)，双指针总计最多遍历整个数组一次。
	
	
	空间复杂度：O(1)，只需要额外的常数级别的空间。
	

public class Solution {
    public int maxArea(int[] height) {
 ..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 5. 最长回文子串]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114545750</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114545750</guid><author>xing_ran_ran</author><pubDate>Wed, 10 Mar 2021 10:03:48 +0800</pubDate><description><![CDATA[子串：原始字符串的一个连续子集

子序列：原始字符串的一个子集


思路：动态规划

回文串是天然具有状态转移性质的，这是因为一个回文去掉两头以后，剩下的部分依然是回文。回文的长度要严格大于2。如果一个子串两头的字符不相等，一定不是回文串。如果一个子串两头的字符相等，需要看去掉两头以后剩下部分的子串是否是回文。




...]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 3. 无重复字符的最长子串]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114539510</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114539510</guid><author>xing_ran_ran</author><pubDate>Mon, 08 Mar 2021 19:29:27 +0800</pubDate><description><![CDATA[思路：滑动窗口



1）我们使用两个指针表示字符串中的某个子串（或窗口）的左右边界，其中左指针代表着上文中「枚举子串的起始位置」，而右指针即为上文中的「不包含重复字符的最长子串的结束位置」；

2）在每一步的操作中，我们会将左指针向右移动一格，表示 我们开始枚举下一个字符作为起始位置，然后我们可以不断地向右移动右指针，但需要保证这两个指针对应的子串中没有重复的字符。在移动结束后，这个子串就对应着 以左指针开始的，不包含重复字符的最长子串。我们记录下这个子串的长度；

3）在枚举结束后，我们找到的最长的..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 2. 两数相加]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114535799</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114535799</guid><author>xing_ran_ran</author><pubDate>Mon, 08 Mar 2021 17:15:20 +0800</pubDate><description><![CDATA[思路：



——时间复杂度：O(max(m,n))，其中 m,n 为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要 O(1) 的时间。
——空间复杂度：O(max(m,n))。答案链表的长度最多为较长链表的长度 +1。


/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 * ..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 617. 合并二叉树]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114525343</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114525343</guid><author>xing_ran_ran</author><pubDate>Mon, 08 Mar 2021 15:52:08 +0800</pubDate><description><![CDATA[思路1：深度优先搜索

可以使用深度优先搜索合并两个二叉树。从根节点开始同时遍历两个二叉树，并将对应的节点进行合并。

两个二叉树的对应节点可能存在以下三种情况，对于每种情况使用不同的合并方式。

   如果两个二叉树的对应节点都为空，则合并后的二叉树的对应节点也为空；

   如果两个二叉树的对应节点只有一个为空，则合并后的二叉树的对应节点为其中的非空节点；

   如果两个二叉树的对应节点都不为空，则合并后的二叉树的对应节点的值为两个二叉树的对应节点的值之和，此时需要显性合并...]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 543. 二叉树的直径]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114489550</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114489550</guid><author>xing_ran_ran</author><pubDate>Mon, 08 Mar 2021 10:58:02 +0800</pubDate><description><![CDATA[思路：

注意题目要求不能使用额外空间，这就是题目的难点所在。
这道题的描述部分包含了非常重要的信息，1 ≤ a[i] ≤ n，即每个数字本身都对应一个 i-1 的数组下标。
我们可以利用数组内容本身跟数字下标的关联找出缺失的数字。

...]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 283. 移动零]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114485751</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114485751</guid><author>xing_ran_ran</author><pubDate>Sun, 07 Mar 2021 16:57:34 +0800</pubDate><description><![CDATA[思路：双指针（快慢指针）

初始状态：i (fast)指向当前遍历的元素 ； j (slow)表示下一个非0元素存放的位置






	时间复杂度：O(n)，其中n为序列长度。每个位置至多被遍历两次。
	
	
	空间复杂度：O(1)。只需要常数的空间存放若干变量。
	

public void moveZeroes(int[] nums) {
    if (nums == null || nums.length == 0) {
        return;
    }
    int slow...]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 234. 回文链表]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114456566</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114456566</guid><author>xing_ran_ran</author><pubDate>Sat, 06 Mar 2021 21:54:29 +0800</pubDate><description><![CDATA[思路：快慢指针

避免使用 O(n) 额外空间的方法就是改变输入。

我们可以将链表的后半部分反转（修改链表结构），然后将前半部分和后半部分进行比较。比较完成后我们应该将链表恢复原样。虽然不需要恢复也能通过测试用例，但是使用该函数的人通常不希望链表结构被更改。

该方法虽然可以将空间复杂度降到 O(1)，但是在并发环境下，该方法也有缺点。在并发环境下，函数运行时需要锁定其他线程或进程对链表的访问，因为在函数执行过程中链表会被修改。

整个流程可以分为以下五个步骤：

过滤掉空链表或者单节点链表的情况，这..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 226. 翻转二叉树]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114455816</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114455816</guid><author>xing_ran_ran</author><pubDate>Sat, 06 Mar 2021 20:51:38 +0800</pubDate><description><![CDATA[思路：递归

从根节点开始，递归地对树进行遍历，并从叶子结点先开始翻转。如果当前遍历到的节点 \textit{root}root 的左右两棵子树都已经翻转，那么我们只需要交换两棵子树的位置，即可完成以 \textit{root}root 为根节点的整棵子树的翻转。

——时间复杂度：O(N)，其中 N 为二叉树节点的数目。我们会遍历二叉树中的每一个节点，对每个节点而言，我们在常数时间内交换其两棵子树。

——空间复杂度：O(N)。使用的空间由递归栈的深度决定，它等于当前节点在二叉树中的高度。在平均情况下..]]></description><category></category></item><item><title><![CDATA[LeetCode 热题 HOT 100 - 206. 反转链表]]></title><link>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114454089</link><guid>https://blog.youkuaiyun.com/xing_ran_ran/article/details/114454089</guid><author>xing_ran_ran</author><pubDate>Sat, 06 Mar 2021 20:32:48 +0800</pubDate><description><![CDATA[思路1：迭代

初始：





——时间复杂度：O(n)，其中n是链表的长度。需要遍历链表一次。

——空间复杂度：O(1)。


/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListN...]]></description><category></category></item></channel></rss>