面试算法题总结 - 一

快速排序法

思想，每次随机取一个数，将大于其的放在右边，小于或等于其的放在左边，如此递归

def quicksort(arr):
    if len(arr) <= 1 or len(list(filter(lambda a:a==arr[0],arr))) == len(arr):
        return arr

    middle = random.choice(range(len(arr)))
    left = []
    right = []

    for i, num in enumerate(arr):
        if num <= arr[middle]:
            left.append(num)
        elif num > arr[middle]:
            right.append(num)

    left = quicksort(left)
    right = quicksort(right)

    left.extend(right)
    return left

其他实现方法

https://blog.csdn.net/razor87/article/details/71155518

LRU缓冲算法

思想：使用字典类型存贮key,node，node存的是双向链表的引用，在双向链表中存贮value,当get 或者 put时，将该node放在双向链表的头部，若put时超出size,则将末尾的node删除。

class LRUCache(object):
    def __init__(self, size: int):
        self.size = size
        self.cache = {}
        self.head = None
        self.tail = None

    def get(self, key: str):
        node = self.cache.get(key)
        self.head.deleteNode(node)
        self.head.append(node)
        self.head = node
        return self.head

    def put(self, key, value):
        node = DuLinkList(value)
        if self.head is None:
            self.head = node
            self.tail = key
            self.cache[key] = node
            return self.head

        print('len', len(self.cache.keys()))
        if len(self.cache.keys()) >= self.size:
            last = self.head.delete()
            last_key = filter(lambda item: last == item[1], self.cache.items())
            last_key = list(last_key)[0][0]
            del self.cache[last_key]
            # del self.cache[last.value]

        self.head.append(node)
        self.head = node
        self.cache[key] = node

        return self.head


class DuLinkList(object):
    def __init__(self, value):
        self.pre = self
        self.value = value
        self.next = self

    # 添加一个元素，放在最前面
    def append(self, node):
        # 最后一个的下一个是新插入的节点
        self.pre.next = node
        # 新插入节点的上一个是最后一个
        node.pre = self.pre
        # 现在节点的前面一个是新插入的节点
        self.pre = node
        node.next = self

    # 从末尾删除一个元素
    def delete(self):
        # 倒数第二个的下一个是第一个，第一个的上一个是倒数第二个
        last = self.pre
        self.pre.pre.next = self
        self.pre = self.pre.pre
        return last

    # 从双向链表中删除一个元素
    def deleteNode(self, node):
        node.next.pre = node.pre
        node.pre.next = node.next


def iterLRU(lru):
    node = lru.head
    while node:
        print(node.value)
        node = node.next
        if node is lru.head:
            break
    print('-----')


if __name__ == '__main__':
    lru = LRUCache(5)
    lru.put(1, 1)
    lru.put(2, 2)
    lru.put(3, 3)
    lru.put(4, 4)
    lru.put(5, 5)

    lru.get(3)
    lru.get(4)

    lru.put(6, 6)
    lru.put(7, 7)

    iterLRU(lru)

比较两个二叉树是否相等

class Tree(object):
    def __init__(self, value):
        self.left = None
        self.value = value
        self.right = None


def compareTree(tree1, tree2):
    # 如果都为None,返回true
    if tree1 is None and tree2 is None:
        return True
    # 如果不都为None，其中有一个是None
    if tree1 is None or tree2 is None:
        return False
    # 如果值相等
    if tree1.value == tree2.value:
        # 比较左子节点
        left = compareTree(tree1.left, tree2.left)
        # 比较右子节点
        right = compareTree(tree1.right, tree2.right)
    else:
        return False
    # 如果左右子节点都相等
    if left and right:
        return True
    else:
        return False

if __name__ == '__main__':
    tree1 = Tree(2)
    tree1.left = Tree(1)
    tree1.right = Tree(3)

    tree2 = Tree(2)
    tree2.left = Tree(1)
    tree2.right = Tree(3)

    print(compareTree(tree1,tree2))