Python每日一练(20230412) 队列实现栈、二叉树序列化、交换链表节点

class MyStack:
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.queue = []
        self.help = []
    def push(self, x):
        """
        Push element x onto stack.
        """
        while len(self.queue) != 0:
            self.help.append(self.queue.pop(0))
        self.queue.append(x)
        while len(self.help) > 0:
            self.queue.append(self.help.pop(0))
    def pop(self):
        """
        Removes the element on top of the stack and returns that element.
        """
        de = self.queue.pop(0)
        return de
    def top(self):
        """
        Get the top element.
        """
        de = self.queue[0]
        return de
    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        if len(self.queue) == 0:
            return True
        return False
# %%
myStack = MyStack();
myStack.push(1)
myStack.push(2)
print(myStack.top())
print(myStack.pop())
print(myStack.empty())

class TreeNode:
    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 root == None:
            return "null,"
        left_serialize = self.serialize(root.left)
        right_serialize = self.serialize(root.right)
        return str(root.val) + "," + left_serialize + right_serialize
    def deserialize(self, data):
        """Decodes your encoded data to tree.
        :type data: str
        :rtype: TreeNode
        """
        def dfs(queue):
            val = queue.popleft()
            if val == "null":
                return None
            node = TreeNode(val)
            node.left = dfs(queue)
            node.right = dfs(queue)
            return node
        from collections import deque
        queue = deque(data.split(","))
        return dfs(queue)
# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None
class LinkList:
    def __init__(self):
        self.head=None
    def initList(self, data):
        self.head = ListNode(data[0])
        r=self.head
        p = self.head
        for i in data[1:]:
            node = ListNode(i)
            p.next = node
            p = p.next
        return r
    def    convert_list(self,head):
        ret = []
        if head == None:
            return
        node = head
        while node != None:
            ret.append(node.val)
            node = node.next
        return ret
class Solution(object):
    def swapPairs(self, head):
        dummyHead = ListNode(-1)
        dummyHead.next = head
        prev, p = dummyHead, head
        while p != None and p.next != None:
            q, r = p.next, p.next.next
            prev.next = q
            q.next = p
            p.next = r
            prev = p
            p = r
        return dummyHead.next
# %%
l = LinkList()
head = [1,2,3,4]
l1 = l.initList(head)
s = Solution()
print(l.convert_list(s.swapPairs(l1)))