力扣天天练-day3

topic19:删除链表表的倒数第n个结点

题目描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

类似于删除列表的倒数第n个元素

思路：用双指针,前后两个指针，相差n，当前指针到达链表末尾的时候，后指针即为所求

def removeNthFromEnd(head,n):#双指针，一前以后，相距n，前指针到达列表尾时，后指针为所求
    
    next=0  #后指针
    pro=next+n   #前指针
    length=len(head)  #列表长度

    for pro in range(n,length):
        if pro==length-1:
            next+=1
            del head[next]
            return  head
        else:
            next+=1   #前后指针同时向后移
            pro+=1
    return head
def re2(head,n):     #python中用列表倒置，很轻松解决
    reverse=head[::-1]
    del reverse[n-1]
    return reverse[::-1]

链表：

def removeNthFromEnd(self, head, n) :
        # 定义左右指针和虚拟头结点，虚拟头结点的next指向head，方便处理头结点的删除
        left = right = dummy = ListNode(next=head)
        # 将右指针向后移动n个位置
        for _ in range(n):
            right = right.next
        # 当右指针到达链表末尾时，左指针指向待删除节点的前一个节点
        while right.next:
            left = left.next
            right = right.next
        # 将待删除节点从链表中删除
        left.next = left.next.next
        # 返回去掉头结点的链表
        return dummy.next

 

topic20：有效的括号

题目描述：给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。有效字符串需满足：

        左括号必须用相同类型的右括号闭合。
        左括号必须以正确的顺序闭合。
        每个右括号都有一个对应的相同类型的左括号。

思路：经典括号匹配问题，用栈将元素存储，如果是左括号则入栈，遇到括号则弹出栈顶元素，不匹配则返回false，匹配则继续，直到栈空，时间复杂度O(n)

def isValid(string):
    stack=[]  #初始化一个空栈
    length=len(string)
    for i in range(0,length):
        if string[i]=='(' or string[i]=='[' or string[i]=='{':
            stack.append(string[i])
        elif string[i]==')':   #当遇到右括号时，比较栈顶元素是否为左括号
            if len(stack)==0:
                return False
            if stack[-1]=='(':
                stack.pop()   #弹出栈顶元素
            else:
                return False
        elif string[i]==']':   #当遇到右括号时，比较栈顶元素是否为左括号
            if len(stack)==0:
                return False
            if stack[-1]=='[':
                stack.pop()   #弹出栈顶元素
            else:
                return False
        elif string[i]=='}':   #当遇到右括号时，比较栈顶元素是否为左括号
            if len(stack)==0:
                return False
            if stack[-1]=='{':
                stack.pop()   #弹出栈顶元素
            else:
                return False
    if len(stack)!=0:
        return False
    return True

 

topic21：合并两个有序链表

题目描述：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

思路：构造一个长度为；l1+l2的新链表，遍历min（l1,l2）次，将两个链表的表头比较，较小者加入新链表，双指针。

def mergeTwoLists(list1,list2):
    length=len(list1)+len(list2)
    result=[0]*length   # 初始化结果列表
    i,j=0,0
    for k in range(0,length):
        if i==len(list1):
            result[k:]=list2[j:]   # 将剩余的元素添加到结果列表中
            break
        elif j==len(list2):
            result[k:]=list1[i:]   # 将剩余的元素添加到结果列表中
            break
        elif list1[i]>=list2[j]:
            result[k]=list2[j]
            j+=1
        else:
            result[k]=list1[i]
            i+=1
    return result

print(mergeTwoLists([1,2,3],[4,5,6]))

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        cur = ListNode()
        temp = cur # 保存头指针，移动的是cur指针
        while l1 and l2:
            if l1.val <= l2.val:
                cur.next = l1
                l1 = l1.next
            elif l1.val > l2.val:
                cur.next = l2
                l2 = l2.next
            cur = cur.next
        if l1 is not None:
            cur.next = l1
        elif l2 is not None:
            cur.next = l2
        return temp.next
            

 

 

topic22：括号生成

题目描述：数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

思路：相当于给这些括号排序，要求：第一个绝对是左括号，最后一个绝对是右括号，看到所有可能，需要想到回溯（标记，进修后再完成）

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        # 定义一个列表用来存储结果
        result = []

        # 定义一个递归函数generate，用来生成符合要求的括号字符串
        def generate(start_str, left, right):
            # 如果左括号用完了，就在字符串末尾加上剩余的右括号，将生成的字符串添加到结果列表中
            if left == 0:
                result.append(start_str + ")" * right)
                return
            # 如果左右括号数相同，只能再添加左括号
            if right == left:
                generate(start_str + "(", left - 1, right)
            # 如果左括号数比右括号数多，既可以添加左括号，也可以添加右括号
            else:
                generate(start_str + "(", left - 1, right)
                generate(start_str + ")", left, right - 1)

        # 调用递归函数generate，生成符合要求的括号字符串，并将结果添加到结果列表中
        generate("", n, n)

        # 返回结果列表
        return result

​​​​​​​ 

 

topic23：合并k个升序链表

题目描述：给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。

思路：k个指针，比较k个链表头结点的大小，将小的加入新链表，与合并两个链表思路一样，可以用二分查找来降低时间复杂度（比较k个元素）