<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[anda0242的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/anda0242</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; anda0242]]></copyright><item><title><![CDATA[全错排列]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316273</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316273</guid><author>anda0242</author><pubDate>Fri, 27 Sep 2019 21:39:00 +0800</pubDate><description><![CDATA[题目描述有n个小朋友，每个小朋友都有自己的座位。恰好每个小朋友都坐错座位的方式有多少种？n &lt;= 66
输入描述：
第1行，一个自然数，表示小朋友的个数。
输出描述：
输出一个整数，表示符合条件的坐法有多少种?
笔试遇到了， 错排公式： Dn = (n-1)(Dn-1+Dn-2)。

转载于:https://www.cnblogs.com/Shinered/p/11600...]]></description><category></category></item><item><title><![CDATA[二叉树中第 K小的元素]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316274</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316274</guid><author>anda0242</author><pubDate>Tue, 10 Sep 2019 17:05:00 +0800</pubDate><description><![CDATA[给定一个二叉搜索树，编写一个函数kthSmallest来查找其中第k个最小的元素。
说明：你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。
思路： 二叉搜索树因其有序，故采用中序遍历，可以得到第K小的元素。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     i...]]></description><category></category></item><item><title><![CDATA[二叉树的最近祖先]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316271</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316271</guid><author>anda0242</author><pubDate>Mon, 09 Sep 2019 22:19:00 +0800</pubDate><description><![CDATA[给定一个二叉树，找到该树中指定节点的最近公共祖先。

其中节点5和节点1的最近公共祖先是节点3。
说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中

解决思路：
1.如果根节点的左右子树分别存在p,q，则返回此刻的根节点。
2.如果根节点和左子树都不是节点，p,q，则可以根据公共祖先必定在右子树。
3.否则公共祖先必在则在左子树。
...]]></description><category></category></item><item><title><![CDATA[排序链表]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316272</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316272</guid><author>anda0242</author><pubDate>Wed, 04 Sep 2019 11:12:00 +0800</pubDate><description><![CDATA[在O(nlogn) 时间复杂度和常数级空间复杂度下，对链表进行排序。
1. 利用递归的归并排序，自顶向下递归解决问题。

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(!head) return NULL;
        int length = 0;
  ...]]></description><category></category></item><item><title><![CDATA[二叉搜索树的最近公共祖先]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316270</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316270</guid><author>anda0242</author><pubDate>Tue, 03 Sep 2019 16:08:00 +0800</pubDate><description><![CDATA[给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。

示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8输出: 6...]]></description><category></category></item><item><title><![CDATA[反转一个单链表]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316269</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316269</guid><author>anda0242</author><pubDate>Fri, 30 Aug 2019 16:00:00 +0800</pubDate><description><![CDATA[反转一个单链表。
示例:
输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL
输出: 5-&gt;4-&gt;3-&gt;2-&gt;1-&gt;NULL

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode...]]></description><category></category></item><item><title><![CDATA[LRU缓存机制]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316268</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316268</guid><author>anda0242</author><pubDate>Thu, 29 Aug 2019 17:30:00 +0800</pubDate><description><![CDATA[运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。
获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最...]]></description><category></category></item><item><title><![CDATA[相交列表]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316114</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316114</guid><author>anda0242</author><pubDate>Tue, 27 Aug 2019 21:43:00 +0800</pubDate><description><![CDATA[编写一个程序，找到两个单链表相交的起始节点。
注意：
如果两个链表没有交点，返回 null.在返回结果后，两个链表仍须保持原有的结构。可假定整个链表结构中没有循环。程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
思路：题目要求用O(n)的时间复杂度：
1.两链表一同遍历，如果pA遍历结束，则pA=headB.
2.两链表一同遍历,如果pB遍历结束，则pB=head...]]></description><category></category></item><item><title><![CDATA[删除链表中的节点]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316116</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316116</guid><author>anda0242</author><pubDate>Tue, 27 Aug 2019 18:08:00 +0800</pubDate><description><![CDATA[写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
因为函数只给定了一个参数，表面该节点就是要删除的结点。然后直接用下一个结点覆当前结点。
开始没想到，因为一般都是先找前一个结点，以及下一个结点，这道题是直接用下一个结点覆盖当前结点。

/**
 * Definition for singly-linked list.
 * struct ...]]></description><category></category></item><item><title><![CDATA[除自身以外数组的乘积]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316113</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316113</guid><author>anda0242</author><pubDate>Tue, 27 Aug 2019 17:58:00 +0800</pubDate><description><![CDATA[给定长度为n的整数数组nums，其中n &gt; 1，返回输出数组output，其中 output[i]等于nums中除nums[i]之外其余各元素的乘积。
说明:请不要使用除法，且在O(n) 时间复杂度内完成此题。
思路：乘积值应该是左边值乘以右边值。需要循环两遍，才能得到正确的结果。

class Solution {
public:
    v...]]></description><category></category></item><item><title><![CDATA[2的幂]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316267</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316267</guid><author>anda0242</author><pubDate>Tue, 27 Aug 2019 17:37:00 +0800</pubDate><description><![CDATA[给定一个整数，编写一个函数来判断它是否是 2 的幂次方。
输入: 1
输出: true
解释: 20= 1

可以用位运算，2的幂次n必定只有一个1,和n-1进行与运算后必然为0。

class Solution {
public:
    /*
    bool isPowerOfTwo(int n) {
        if(n &lt;= 0) retur...]]></description><category></category></item><item><title><![CDATA[反转字符串中的单词]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316265</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316265</guid><author>anda0242</author><pubDate>Mon, 26 Aug 2019 16:41:00 +0800</pubDate><description><![CDATA[给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
示例1:
输入: "Let's take LeetCode contest"输出: "s'teL ekat edoCteeL tsetnoc"注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

class Solution {
public:
  
   ...]]></description><category></category></item><item><title><![CDATA[环形链表]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316264</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316264</guid><author>anda0242</author><pubDate>Sat, 24 Aug 2019 16:26:00 +0800</pubDate><description><![CDATA[给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
思路，利用哈希表，或者集合去重的特性。

/**
 * Defin...]]></description><category></category></item><item><title><![CDATA[买卖股票的最佳时机2]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316262</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316262</guid><author>anda0242</author><pubDate>Fri, 23 Aug 2019 16:37:00 +0800</pubDate><description><![CDATA[给定一个数组，它的第i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [7,1,5,3,6,4]输出: 7解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, ...]]></description><category></category></item><item><title><![CDATA[买卖股票的最佳时机]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316263</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316263</guid><author>anda0242</author><pubDate>Fri, 23 Aug 2019 16:17:00 +0800</pubDate><description><![CDATA[给定一个数组，它的第i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
注意你不能在买入股票前卖出股票。
示例 1:
输入: [7,1,5,3,6,4]输出: 5解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 ...]]></description><category></category></item><item><title><![CDATA[二叉树最大深度]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316260</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316260</guid><author>anda0242</author><pubDate>Thu, 22 Aug 2019 16:25:00 +0800</pubDate><description><![CDATA[给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明:叶子节点是指没有子节点的节点。
示例：给定二叉树 [3,9,20,null,null,15,7]，返回最大深度为3。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val...]]></description><category></category></item><item><title><![CDATA[格雷码]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316261</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316261</guid><author>anda0242</author><pubDate>Thu, 22 Aug 2019 16:14:00 +0800</pubDate><description><![CDATA[格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。格雷编码序列必须以 0 开头。
示例 1:
输入:2输出:[0,1,3,2]解释:00 - 001 - 111 - 310 - 2
思路： 使用镜像翻转后的序列在最前边加0或者1。或者使用格雷码公式:G(i) = i^(i/2)。

cl...]]></description><category></category></item><item><title><![CDATA[存在重复元素]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316258</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316258</guid><author>anda0242</author><pubDate>Thu, 22 Aug 2019 11:54:00 +0800</pubDate><description><![CDATA[给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。
示例 1:
输入: [1,2,3,1]输出: true
思路： 一种是利用排序， 第二种使用hashset。这里只展示第二种用法。

class Solution {
public:
    bool containsDuplic...]]></description><category></category></item><item><title><![CDATA[子集]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316259</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316259</guid><author>anda0242</author><pubDate>Wed, 21 Aug 2019 16:54:00 +0800</pubDate><description><![CDATA[给定一组不含重复元素的整数数组nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
示例:
输入: nums = [1,2,3]输出:[  [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], []]

class Solution {
public:
    vector&lt;vector&lt...]]></description><category></category></item><item><title><![CDATA[爬楼梯]]></title><link>https://blog.youkuaiyun.com/anda0242/article/details/102316256</link><guid>https://blog.youkuaiyun.com/anda0242/article/details/102316256</guid><author>anda0242</author><pubDate>Wed, 21 Aug 2019 16:18:00 +0800</pubDate><description><![CDATA[假设你正在爬楼梯。需要 n阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2输出： 2解释： 有两种方法可以爬到楼顶。1.  1 阶 + 1 阶2.  2 阶
使用了简单动态规划。 第n阶的方法总数为上一级或者上上级两者方法之和。

class Solution {
publ...]]></description><category></category></item></channel></rss>