算法 on 不会跑

转换BST为一个双向链表

Sun, 17 Sep 2017 10:01:47 +0000

经典二叉树题：转换一个二叉树为一个双向链表；

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Convert(self, pRootOfTree):
        root = pRootOfTree
        if not root:
            return root
        stack, node, head = [root], root.left, None
        while stack or node:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop(-1)
            node.left = head
            # 判断是否为第一个节点
            if head:
                head.right = node
            head = node
            node = node.right
        return head

稳定婚姻匹配问题

Sat, 26 Aug 2017 16:06:53 +0000

什么是稳定婚姻匹配问题

稳定婚姻问题（Stable Marriage Problem）是一个经典的算法问题，最早由 David Gale 和 Lloyd Shapley 在 1962 年提出。问题描述如下：

给定 N 个男性和 N 个女性，每个人都对所有异性有一个偏好排序列表。需要找到一种稳定的匹配方案，使得不存在这样的情况：男性 A 和女性 B 没有配对，但他们都更喜欢对方而不是各自当前的伴侣。如果存在这样的一对，就称之为"不稳定对"（blocking pair），整个匹配就是不稳定的。

倒水问题-经典面试题

Sat, 26 Aug 2017 15:56:21 +0000

有两个容器，容积分别为A升和B升，有无限多的水，现在需要C升水, 如何倒？

举个例子，3，5升的桶，需要倒出4升水，可以这么做：

3 % 5 = 3  //把3升水倒入5升桶
6 % 5 = 1 //把第二个3升的水倒入5升桶，最后剩下1升的也放入5升桶
9 % 5 = 4 //把第三个3升水倒入5升桶，得到4升

扩展的欧几里德算法，算法描述：

LeetCode-Unique_Binary_Search_Trees

Sat, 15 Jul 2017 01:13:02 +0000

题目的意思就是给你1到n个数，你能组成多少种BST，解题思路就是：以每一个数做一次BST的root节点，然后求和所有次数即可，然后每次以i为root时，左子树有i-1个点，右子树有n-i各点，得到递推式：dp[i] += dp[j-1] * dp[i-j]，最后求和即可，原题链接：https://leetcode.com/problems/unique-binary-search-trees/

LeetCode-LFU_Cache

Sun, 02 Jul 2017 14:30:22 +0000

LeetCode的设计题，比起之前的LRU稍微难点，但是根据《现代操作系统》的解释，需要使用一个counter进行频率的计数，下面给出的并不是O(1)，但是基本思路是对的；原题链接：https://leetcode.com/problems/lfu-cache/

LeetCode-Find_Median_from_Data_Stream

Sat, 01 Jul 2017 04:42:14 +0000

LeetCode的一道设计题，快速找到已添加的数据的中位数，下面给出的方法添加的时间复杂度为max(n/2, logn), 查找的时间复杂度为O(1), 之后会给出添加时间复杂度为O(logn)查找O(1)的解法，其实就是维护两个堆（一个大根堆一个小根堆）；原题链接：https://leetcode.com/problems/find-median-from-data-stream/

LeetCode-Binary_Search_Tree_Iterator

Fri, 30 Jun 2017 17:05:57 +0000

一个比较有意思的设计题，需要你设计一个BST的迭代器，不断返回最小值，其实就是中序遍历的过程，然后就是怎么把中序遍历过程用类实现，我给出了两者做法，前一种比较容易实现无需考虑太多，后一种由于加入了hash表所以考虑多一点；原题链接：https://leetcode.com/problems/binary-search-tree-iterator/

LeetCode-Design_Twitter

Thu, 29 Jun 2017 07:36:15 +0000

经典的设计题，以前校招笔试遇到过，题意就是：让你设计一个小的推特系统，能够发推、收到推送、关注和取消关注某人，我的做法是直接采用一个数据表（字典），然后写的比较复杂，但是逻辑还算清晰，大量的检查异常情况，多次提交后AC；原题链接：https://leetcode.com/problems/design-twitter/

LeetCode-Min_Stack

Thu, 29 Jun 2017 03:08:00 +0000

经典的stack相关的设计题，实现一个栈要求能够O(1)时间获取当前栈中最小元素，基本思路是：一个数据栈，另一个栈用栈顶存最小元素，如果弹栈弹得是最小元素，那么最小元素栈也弹栈。原题链接：https://leetcode.com/problems/min-stack/

LeetCode-Reorder_List

Thu, 29 Jun 2017 02:40:50 +0000

经典的链表题，考查了反转链表和一些细节，题意也很明白，把L0→L1→…→Ln-1→Ln变为L0→Ln→L1→Ln-1→L2→Ln-2→…即可，原题链接：https://leetcode.com/problems/reorder-list/

LeetCode-Partition_List

Wed, 28 Jun 2017 17:08:33 +0000

晚上送妹子回家后做了这个链表的题，怕自己忘了睡前总结下。

题目的意思就是：给定一个链表和一个数，把小于这个数的节点放前边，此外的都移到后边，而且保证两部分的节点原有顺序不变；在自己憋了一个来小时后终于AC了，后来对比其他人的提交结果，发现基本都是分成两个链表然后拼接，而我是在原有链表的基础上修改，虽然麻烦点，但也可以实现；对比自己之前对链表的操作，现在已经熟练多了。原题链接：https://leetcode.com/problems/partition-list/

LeetCode-Linked_List_Cycle_II

Wed, 28 Jun 2017 09:55:00 +0000

判断链表是否存在循环的变形题，需要你找出链表循环的开始节点，解题思路：先用快慢指针便利链表知道快慢指针指向同一个节点，然后让快指针从head重新开始走，这次每个指针一次只走一步，再一次指向相同节电的第一个就是要找的节点；

LeetCode-Linked_List_Cycle

Wed, 28 Jun 2017 09:30:13 +0000

经典的链表题，判断一个链表是否存在循环，而且不许使用额外的空间，解题思路：只要分别设定一个快慢指针，当快慢指针重合时就证明有循环，原题链接：https://leetcode.com/problems/linked-list-cycle/

LeetCode-Copy_List_with_Random_Pointer

Wed, 28 Jun 2017 08:31:03 +0000

一个比较经典的链表操作题，深度复制一个链表，链表包含一个next指针和一个random的指针，目前比较多的方法是hash表和自我复制法（在自己后面加一个自己），我写的是第二种方法需要注意的细节比较多，后面加了别人的hash表方法，原题链接：https://leetcode.com/problems/copy-list-with-random-pointer/

LeetCode-Remove_Nth_Node_From_End_of_List

Wed, 28 Jun 2017 08:18:03 +0000

比较简单的一个题，意思就是删除链表中倒数第几个节点，需要最后考虑下删除的是否恰巧为头节点，原题链接：https://leetcode.com/problems/remove-nth-node-from-end-of-list/

Given a linked list, remove the nth node from the end of list and return its head.

For example,

Given linked list: 1->2->3->4->5, and n = 2.

LeetCode-Longest_Increasing_Subsequence

Fri, 23 Jun 2017 10:03:46 +0000

经典的dp题目：最长增长子序列，都是dp的方法但是时间复杂度分别为O(N^2)、O(NlogN);原题链接：https://leetcode.com/problems/longest-increasing-subsequence/

Given an unsorted array of integers, find the length of longest increasing subsequence.

For example,

Given [10, 9, 2, 5, 3, 7, 101, 18],

LeetCode-Edit_Distance

Thu, 22 Jun 2017 14:52:57 +0000

比较特殊的动态规划过程，原题链接：https://leetcode.com/problems/edit-distance/

Given two words word1 and word2, find the minimum number of steps

required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

a) Insert a character

b) Delete a character

c) Replace a character

# _*_ coding: utf-8 _*_


class Solution(object):
    def minDistance1(self, word1, word2):
        """
        :type word1: str
        :type word2: str
        :rtype: int
        "A B G C _ F"
        "_ B _ D E _"
        """
        n = len(word1)
        m = len(word2)
        if not m or not n:
            return m or n
        dp = [[0] * (n+1) for i in xrange(m+1)]
        for i in xrange(m+1):
            dp[i][0] = i
        for j in xrange(n+1):
            dp[0][j] = j
        for i in xrange(m):
            for j in xrange(n):
                if word1[j] != word2[i]:
                    temp = 1
                else:
                    temp = 0
                dp[i+1][j+1] = min(dp[i][j+1]+1, dp[i+1][j]+1, dp[i][j]+temp)
        return dp[m][n]

    def minDistance(self, word1, word2):
        """
        :type word1: str
        :type word2: str
        :rtype: int
        减少了空间复杂度，时间复杂度依然为O(m*n)
        """
        n = len(word1)
        m = len(word2)
        if not m or not n:
            return m or n
        dp1, dp2 = [0] * (m+1), [i for i in xrange(m+1)]
        for i in xrange(n):
            dp1, dp2 = dp2, [i+1] * (m+1)
            for j in xrange(m):
                if word1[i] != word2[j]:
                    diff = 1
                else:
                    diff = 0
                dp2[j+1] = min(dp1[j]+diff, dp1[j+1]+1, dp2[j]+1)
        return dp2[m]

虽然这两种用法我都已经解出，但是回忆起又一次在线笔试题，计算编辑的成本我就细思极恐，比如插入一个字符消耗1个能量，删除一个字符消耗2个能量，替换一个字符消耗3个能量，给定两个字符串求最少的编辑能耗…待我想出来了再给出解题代码，知道解法的大神也请联系我，已跪！

LeetCode-Delect_Operation_for_Two_Strings

Thu, 22 Jun 2017 12:26:12 +0000

LCS的变形题目, 只要求出两个字符串的最长公共子序列，那么最终需要进行删除操作的就是m＋n－2*result。

Given two words word1 and word2, find the minimum number of steps required

to make word1 and word2 the same, where in each step you can delete one character in either string.

LeetCode-Best_Time_to_Buy_and_Sell_Stock

Thu, 22 Jun 2017 04:21:50 +0000

动态规划的小题目，买卖股票，原题链接：https://leetcode.com/problems/best-time-to-buy-and-sell-stock/

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock),

design an algorithm to find the maximum profit.

LeetCode-minimum_path_sum

Thu, 22 Jun 2017 03:27:52 +0000

经典的动态规划题，三种解法都是动态规划，但是最后一种空间复杂度最小，原题链接：

https://leetcode.com/problems/minimum-path-sum/

Given a m x n grid filled with non-negative numbers,

find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

LeetCode-Longest_Consecutive_Sequence

Wed, 21 Jun 2017 09:46:10 +0000

题目的意思就是求出列表里最长的连续序列, 原题如下：

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

For example,

Given [100, 4, 200, 1, 3, 2],

The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.

Your algorithm should run in O(n) complexity.

下面采用了三种不同的方法进行求解，分别是排序统计、并查集、集合，最后一种为最优解也是最巧妙的

LeetCode-Remove_Duplicates_from_Sorted_Array

Tue, 20 Jun 2017 05:13:19 +0000

题目比较简单，就是需要你找出数组里面不同数字的个数，但是也要求把这些项搬运到nums数组的前面去

Given a sorted array, remove the duplicates in place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this in place with constant memory.

LeetCode-power_of_three

Mon, 19 Jun 2017 07:50:03 +0000

Given an integer, write a function to determine if it is a power of three.

Follow up:

Could you do it without using any loop / recursion?

# _*_ coding: utf-8 _*_

class Solution(object):
    def isPowerOfThree(self, n):
        """
        :type n: int
        :rtype: bool
        """
        import math
        if n &lt; 1:
            return False
        # 四舍五入, 因为最后的取对数会有少许误差
        return 3 ** round(math.log(n, 3)) == n

    def isPowerOfThree1(self, n):
        """
        :type n: int
        :rtype: bool
        思路是在看了别人的解析后得出:
            直接在32位的有符号整型号里，找到最大的3的幂数，然后用n对它进行取余即可
            In [178]: math.log(1162261467, 2)
            Out[178]: 30.11428751370197

            In [180]: math.log(1162261467 * 3, 2)
            Out[180]: 31.699250014423125
            32位最大3的幂数是1162261467
        """

        return n &gt; 0 and 1162261467 % n == 0

复杂度分析：

LeetCode-clone_graph

Sat, 10 Jun 2017 14:03:15 +0000

克隆一个图，用了两个遍历方法如下：

Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.

OJ’s undirected graph serialization:

Nodes are labeled uniquely.

We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.

As an example, consider the serialized graph {0,1,2#1,2#2,2}.

LeetCode-binary-tree-level-order-traversal

Wed, 07 Jun 2017 07:30:11 +0000

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:

Given binary tree [3,9,20,null,null,15,7],

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

# _*_ coding: utf-8 _*_


class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        n_last = last = root
        _queue = [root]
        result, temp = [], []
        while _queue:
            node = _queue.pop(0)
            temp.append(node.val)
            if node.left:
                _queue.append(node.left)
                n_last = node.left
            if node.right:
                _queue.append(node.right)
                n_last = node.right
            if node == last:
                result.append(temp)
                last = n_last
                temp = []
        return result

    def levelOrder1(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res, level = [], [root]
        while root and level:
            # 先倒出所有不为空的叶子
            res.append([n.val for n in level if n])
            # 用之前的叶子找到下一层不为空的叶子
            level = [kid for n in level for kid in (n.left, n.right) if kid]
        return res

复杂度分析：

LeetCode-Lowest_Common_Ancestor_of_a_Binary_Search_Tree

Tue, 06 Jun 2017 09:15:08 +0000

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

        _______6______
       /              \
    ___2__          ___8__
   /      \        /      \
   0      _4       7       9
         /  \
         3   5

For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

LeetCode-Serialize and Deserialize BST

Tue, 06 Jun 2017 08:09:10 +0000

序列化和反序列化一个二叉搜索树，题目的意思是想让我利用搜索树的性质来做，但是我还是坚持了使用按层和先序遍历的方法，仅供参考，原题如下：

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

LeetCode-delete_a_node_in_BST

Tue, 06 Jun 2017 03:48:12 +0000

Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.

Basically, the deletion can be divided into two stages:

Search for a node to remove.

If the node is found, delete the node.

Note: Time complexity should be O(height of tree).

也就是必须在树上爬着解决问题，不允许先遍历剔除再重新建树，下面是我写的第一个版本，用的迭代方法；

LeetCode-Top_K_Frequent_Elements

Sun, 04 Jun 2017 17:29:09 +0000

Given a non-empty array of integers, return the k most frequent elements.

For example,

Given [1,1,1,2,2,3] and k = 2, return [1,2].

Note:

You may assume k is always valid, 1 ≤ k ≤ number of unique elements.

Your algorithm’s time complexity must be better than O(n log n), where n is the array’s size.

LeetCode–brick_wall

Sat, 03 Jun 2017 04:59:20 +0000

比较有意思的题，求最少穿过的砖的块数，原题连接：https://leetcode.com/problems/brick-wall/

There is a brick wall in front of you. The wall is rectangular and has several rows of bricks.

The bricks have the same height but different width.

You want to draw a vertical line from the top to the bottom and cross the least bricks.

LeetCode–longest_substring_without_repeating_char

Sat, 03 Jun 2017 03:46:40 +0000

这是一个面试的经典题，明显是个送分题：）

Given a string, find the length of the longest substring without repeating characters.

Examples:

Given “abcabcbb”, the answer is “abc”, which the length is 3.

Given “bbbbb”, the answer is “b”, with the length of 1.

LeetCode–Convert_Sorted_List_to_Binary_Search_Tree

Fri, 02 Jun 2017 04:13:46 +0000

Given a singly linked list where elements are sorted in ascending order,

convert it to a height balanced BST.

# _*_ coding: utf-8 _*_


class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None


class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution(object):
    def sortedListToBST(self, head):
        """
        :type head: ListNode
        :rtype: TreeNode
        每次找到中位数，然后递归
        """
        if not head or not head.next:
            return TreeNode(head.val) if head else head
        
        slow, fast, pre = head, head, None
        while fast and fast.next:
            pre, slow, fast = slow, slow.next, fast.next.next
        # 截断链表
        pre.next = None
        root = TreeNode(slow.val)
        # 递归查找中间位置的节点
        root.left, root.right = map(self.sortedListToBST, [head, slow.next])
        
        return root

复杂度分析：

LeetCode–Remove_Duplicates_from_Sorted_List_II

Thu, 01 Jun 2017 15:37:25 +0000

Given a sorted linked list, delete all nodes that have duplicate numbers,

leaving only distinct numbers from the original list.

For example,

Given 1->2->3->3->4->4->5, return 1->2->5.

Given 1->1->1->2->3, return 2->3.

# _*_ coding: utf-8 _*_

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head or not head.next:
            return head
        
        dummy = ListNode(None)
        node, dummy.next, last_uniq = head, head, dummy
        last_val = None
        while node:
            # 先找出一串相等值
            while node and last_val == node.val:
                node = node.next
            # 假如是最后一个值，那么直接break
            if not node or not node.next:
                last_uniq.next = node
                break
            # 更新最后的值
            last_val = node.val
            # 重新判断更新last_val后当前节点和下一个节点
            if node.val != node.next.val:
                last_uniq.next = node
                last_uniq = last_uniq.next
                node = node.next
        return dummy.next

自己的提交虽然全部通过测试用例，但是leetcode评分为1.46％，感觉太差劲于是找到一个更好的简单的解法，贴在下面

LeetCode–reverse_linked_list_II

Thu, 01 Jun 2017 12:50:11 +0000

Reverse a linked list from position m to n. Do it in-place and in one-pass.

For example:

Given 1->2->3->4->5->NULL, m = 2 and n = 4,

return 1->4->3->2->5->NULL.

Note:

Given m, n satisfy the following condition:

1 ≤ m ≤ n ≤ length of list.

# _*_ coding: utf-8 _*_


class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution(object):
    def reverseBetween(self, head, m, n):
        """
        :type head: ListNode
        :type m: int
        :type n: int
        :rtype: ListNode
        """
        if not head or not head.next:
            return head

        diff, dummy, cur = n - m + 1, ListNode(None), head
        dummy.next = head
        # 最后未交换的节点
        last_unswapped = dummy
        while cur and m &gt; 1:
            cur, last_unswapped, m = cur.next, cur, m - 1
        
        prev, first_swapped = last_unswapped,  cur
        while cur and diff &gt; 0:
            cur.next, prev, cur, diff = prev, cur, cur.next, diff - 1
        # 最后调转车头    
        last_unswapped.next, first_swapped.next = prev, cur
        
        return dummy.next

复杂度分析：

LeetCode–Remove-Linked-List-Elements

Sun, 28 May 2017 17:26:57 +0000

Remove all elements from a linked list of integers that have value val.

Example

Given: 1 –> 2 –> 6 –> 3 –> 4 –> 5 –> 6, val = 6

Return: 1 –> 2 –> 3 –> 4 –> 5

LeetCode–Palindrome-Linked-List

Sun, 28 May 2017 15:41:00 +0000

Given a singly linked list, determine if it is a palindrome.

Follow up:

Could you do it in O(n) time and O(1) space?

# _*_ coding: utf-8 _*_


class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if not head or not head.next:
            return True
        if not head.next.next:
            if head.val == head.next.val:
                return True
            else:
                return False
        slow = head
        fast = head.next
        pre_node = None
        while fast and fast.next:
            fast = fast.next.next
            # 反转链表
            temp = slow.next
            slow.next = pre_node
            pre_node = slow
            slow = temp
            
        # 节点个数为偶数
        if fast:
            l2 = slow.next
            slow.next = pre_node
            l1 = slow
        else:
            l1 = pre_node
            l2 = slow.next
        
        while l1:
            if l1.val != l2.val:
                return False
            l1, l2 = l1.next, l2.next
        return True

复杂度分析：

LeetCode–odd-even-linked-list

Sun, 28 May 2017 11:43:15 +0000

最近主要练习链表的变换，这个题很经典，特别是容易忽略末尾出现的闭环

Given a singly linked list, group all odd nodes together followed by the even nodes.

Please note here we are talking about the node number and not the value in the nodes.

You should try to do it in place. The program should run in O(1) space complexity and O(nodes) time complexity.

LeetCode–reverse-nodes-in-k-group

Sun, 28 May 2017 06:03:17 +0000

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

k is a positive integer and is less than or equal to the length of the linked list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

LeetCode–MergeKList

Mon, 22 May 2017 13:57:33 +0000

# _*_ coding: utf-8 _*_

'''
Merge k sorted linked lists and return it as one sorted list.
Analyze and describe its complexity.
'''


class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        采用并归的思想
        """
        # 过滤空链表
        _list = filter(lambda node: node, lists)
        return self.merge_help(_list)
        
    def merge_help(self, _list):
        n = len(_list)
        if n == 0:
            return None
        elif n == 1:
            return _list[0]
        elif n == 2:
            return self.merge(_list[0], _list[1])
        else:
            mid = n / 2
        
        return self.merge(self.merge_help(_list[:mid]), self.merge_help(_list[mid:]))

    def merge(self, l1, l2):
        if not (l1 and l2):
            return l1 or l2
            
        pre_head = ListNode(None)
        # 确定头节点
        pre_head.next = l1 if l1.val &lt;= l2.val else l2
        node = ListNode(None)
        while l1 and l2:
            if l1.val &lt;= l2.val:
                node.next = l1
                l1 = l1.next
            else:
                node.next = l2
                l2 = l2.next
            node = node.next
        node.next = l1 or l2
        return pre_head.next

复杂度分析：

LeetCode–链表排序O(nlogn)

Sun, 21 May 2017 05:36:41 +0000

# _*_ coding: utf-8 _*_

'''
Sort a linked list in O(n log n) time using constant space complexity.
'''


class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution(object):
    """
    :type head: ListNode
    :rtype: ListNode
    """
    def merge(self, h1, h2):
        '''
        dummy = tail = ListNode(None)
        while h1 and h2:
            if h1.val &lt; h2.val:
                tail.next, tail, h1 = h1, h1, h1.next
            else:
                tail.next, tail, h2 = h2, h2, h2.next

        tail.next = h1 or h2
        return dummy.next
        '''
        # 先申请出头节点的前节点，以及尾节点
        pre_head = tail = ListNode(None)
        # 选举头节点, pre_head.next就是head的意思
        if h1 and h2:
            if h1.val &lt; h2.val:
                pre_head.next = h1
            else:
                pre_head.next = h2
        # 假设一个节点其实为空，那么pre_head.next就是不为空的节点
        else:
            pre_head.next = h1 or h2

        while h1 and h2:
            # 首先把尾节点的next指到比较下更小的节点，
            # 然后往前移动尾节点更新tail，然后往前移动更新h1/h2
            if h1.val &lt; h2.val:
                tail.next = h1
                tail = h1
                h1 = h1.next
            else:
                tail.next = h2
                tail = h2
                h2 = h2.next

        # 选择尚不为空的链作为尾巴的下一个指向, 其实就是串接
        tail.next = h1 or h2
        # 返回头节点
        return pre_head.next

    def sortList(self, head):
        # 空链表或者单节点链表
        if not head or not head.next:
            return head

        pre, slow, fast = None, head, head
        while fast and fast.next:
            # fast的步长为2，pre／slow的步长为1，pre紧挨着slow，
            # 最终状态为：fast为末尾节点或者为空, slow为中间节点
            # slow把链表拆为近似均等两半，并归排序
            pre, slow, fast = slow, slow.next, fast.next.next
        # pre为slow前一个节点，指向空节点就是拆分链表,
        # pre为第一段的尾节点，fast为后一段的尾节点(链表长度为2*n+1)或者为尾节点后一个(链表长度为2*n)
        pre.next = None

        # 合并以head和slow(中间节点)作为头节点的链表
        return self.merge(self.sortList(head), self.sortList(slow))

复杂度分析：

LeetCode–统计更小值数量

Fri, 19 May 2017 08:45:55 +0000

Time: O(nlogn)

Space: O(n)

You are given an integer array nums and you have to

return a new counts array. The counts array has the

property where counts[i] is the number of smaller

elements to the right of nums[i].

Example:

Given nums = [5, 2, 6, 1]

To the right of 5 there are 2 smaller elements (2 and 1).

To the right of 2 there is only 1 smaller element (1).

LeetCode－－实现字典树

Thu, 18 May 2017 13:34:59 +0000

class TrieNode(object):
    def __init__(self):
        self.is_word = False
        # 某个节点是否为单词，一般默认为path（路径）
        # 当有单词录入时，变为True
        self.leaves = {}

class Trie(object):

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.root = TrieNode()

    def insert(self, word):
        """
        Inserts a word into the trie.
        :type word: str
        :rtype: void
        """
        _cur = self.root
        for c in word:
            # 如果字母不存在于此节点的叶子里，就生成一个新节点
            if c not in _cur.leaves:
                _cur.leaves[c] = TrieNode()
            _cur = _cur.leaves[c]
            
        _cur.is_word = True
        
            def search(self, word):
        """
        Returns if the word is in the trie.
        :type word: str
        :rtype: bool
        """
        
        _cur = self.root
        for c in word:
            if c not in _cur.leaves:
                return False
            _cur = _cur.leaves[c]
        return True if _cur.is_word else False
        '''
        def _search(word, index, _cur):
            if len(word) == index:
                return _cur.is_word
            if word[index] in _cur.leaves:
                return _search(word, index+1, _cur.leaves[word[index]])
                
            return False
            
        return _search(word, 0, self.root)
        '''
        

    def startsWith(self, prefix):
        """
        Returns if there is any word in the trie that starts with the given prefix.
        :type prefix: str
        :rtype: bool
        """
        '''
        def _search(word, index, _cur):
            if len(word) == index:
                return True
            if word[index] in _cur.leaves:
                return _search(word, index+1, _cur.leaves[word[index]])
                
            return False
            
        return _search(prefix, 0, self.root)
        '''
        _cur = self.root
        for c in prefix:
            if c not in _cur.leaves:
                return False
            _cur = _cur.leaves[c]
        return True


# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

但是LeetCode的评分是73％ 400ms，回头看看应该是节点类的抽象开销导致，于是改的简单点直接用字典实现：

算法－－按层打印二叉树

Thu, 18 May 2017 11:54:27 +0000

# _*_ coding: utf-8 _*_

# 按层打印二叉树


class TreeNode(object):
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None


class PrintTree(object):
    def printTree(self, root):
        if not root:
            return
        '''
        定义next_last为下一层的最后一个，cur_last为当前层最后一个
        temp用于存放当前行的值，resutl存放最终的结果
        '''
        next_last = cur_last = root
        _queue = [root]
        result, temp = [], []
        while _queue:
            # 在按层遍历的基础上，不断把下层最右边儿子赋值给next_last
            _cur = _queue.pop(0)
            temp.append(_cur.val)
            if _cur.left:
                _queue.append(_cur.left)
                next_last = _cur.left
            if _cur.right:
                _queue.append(_cur.right)
                next_last = _cur.right
            # 如果当前节点为此层最后的节点时，
            # 进行下层最后一个节点的赋值(cur_last=next_last)，然后才由_queue.pop(0)进入下层
            if _cur == cur_last:
                result.append(temp)
                temp = []
                cur_last = next_last
        return result