zoukankan      html  css  js  c++  java
  • lintcode 刷题记录··

    单例模式,用C#实现过单例模式,python区别就是类里边的静态方法写法不一样,python叫类方法,函数之前加@classmethod

    class Solution:
        # @return: The same instance of this class every time
        __m_Solution=None
        
        @classmethod
        def getInstance(self):
            # write your code here
            if self.__m_Solution == None:
                self.__m_Solution=Solution()
            return self.__m_Solution
    
        def __init__(self):
            pass

    遍历二叉树路径,输出与给定值相同的所有路径,这里是递归调用的,本来像把递归改成循环的 但是高了好久 没搞出来····

    class Solution:
        # @param {int} target an integer
        # @return {int[][]} all valid paths
        def binaryTreePathSum(self, root, target):
            # Write your code here
            res = []
            path = []
            import copy
            def getallpath(current, path, res):
                if current == None: return
                path.append(current.val)
                if current.left != None:
                    getallpath(current.left,copy.deepcopy(path), res)
                if current.right != None:
                    getallpath(current.right,copy.deepcopy(path),res)
                if current.left is None and current.right is None:
                    res.append(path)
    
            getallpath(root,path,res)
            ps=[]
            for p in res:
                sum=0
                for v in p:
                    sum=sum+v
                if sum==target:ps.append(p)
            return  ps
            

     三角形计数 给定一个整数数组,在该数组中,寻找三个数,分别代表三角形三条边的长度,问,可以寻找到多少组这样的三个数来组成三角形

    直接遍历会提示超过时间限制

    选择排序加二分查找的方法来提高效率,python默认的递归有上线,需要设置,  还有二分查找的方法是先确认最大最小边然后找第三边,这样条件就变成一个

    class Solution:
        # @param S: a list of integers
        # @return: a integer
        def triangleCount(self, S):
            # write your code here
            def quicksort(a):  # 快速排序
                if len(a) < 2:
                    return a
                else:
                    pivot = a[0]
                    less = [i for i in a[1:] if i <= pivot]
                    greator = [i for i in a[1:] if i > pivot]
                    return quicksort(less) + [pivot] + quicksort(greator)
    
            n = len(S)
            if n < 3: return
            import sys
            sys.setrecursionlimit(1000000)
            S = quicksort(S)
            sum = 0
            for i in range(n):
                for j in range(i + 1, n):
                    l = i + 1
                    r = j
                    target = S[j] - S[i]
                    while l < r:
                        mid = (l + r) // 2
                        if S[mid] > target:
                            r = mid
                        else:
                            l = mid + 1
                    sum = sum + j - l
    
            return sum

     将一个二叉查找树按照中序遍历转换成双向链表。

    """
    Definition of TreeNode:
    class TreeNode:
        def __init__(self, val):
            this.val = val
            this.left, this.right = None, None
    Definition of Doubly-ListNode
    class DoublyListNode(object):
    
        def __init__(self, val, next=None):
            self.val = val
            self.next = self.prev = next
    """
    
    class Solution:
        """
        @param root, the root of tree
        @return: a doubly list node
        """
        def bstToDoublyList(self, root):
            # Write your code here
            l=[]
            if root is None:return
            stack=[]
            current=root
            dlist=None
            cur=None
            last=None
            while len(stack)> 0 or current is not None:
                while current is not None:
                    stack.append(current)
                    current=current.left
                current=stack.pop()
                l.append(current.val)
                cur=DoublyListNode(current.val)
                cur.prev=last
                if last is not None: last.next=cur
                last=cur
                if dlist is None :dlist=cur
                current=current.right
            return dlist
  • 相关阅读:
    Oracle与MySQL的几点区别
    MySQL使用Union创建视图报错
    MySQL指定mysqld启动时所加载的配置文件
    MySQL使用位运算
    django rest framework(3)
    Django Rest Framework(2)
    Django 之缓存
    RESTful API
    restful framework 认证源码流程
    其他排序
  • 原文地址:https://www.cnblogs.com/onegarden/p/6924209.html
Copyright © 2011-2022 走看看