笔试刷题必备------ 设计问题

笔试刷题必备------ 设计问题

Shuffle an Array

import copy
import random

class Solution(object):
    def __init__(self,nums):
        self._item = nums
    def reset(self):
        return self._item
    def shuffle(self):
        res = []
        temp = copy.deepcopy(self._item)
        while len(temp) != 0:
            toInsert = temp[random.randint(0,len(temp)-1)]
            res.append(toInsert)
            temp.remove(toInsert)
        return res

最小栈

class Stack(object):
    def __init__(self):
        self.item = []

    def push(self,x):
        self.item.append(x)

    def isEmpty(self):
        return self.item == []

    def pop(self):
        if self.isEmpty():
            raise Exception("Your Stack is Empty!")
        return self.item.pop()

    def top(self):
        if self.isEmpty():
            raise Exception("Your stack is Empty!")
        return self.item[-1]

    def size(self):
        return len(self.item)



class MinStack(object):
    def __init__(self):
        self.dataStack = Stack()
        self.minStack = Stack()

    def isEmpty(self):
        return self.dataStack.isEmpty()

    def push(self,x):
        self.dataStack.push(x)
        if self.minStack.isEmpty():
            self.minStack.push(x)
        elif self.minStack.top() >= x:
            self.minStack.push(x)

    def pop(self):
        if self.isEmpty():
            raise Exception("Your MinStack is Empty!")
        else:
            val = self.dataStack.pop()
            if val == self.minStack.top():
                self.minStack.pop()
            return val

    def top(self):
        return self.dataStack.top()
    def size(self):
        return self.dataStack.size()

    def getMin(self):
        return self.minStack.top()




if __name__ == "__main__":
    stack = Stack()
    stack.push(1)
    stack.push(2)
    stack.push(3)
    #print(stack.pop())
    #print(stack.top())

    mstack = MinStack()
    mstack.push(1)
    mstack.push(2)
    mstack.push(3)
    mstack.push(4)
    print(mstack.pop())
    print(mstack.getMin())
    print(mstack.top())

二叉树的序列化与反序列化

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

示例:

你可以将以下二叉树：

  1
 / \
2   3
   / \
  4   5

序列化为 “[1,2,3,null,null,4,5]”
提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

说明: 不要使用类的成员 / 全局 / 静态变量来存储状态，你的序列化和反序列化算法应该是无状态的。

leetcode中的答案代码

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:
    def serialize(self, root):
        """Encodes a tree to a single string.

        :type root: TreeNode
        :rtype: str
        """
        if not root:
            return []
        return_list = []
        current_level = [root]
        while len(current_level):
            new_level = []
            for current_node in current_level:
                if current_node:
                    return_list.append(str(current_node.val))
                    new_level.append(current_node.left)
                    new_level.append(current_node.right)

                else:
                    return_list.append(None)

            current_level= new_level
        return return_list

    def deserialize(self, data):
        """Decodes your encoded data to tree.

        :type data: str
        :rtype: TreeNode
        """

        if len(data) == 0:
            return None
        return_node = TreeNode(int(data[0]))
        current_level = [return_node]
        data = data[1:]
        while len(current_level):
            new_level = []
            count = 0
            for current_node in current_level:
                if current_node:
                    count+=1

            if not count:
                break
            new_level_data = data[:count*2]
            data = data[count*2:]
            count = 0
            for current_node in current_level:
                if current_node:
                    if new_level_data[count]:
                        current_node.left = TreeNode(int(new_level_data[count]))
                    count +=1
                    new_level.append(current_node.left)
                    if new_level_data[count]:
                        current_node.right = TreeNode(int(new_level_data[count]))
                    count += 1
                    new_level.append(current_node.right)
                    
            current_level = new_level
        return return_node




        # Your Codec object will be instantiated and called as such:
        # codec = Codec()
        # codec.deserialize(codec.serialize(root))

个人感觉leetcode是有问题的
所以给出了自己的实现

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


class Solution(object):
    #类似于层次遍历，但是不需要把层表示出来
    def serialize(self, root):
        """Encodes a tree to a single string.

        :type root: TreeNode
        :rtype: str
        """
        if root == None:
            return '[]'
        res = []
        current_level = [root]
        while current_level:
            next_level = []
            for current_node in current_level:
                if current_node:
                    res += [current_node.val]
                    next_level += [current_node.left]
                    next_level += [current_node.right]
                else:
                    res.append(None)

            # 判断一下next_level是否全是空的
            isAllNone = True
            for i in next_level:
                if i != None:
                    isAllNone = False
            if isAllNone:
                break
            current_level = next_level
        res_str = "["
        for i in res:
            res_str += str(i)
            res_str += ','
        res_str = res_str[:-1] + "]"

        return res_str


        res_str =  "["
        for i in res:
            res_str+=str(i)
            res_str+=","
        res_str=res_str[:-1]+"]"
        return res_str

    def deserialize(self, data):
        root_list = []
        data = data[1:-1].split(',')

        count = 1
        while 2*count+1 <= len(data):

            if data[count-1] != 'None':
                root = TreeNode(int(data[count-1]))
            if data[count*2-1] != 'None':
                root.left = TreeNode(int(data[count*2-1]))

            if data[count*2+1-1] != 'None':
                root.right = TreeNode(int(data[count*2+1-1]))

            root_list.append(root)
            count += 1

        count2 = 1
        while 2*count2+1 <= len(root_list):
            root_list[count2-1].left = root_list[count2*2-1]
            root_list[count2-1].right = root_list[count2*2+1-1]
            count2 += 1

        return root_list[0]




    def in_order_recusive(self,root):
        if root == None:
            return []
        res = []
        res += self.in_order_recusive(root.left)
        res.append(root.val)
        res += self.in_order_recusive(root.right)

        return res

    def level_order_recusive(self,root):
        if root == None:
            return []
        res = []
        current_level = [root]
        while current_level:
            res.append([current_node.val for current_node in current_level])
            next_level = []
            for current_node in current_level:
                if current_node.left != None:
                    next_level+=[current_node.left]
                if current_node.right != None:
                    next_level+=[current_node.right]
            current_level = next_level

        return res

if __name__ == "__main__":
    node1 = TreeNode(1)
    node2 = TreeNode(2)
    node3 = TreeNode(3)
    node4 = TreeNode(4)
    node5 = TreeNode(5)
    node1.left = node2
    node1.right = node3
    node3.left = node4
    node3.right = node5
    solu = Solution()
    print("中序遍历：")
    print(solu.in_order_recusive(node1))
    print("序列化：")
    print(solu.serialize(node1))
    data = solu.serialize(node1)

    print("反序列化：")
    r = solu.deserialize(data)
    print(solu.in_order_recusive(r))
    print("层次遍历一下反序列化的结果：")
    print(solu.level_order_recusive(r))

Insert Delete GetRandom O(1)

设计一个支持在平均时间复杂度 O(1) 下，执行以下操作的数据结构。

insert(val)：当元素 val 不存在时，向集合中插入该项。
remove(val)：元素 val 存在时，从集合中移除该项。
getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。
示例 :

// 初始化一个空的集合。
RandomizedSet randomSet = new RandomizedSet();

// 向集合中插入 1 。返回 true 表示 1 被成功地插入。
randomSet.insert(1);

// 返回 false ，表示集合中不存在 2 。
randomSet.remove(2);

// 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
randomSet.insert(2);

// getRandom 应随机返回 1 或 2 。
randomSet.getRandom();

// 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
randomSet.remove(1);

// 2 已在集合中，所以返回 false 。
randomSet.insert(2);

// 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。
randomSet.getRandom();

import random
class RandomizedSet(object):
    def __init__(self):
        """
        Initialize your data structure here
        """
        self.values = []
        self.index = {}

    def insert(self,val):
        """
        Inserts a value to the set . Returns true if the set did not already contain the specified element.
        :type val: int
        :rtype: bool
        """
        if val in self.index:
            return False
        self.values.append(val)
        self.index[val] = len(self.values)-1
        return True

    def remove(self,val):
        """
        Removes a value from the set. Returns true if the set contained the specified element.
        :type val: int
        :rtype: bool
        """
        if val not  in self.index:
            return False
        self.index[self.values[-1]] = self.index[val]
        self.values[-1],self.values[self.index[val]] = self.values[self.index[val]],self.values[-1]
        self.values.pop()
        self.index.pop(val)
        return True
    def getRandom(self):
        return self.values[random.randint(0,len(self.values)-1)]