LeetCode

题目描述：统计一个数字在排序数组中出现的次数。例如输入排序数组{1,2,3,3,3,3,4,5}和数字3，由于3在这个数组中出现了4次，因此输出4。 i c } m l p a o s r s f } f } f } t u u u F n n n F o c c c o r v l l i } r v v i } l l i } } } r v v i } l l i } } } r u 3 f a e e f e g a a f e e f e e e g a a f e e f e e e n 8 i r t t t e r r t t l l t e r r t t l l t d S n f u t s m s s u t s m s s u a o d n f l i r r F s e t r m m i i } } e e e s r L s e t r m m i i } } e s e e r t l N i a s / e n i t n a e i i d f e n t n a t n a e i i d f e t n n i u u = s s r 没 t r a d r t d d N l i d { a s a d r t d d N l i a { d o t m r t t 找 u l s r t u N u m s f r g t r t u N u m s f r g n i s n t 到 r a t t = r = u m i r e e = t e K t = r = u m i r e s t = e o O u = = n s K > n m d e n m t ( > n m d e t m t n f m = = t ( = e ( = t { d i m = F _ = e ( = t { a i = m L K s g - _ n e - s = = = u d i i n e - s = = = u r d i a { ( g e - 1 - s d n 1 t = r = N d m r n s d n 1 t = r t N m d s _ e t 1 n t 1 d a n k n u i s u t 1 d a n k n u i t t L f u a r u 0 m m - d t m a r u e = m d - K n F a i m r { t m { m i K s r { t m { n m ( u i s s s t s i d > 1 + ( : t s d i m < + 1 & m r t r : 1 + [ d & 1 + [ d i n s s K l t m - k 1 n i m d k 1 u : t ( a i e i ( u n e i m K & s + n n d m 1 { m o n d + { s [ ( n t o d ] i s u d ] ( , I & , 1 u ) d , t ) m 1 n n = t i k t , k = / > k [ / d , ] , [ , I , k - I 2 0 n 2 < s _ , 0 1 n s t t , t & t ] e a k 0 { ] & a , n r : , n , r _ d t . _ n t , I n c u , k & n . o k m : & e t c u : s e n ) o n [ n I n d u t I m d n u ) n - n i ) t m t 1 t d , s - ) , _ [ I 1 _ - m n ) s i t s 1 t d t ] a + { a r 1 r ! t ] t = 1 1 : ! : k = ) I I n k n { t ) t , , _ { _ e e n n d d 1 1 : : I I n n t t ) ) I I n n t t { { 算法思想：如果不考虑数字会重复，那就错了。实际上就是topK的变种题，而且这个K要自己来求，实际解法是FirstK+LastK。 ...

题目描述：求数组中只出现一次的数字 i c } m l p a o s r s f } t u F n F o c o r v f } r u 4 a a o e n 0 p r r t d S p u a o e n i n r t l a n i u r = i ^ o t O n = n n i n n o c u 1 n n e m . u ( s . m { _ [ < s 0 n [ n ] u i u m ] m s s . : c o [ u I n n t t ] { ) I n t { 算法思想：这是假设数组中只出现一次的数字只有一个，那就直接异或，最后的这个数就是结果。 如果只出现一次的数字有两个呢？那就先异或，得出两个数的异或结果，然后从低位向高位找第一个为1的位。然后根据这一位为1和0把数组分成两组，然后两组数分别异或，就得出最后的结果了。因为异或，不同才为1。所以找不为1的那位，也就证明两个数在那一位肯定不同，所以能把两个数分到不同的数组。 ...

题目描述：求二叉树的深度。 i c } m l p a o s r s f } t u F n F o c o r i } r u 3 t f e n 9 r t d S e r u a o e o r r t l D o e n i u e t t o t p u m n i t = r a o h = n x n ( ( _ n 0 t { i r r l e o e o { D t e : p t T h r ( e r e o N o o t d ? e . ? l ) e f t ) , I n t t r e { e D e p t h ( r o o t ? . r i g h t ) ) + 1 算法思想：采用递归解法，每次+1，利用栈的特性。 ...

题目描述： 题目一：输入一个英文句子，翻转句子中单词的顺序，但单词内字啊的顺序不变。为简单起见，标点符号和普通字母一样处理。 题目二：字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。 i c } m l p a o s r s f } f } f } t / u / u u F 翻 n 左 n n F o 转 c 旋 c c o r 字 v r v w } r r 转 i } v r r r r v v w } u 4 符 r a / e / a a h e e 字 l f a / e / e / e e r a a h n 2 串 e r 第 v 第 r r i v t 符 e r 翻 v 翻 v 全 v t e r r i d S v 一 e 二 l e u 串 f n 转 e 转 e 部 e u v l a o e s 次 r 次 s e e i } e r r t r s 前 r 后 r 翻 r r e s e e l s s s e t l r t 整 s 单 t n f n s n R > e t 面 s 面 s 转 s n r t n e t t t n i u s r 体 e 个 a d e d e a o t r 一 e 一 e e s a d s t r r a d o t e s 翻 ( 翻 r n s ( S b t s u s 段 ( 段 ( ( S e r t s s r n i W 转 & 转 t = d t r e s + & t c a . r & & & t ( t = a t [ [ t - o o = s r e n t = s r d t c n = s s s r _ r e s e = n r t = 0 < s v d a t i e e o t t t i = e t m t n + d A r [ e r 1 r n f S u " A r r r n s n p a d = 1 { ( r s 0 s e r + t s g g t n " r s s s g t s d < r ] _ r , t n s = , ( - r t r , , , ( r t 1 = t 1 a r d e = s > i a s s a e ] = s y 0 s ] ( 1 s t c n y 0 n 0 t : r n s : ( , . & e t r d g ( , , , r t d t = t s c = s n a s e ( s s i 1 r e S ) s o = t d r ) f _ s ) n s s ) n { s s m t . u r t g - t t o [ t p r c n " s , a s = 1 r r u s r i o t , b : = ) s s t t s n u " e . . a [ g n { s n S " c c [ r e ) t { t d 从 t " o o C t n - a - 第 r u u h ] d 1 r 1 N i { n n a ] ) t ) 个 n t t r , 开 g - - a S 始 , 1 1 c t e _ ) ) t r n e i d n r n - : ] g 1 , ) I _ { n t s ) t a r t 1 S : t r I i n n t g , _ { e n d 1 : I n t ) { 算法思想： 题目一：第一次整体翻转，第二次单个翻转。 题目二：第一次翻转前面一段，第二次翻转后面一段，然后全部翻转。 ...

题目描述：求二叉树的深度。 i c } m l p a o s r s f } t u F n F o c o r i } r u 3 t f e n 9 r t d S e r u a o e o r r t l D o e n i u e t t o t p u m n i t = r a o h = n x n ( ( _ n 0 t { i r r l e o e o { D t e : p t T h r ( e r e o N o o t d ? e . ? l ) e f t ) , I n t t r e { e D e p t h ( r o o t ? . r i g h t ) ) + 1 算法思想：递归求，每次+1，利用栈的特性。 ...

题目描述： 题目一：输入一个递增排序的数组和一个数字 s，在数组中查找两个数，得它们的和正好是 s。如果有多对数字的和等于 s，输出任意一对即可。 题目二：输入一个正数 s，打印出所有和为 s 的连续正数序列（至少两个数）。 i c } m l p a o s r s f } f } f } t u u u F n n n F o c c c o r v v w } p i } v v l v w } p f } p u 4 s a a h r s f a a e a / h r f o r n 1 u r r i i u r r t r 最 i i o r i d S m l n m k 少 l n r n a o I l r e i } } } t s r s b m s 要 e i } w } s s t K i p t t l s e i f e e ( I < e m i i u 2 f h u m ( P r ( i u K f g l l " s t a g d m 个 s i m a " r i i " o t ( t h l n s s n K 3 u l s 数 m s l s l i i n n o n i _ t e u p r e r e l o S r l = = a u f e b s i } l s n t n o = f m r e i e q { n = l m o i u f - t s ( c n n = t s i t i g { f r e = 2 ( l s r s g m = + a ( m i e u 0 [ n u f h t e u 1 s K m s s = l _ a ) ! { m n < r t r t s e 1 m < = P a + u f s l l " s u i ( n n + u n + a = r l = + m o m 1 ! s l ) : m r g " u - = l c l m i l = s r a " m . s i h \ m = t e k l i k n 1 K l ) a . [ . g t ( s 1 ! ( ) d t < b = P l l < I c h ] n [ 1 " _ / + { ( i = r l b n o t u r ) 2 { s m g i : i t u + m i k b m i k n g ] n { s g : i a d t I + , t n [ h g l { ( n 1 _ u r t I l & s t - m i ] n , & m , { k s g t a _ : 1 [ h + ) b s l l t i u l b I e ] n { g m , i n f ) u ) s g t t + m b : ) ] \ s < i ( [ g I { = n l k ) n = u e t m f { ) k s t [ ] { { l e > f t k ] ) { = \ ( k ) " ) 算法思想： 题目一：我们先在数组中选择两个数字，如果它们的和等于输入的 s，我们就找到了要找的两个数字。如果和小于 s 呢？我们希望两个数字的和再大一点。由于数组已经排好序了，我们可以考虑选择较小的数字后面的数字。因为排在后面的数字要大一些，那么两个数字的和也要大一些， 就有可能等于输入的数字 s 了。同样， 当两个数字的和大于输入的数字的时候，我们可以选择较大数字前面的数字，因为排在数组前面的数字要小一些。 题目二：考虑用两个数 small 和 big 分别表示序列的最小值和最大值。首先把 small 初始化为 1，big 初始化为 2。如果从 small 到 big 的序列的和大于 s，我们可以从序列中去掉较小的值，也就是增大 small 的值。如果从 small 到 big 的序列的和小于 s，我们可以增大 big，让这个序列包含更多的数字。因为这个序列至少要有两个数字，我们一直增加 small 到(1+s)/2 为止。 ...

题目描述：输入两个链表，找出它们的第一个公共结点。 i c } m l p a o s r s f } t u F n F o c o r v v v v w } w } v v v i } } w } r u 3 f a a a a h h a a a f e h / e n 7 i r r r r i i r r r l i 没 t d S n l l l s l 有 u a o d p q p q e p p e q q p q l e w } e l w } e i } p q 公 r t l F H H L L H L H L H H e n h e h f H H 共 n i u i e e e e p e e q e e e e n i { n i p e e 结 o t r a a n n H a n H a n a a > l l H p a a 点 L n i s d d e d e d d d = e p l = e q l e H r d d i o t = = a + a + 1 2 0 H e H e a e e 1 2 s n C = = d = = d = = p l e n - l e n d a t t o 0 0 ? ? = = L { e a l e a 1 d u = = N { m h h . p 1 . q 1 e n d - e n d - ? 1 r o m e e n H n H h h n 1 = n 2 = . n p q d o a a e e e e e e > > n = H H e n d d x a x a a a - = = 1 = = 1 e = p e e ( N 1 2 t d t d d d x = H a a 0 o ? ? 1 2 q 0 p 0 q t e d d ) d ! . ! . L H H q a 1 2 e = n = n e { e { e ! H d ? ? ( e e n a a = e 1 . . _ n x n x d d a ! n n i t i t 1 2 n d e e h l l ? ? i 2 x x e . . l t t a { { n n { d e e & 1 x x & : t t q L H i e s a t d N 2 o ? d . e n ? e , x _ t h ! e = a d n 2 i : l L { i s t N o d e ? ) L i s t N o d e { 算法思想：先算出两个链表的长度，假如差为K，长的链表先走K步，然后两个指针一起走，如果相遇就是第一个公共节点。如果没有相遇就没有公共节点。 ...

题目描述：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007 输入描述: 题目保证输入的数组中没有的相同的数字 i c } m l p a o s r s f } f } t u u F n n F o c c o r v r i } v l l l v v v v w } w } w } i w } r u 3 i a e p f a e e e a a a a h h h n h e n 6 n r t r r t t t r r r r i i i d i t d S v u o s l l l e l u a o e n r c t r c m l r p q i c e i } } e c i p e c i q x e n i r t l r n e a e o i e i n o f e o n o n u n n i u s = s r t p d f g = = d u p l p p d - q p d - = i m d o t e p s t u y t h e n n s y e = y e = n s e l n i P n r ( r = t m e x t > u c c i p e c i q > [ x > [ x s d [ x e o a u o _ > n = = i n = m o o n o n = i 1 = i 1 t e i f n i m c = ( = d d = = s p u d - { p d - n - n - a x n + t r s e n 0 A s p s [ y n e = y e = s d = m d = r d = { s s u e r t r p e 0 t p [ t x [ x t e i e t < e + ( s m n r a o r / n a ] i 1 i 1 a x 1 d x 1 = x 1 _ ( s d a r c o 前 后 d r n + - n - r ] ] ] r & : y t e c 半 半 t > d = = d = t + e i n n { ( s e 段 段 e e = = n = g u , i n + s s 最 最 / & n x q 1 x 1 { 1 d h m n u ( s 后 后 辅 & u ] ] n n c t s 0 o m e & ( 一 一 助 m - u { u { o : , u s n n & 个 个 数 q s = = m m p + t ) d u n 组 [ m s s y [ n ) m u 从 > q n i n [ [ [ c I . [ s m 最 = ] u d u p q i o n c I / , s 后 m m ] ] n u t o n , 一 m { s s d n ] u t 2 s 位 i [ [ e t ) n ] t m 开 d p q x t , a i 始 + ] ] ] _ r d 1 - t + s , 1 { I 1 t , n ) a m t r i e t d n { : ) d ) I n t , _ e n d : I n t ) I n t { 算法思想：很容易想到的方法就是遍历每一个元素，让其与后面的元素对比，如果大于则count++，但是这样的时间复杂度是O(n2)，因此，我们可以用归并排序思路。 ...

题目描述：在字符串中找出第一个只出现一次的字符。如输入“abaccdeff”，则输出‘b’。 i c } m l p a o s r s f } t u F n F o c o r v v l f } f } r u 3 o a a e o o e n 5 n r r t r r t d S l u a o y k h s s i } } s i } r t l O e a t t f e t f n i u n y s r r l r o t e S h i h s h C n i F o M n i a h e k h i a r h o i r a g n s a e a n s e a n n t p s h s { y s h t r d s s M h S h k M u a { ( = = t a M o M e a r c _ = r p a r a y p n t [ A i . p t p S [ e s [ C r n k . s . o s s r : C h r g e u . u r t t ( h a a s y p a p t r r " S a r y s d p d s ] " t r a ( { . a p a ) r a c s c t e t { = i c t ) o e n e = n t e n V d V g e r t a ( a 1 ) r a l s l ] : i u t u { ( n e r e ) I s ( ) ( n ( h 1 C t s a , h ] t s a ( r h f r ) ) M o a a r c { p K t [ e e s y r t : r { ] s ! t r + ) 1 , f o r K e y : s t r ) 算法思想：用hashmap存，然后按顺序遍历一次，第一个等于1的就是结果。 ...

题目描述：把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。 i c } m l p a o s r s f } f } t u u F n n F o c c o r i } v u v v v v w } r i } v w } w } w } r u 3 k f a g a a a a h e i f a h h h e n 4 U r l r r r r i t s r i i i t d S g k y l u U n l l l u a o l r u N u u u c e l u w } w } w } c r g r n e n e n e n r t l y < e g u g g g u e g h h h u n l = e u u u u n i u N = t l m l l l r c t l i i i r y = t m n m n m n m o t u u y s y y y r u y l l l r u ( u u u u n n i m 0 r N . 2 3 5 e r m N e u e u e u e g _ 0 r = m / m / m / u o ( n u a n r i u g g g n l n % = % = % = m n _ { m p = = = t e n m u l u l u l t y n { n 2 3 5 0 s p n U s g y g y g y N : f 2 3 5 = { k e 0 0 0 = t g . l 2 l 3 l 5 + u a = = = = : = n l a y y y = m I l = = = d 1 < y p N + N + N + s n s 1 I [ ( p u = u = u = 1 [ t e 0 0 0 n I 1 k = e m m m c ) t n ) n s 1 s 1 s 1 u { { { ) t { m d [ [ [ r ] i ( u u u r ( n m g g g e ) ( i l l l n B u n y y y t o I g U 2 3 5 o n l g ] ] ] - l t y l * * * N y 2 3 5 1 { { u ) ] m < < < s = = = [ u m m m g i i i l n n n y U U U 2 g g g ] l l l * y y y 2 , { { { u g l y N u m s [ u g l y 3 ] * 3 , u g l y N u m s [ u g l y 5 ] * 5 ) 算法思想：最简单的方法就是先通过将一个数不断除以2，3，5来判定该数是不是丑数，而后在从1开始，依次往后判断每个数是不是丑数，并记下丑数的个数，这样当计算的个数为给定值时，便是需要求的第n个丑数，这种方法的时间复杂度为O（k），这里的k为第n个丑数的大小，比如第1500个丑数的大小为859963392，那么就需要判断859963392次，时间效率非常低。 直观的优化措施就是看能不能将时间复杂度降低到O（n），即只在丑数上花时间，而不在非丑数上浪费时间。剑指offer上给的思路很好，用O（n）的辅助空间来得到O(n)的时间复杂度。其核心思想是：每一个丑数必然是由之前的某个丑数与2，3或5的乘积得到的，这样下一个丑数就用之前的丑数分别乘以2，3，5，找出这三这种最小的并且大于当前最大丑数的值，即为下一个要求的丑数。 ...