leetcode每日一练

DATAwhale编程第六期任务一

一、任务说明：
1、栈
用数组实现一个顺序栈
用链表实现一个链式栈
编程模拟实现一个浏览器的前进、后退功能

2、队列
用数组实现一个顺序队列
用链表实现一个链式队列
实现一个循环队列

3、链表
实现单链表、循环链表、双向链表，支持增删操作
实现单链表反转
实现两个有序的链表合并为一个有序链表
实现求链表的中间结点

二、对应的 LeetCode 练习题

一、栈

1、Valid Parentheses（有效的括号）
https://leetcode.com/problems/valid-parentheses/

    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack=[]
        length=len(s)
        if (length%2):
            return False
            
   
      for i in s:
            if not stack:
                stack.append(i)
                continue
            top=stack[-1]
            if top=='(':
                if i==')':
                    stack.pop()
                else:
                    stack.append(i)
            elif top=='{':
                if i=='}':
                    stack.pop()
                else:
                    stack.append(i)
            elif top=='[':
                if i==']':
                    stack.pop()
                else:
                    stack.append(i)
            else:
                     return False
        if not stack:
                return True
        else:
                return False
           

2、Longest Valid Parentheses（最长有效的括号）
https://leetcode.com/problems/longest-valid-parentheses/

    def longestValidParentheses(self, s):
        """
        :type s: str
        :rtype: int
        """
        n=len(s)
        stack,index_stack=[],[-1]
        max_len=0
        for i in range(n):
            if s[i]=='(':
                stack.append(s[i])
                index_stack.append(i)
            else:
                if stack!=[]:
                    stack.pop()
                    index_stack.pop()
                else:
                    index_stack.append(i)
        if len(index_stack)==1:
            max_len=len(s)
        else:
            index_stack.append(len(s))
        for i in range(len(index_stack)-1):
            if index_stack[i+1]-index_stack[i]!=1:
                if max_len<index_stack[i+1]-index_stack[i]-1:
                    max_len=index_stack[i+1]-index_stack[i]-1
        return max_len

3、Evaluate Reverse Polish Notatio（逆波兰表达式求值）
https://leetcode.com/problems/evaluate-reverse-polish-notation/

    def evalRPN(self, tokens):
        """
        :type tokens: List[str]
        :rtype: int
        """
        stack=[]
        for t in tokens:
            if t not in['+','-','*','/']:
                stack.append(int(t))
            else:
                r,l=stack.pop(),stack.pop()
                if t=="+":
                     stack.append(l+r)
                elif t=="-":
                    stack.append(l-r)
                elif t=="*":
                    stack.append(l*r)
                elif t=="/":
                     stack.append(l/r)
                else:
                    if l*r<0 and l%r!=0:
                         stack.append(l/r+1)
                    else:
                         stack.append(l/r)
        return stack.pop()

二、队列
1、Design Circular Deque（设计一个双端队列）
https://leetcode.com/problems/design-circular-deque/

    def __init__(self, k):
        """
        Initialize your data structure here. Set the size of the deque to be k.
        :type k: int
        """
        self.a=[None]*k
        self.k=k
        self.sz=0
        self.b=k-1
        self.f=0
        
    def prev_idx(self,i):
        if i==0:
            return self.k-1
        else:
            return i-1
        
        
    def next_idx(self,i):
        return (i+1)%self.k

    
    def insertFront(self, value):
        """
        Adds an item at the front of Deque. Return true if the operation is successful.
        :type value: int
        :rtype: bool
        """
        if self.sz== self.k:
            return False
        self.f=self.prev_idx(self.f)
        self.a[self.f]=value
        self.sz+=1
        return True

    def insertLast(self, value):
        """
        Adds an item at the rear of Deque. Return true if the operation is successful.
        :type value: int
        :rtype: bool
        """
        if self.sz==self.k:
            return False
        self.b=self.next_idx(self.b)
        self.a[self.b]=value
        self.sz +=1
        return True
        

    def deleteFront(self):
        """
        Deletes an item from the front of Deque. Return true if the operation is successful.
        :rtype: bool
        """
        if self.sz==0:
            return False
        self.f=self.next_idx(self.f)
        self.sz-=1
        
        return True

    def deleteLast(self):
        """
        Deletes an item from the rear of Deque. Return true if the operation is successful.
        :rtype: bool
        """
        if self.sz==0:
            return False
        self.b=self.prev_idx(self.b)
        self.sz-=1
        
        return True
        

    def getFront(self):
        """
        Get the front item from the deque.
        :rtype: int
        """
        if self.sz==0:
            return -1
        return self.a[self.f]
        

    def getRear(self):
        """
        Get the last item from the deque.
        :rtype: int
        """
        if self.sz==0:
            return -1
        return self.a[self.b]

    def isEmpty(self):
        """
        Checks whether the circular deque is empty or not.
        :rtype: bool
        """
        return self.sz==0

    def isFull(self):
        """
        Checks whether the circular deque is full or not.
        :rtype: bool
        """
        
        return self.sz==self.k

# Your MyCircularDeque object will be instantiated and called as such:
# obj = MyCircularDeque(k)
# param_1 = obj.insertFront(value)
# param_2 = obj.insertLast(value)
# param_3 = obj.deleteFront()
# param_4 = obj.deleteLast()
# param_5 = obj.getFront()
# param_6 = obj.getRear()
# param_7 = obj.isEmpty()
# param_8 = obj.isFull()

2、Sliding Window Maximum（滑动窗口最大值）
https://leetcode.com/problems/sliding-window-maximum/

    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        if not nums:
            return []
        res=[]
        for i in range (len(nums)-k +1):
            temp=max(nums[i:i+k])
            res.append(temp)
        return res

三、链表
1、Linked List Cycle I（环形链表）
https://leetcode.com/problems/linked-list-cycle/

# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        try:
            slow=head
            fast=head.next

            while slow is not fast:

                slow=slow.next
                fast=fast.next.next
            return True
        except:
            return False

2、Merge k Sorted Lists（合并 k 个排序链表）
https://leetcode.com/problems/merge-k-sorted-lists/

# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        from heapq import heappush,heappop,heapreplace,heapify
        dummy=node=ListNode(0)
        h=[(li.val,li) for li in lists if li]
        heapify(h)
        while h:
            v,li=h[0]
            if li.next is None:
                heappop(h)
            else:
                heapreplace(h,(li.next.val,li.next))
            node.next=li
            node=node.next
        return dummy.next