判断字符串是否是互为置换，类似 替换字符串之类的遍历就行了。。

class Solution:    # @param {string} A a string    # @param {string} B a string    # @return {boolean} a boolean    def stringPermutation(self, A, B):        # Write your code here        if len(A) !=len(B):return False        lb=[]        for b in B:，            lb.append(b)        for a in A:            if a in lb:                lb.remove(a)            else:                return False        return True

 取滑动窗口的中位数，如果窗口是偶数取中间两个比较小的那个，这个做起来有点复杂，一开始上来直接遍历加排序，总是提示超时，后来优化排序除第一次用全排，后边直接用插入排序，直接用插入排序还是慢，因为上次的序列是一个有序序列可以用二分法优化

插入排序，这么做以后每次构造新的序列移除一个元素还是耗时多，因为本身上次序列是有序的，也可以直接通过索引知道要移除的值，再用二分查找，得出索引，直接移除该索引对应的值

class Solution:    """    @param nums: A list of integers.    @return: The median of element inside the window at each moving.    """    def medianSlidingWindow(self, nums, k):        # write your code here        le = len(nums)        res = []        a = []        def sort(b,first=True):            if len(b) < 2:return b            if first:                return sortq(b)#快速排序，只运行第一次            else:#二分插入                insert = b[len(b) - 1]                low=0                high=len(b)-2                while low<=high:                    mid=(low+high)//2;                    if insert>b[mid]:                        low=mid+1                    else:                        high=mid-1                b.insert(low,insert)                b.pop()                return b                        def sortq(b):            if len(b)<2:                return b            else:                q=b[0]                less=[i for i in b[1:] if i<=q]                greator=[i for i in b[1:] if i>q]                return sortq(less)+[q]+sortq(greator)                      for i in range(le):            if i + k > le: break            if i == 0:                a = nums[i:i + k]                b = sort(a)            else:                n=len(b)                l = 0                r = n - 1                target = nums[i - 1]                while l <= r:#二分查找                    mid = (l + r) // 2                    if b[mid] > target:                        r = mid-1                    elif b[mid]
     
       b[l / 2] else b[l / 2 - 1])            else:                  res.append(b[l // 2])        return res
     

 接雨水二 ，一个二维的数组，每个位置有一个高度，问可以接多少水·

整了半天没整明白，网上查了下，从外围构造一个范围，用优先队列做存储，每次pop最小的一个高度然后判断其上下左右的位置是否比该值小，小就又水流入，然后把该点push队列，标记高度为高的哪一个，标记访问到的位置，循环直到队列没有为止

python 又自带的优先队列 heapd，但是这里需要自定义一个类型，看了一下heapd里面的实现代码做大小比较的时候是直接用的运算符，这里直接把自定义类型重载运算符就可以直接用了

class Solution:    class bar(object):        def __init__(self, x, y, h):            self.x = x            self.y = y            self.h = h        def __lt__(self, other):            return self.h < other.h            def __gt__(self,other):            return self.h > other.h        def __eq__(self, other):            return self.h == other.h    # @param heights: a matrix of integers    # @return: an integer    def trapRainWater(self, heights):        # write your code here        res=0        import heapq        pq = []        heapq.heapify(pq)        cols=len(heights[0])        rows=len(heights)        visit=[None]*rows        for i in range(rows):            visit[i]=[False]*cols        for i in range(cols):            heapq.heappush(pq,self.bar(0,i,heights[0][i]))            visit[0][i]=True            heapq.heappush(pq, self.bar(rows-1, i, heights[rows-1][i]))            visit[rows-1][i] = True        for i in range(1,rows-1):            heapq.heappush(pq, self.bar(i, 0, heights[i][0]))            visit[i][0] = True            heapq.heappush(pq, self.bar(i, cols-1, heights[i][cols-1]))            visit[i][cols-1] = True        dir=[[-1,0],[1,0],[0,-1],[0,1]]        while len(pq)>0:            b = heapq.heappop(pq)            for i in dir:                x=b.x+i[0]                y=b.y+i[1]                if x>=0 and x
     
      =0 and y
      
       b.h:h=heights[x][y]                    else: h=b.h                    nb=self.bar(x,y,h)                    heapq.heappush(pq,nb)        return res
      
     

 链表求和问题,两个链表，每个节点都只有一位数字，表示一个多位数，输出相加以后的数字的链表形式，这里把两个链表都直接累加程字符串，然后转成数字相加，再转成字符串然后组装成链表输出

class Solution:    # @param l1: the first list    # @param l2: the second list    # @return: the sum list of l1 and l2     def addLists2(self, l1, l2):        # Write your code here        strl1 = ''        current = l1        while current is not None:            strl1 = strl1+str(current.val)            current = current.next        intl1 = int(strl1)        strl1 = ''        current = l2        while current is not None:            strl1 = strl1 + str(current.val)            current = current.next        intl2 = int(strl1)        val = str(intl1+intl2)        res = None        last = None        for s in val:            v = int(s)            if res is None:                res = ListNode(v)                last=res            else:                last.next = ListNode(v)                last = last.next        return res

 回文数，转成字符串倒个序，然后再转成数字，判断相等就行了

class Solution:    # @param {int} num a positive number    # @return {boolean} true if it's a palindrome or false    def palindromeNumber(self, num):        # Write your code here        strr = ''        for s in str(num):            strr = s + strr        num2=int(strr)        return num == num2