leecode第2天

20、有效的括号

# 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
# 有效字符串需满足：
# 左括号必须用相同类型的右括号闭合。
# 左括号必须以正确的顺序闭合。
# 每个右括号都有一个对应的相同类型的左括号。


class Solution(object):

    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        dict = {
            ')': '(',
            ']': '[',
            '}': '{'
        }
        print(dict)
        lst=[]
        for item in s:
            if item in '([{':# 左括号直接入栈
                lst.append(item)
            else:# 处理右括号
                if (len(lst) ==0 ) or lst[-1]!=dict[item]:# 栈为空或栈顶不匹配时直接返回False
                    return False
                lst.pop()# 匹配则弹出栈顶

        if (len(lst)==0):# 最终栈空说明完全匹配
            return True
        else:
            return False

21、合并两个有序链表

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

# 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, list1, list2):
        """
        合并两个有序链表为一个升序排列的新链表
        
        :type list1: Optional[ListNode]
        :param list1: 第一个链表的头节点
        :type list2: Optional[ListNode]
        :param list2: 第二个链表的头节点
        :rtype: Optional[ListNode]
        :return: 合并后新链表的头节点
        """
        # 收集第一个链表所有节点的值
        current = list1
        lst=[]
        while current is not None:
            lst.append(current.val)
            current = current.next

        # 收集第二个链表所有节点的值
        current = list2
        while current is not None:
            lst.append(current.val)
            current = current.next

        # 处理空输入的特殊情况
        if not lst:
            return None

        # 对合并后的值进行升序排列
        lst.sort()
        
        # 构建新链表：使用虚拟头节点简化操作
        dummy=ListNode(lst[0])
        rlst=dummy
        # 依次创建链表节点并连接
        for i in range(1,len(lst)):
            rlst.next=ListNode(lst[i])
            rlst=rlst.next

        return dummy

105、同构字符串

# 给定两个字符串 s 和 t ，判断它们是否是同构的。
# 如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
# 每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，
# 相同字符只能映射到同一个字符上，字符可以映射到自己本身。
class Solution(object):
    def isIsomorphic(self, s, t):
        """
        判断两个字符串是否同构（字符映射关系一致）
        
        参数说明：
        :type s: str -- 输入的第一个字符串
        :type t: str -- 输入的第二个字符串
        :rtype: bool -- 返回是否满足同构关系
        
        实现逻辑：
        1. 双向验证字符映射关系
        2. 建立s到t的字符映射表，验证每个s字符对应唯一的t字符
        3. 建立t到s的字符映射表，验证每个t字符对应唯一的s字符
        """
        if len(s)!=len(t):
            return False
        

        # 构建s->t的映射关系并验证单向一致性
        lst1 = ''  # 记录s中出现的唯一字符序列
        lst2 = ''  # 对应t中的字符映射关系
        for i in range(len(s)):
            if s[i] not in lst1:
                lst1 += s[i]
                lst2 += t[i]
            else:
                # 检查已有映射是否与新字符一致
                if lst2[lst1.index(s[i])] != t[i]:
                    return False
                
        # 构建t->s的映射关系并验证反向一致性
        lst3 = ''  # 记录t中出现的唯一字符序列
        lst4 = ''  # 对应s中的字符映射关系      
        for i in range(len(t)):
            if t[i] not in lst3:
                lst3 += t[i]
                lst4 += s[i]
            else:
                # 检查已有映射是否与新字符一致
                if lst4[lst3.index(t[i])] != s[i]:
                    return False
            
        return True
    
    
#leecode最快：
    def isIsomorphic1(self, s, t):
        """
        判断两个字符串是否同构。

        两个字符串同构的条件是：s中的每个字符都可以被唯一替换为t中的对应字符，
        且不同字符不能映射到同一个字符（双射关系）。

        参数:
            s (str): 第一个待验证的字符串
            t (str): 第二个待验证的字符串

        返回值:
            bool: 满足同构关系返回True，否则返回False
        """
        l=len(s)
        l_1=len(t)
        # 长度不一致直接判定非同构
        if l_1!=l:
            return False
        
        # 维护字符映射关系的哈希表
        dic={}
        
        # 遍历每个字符进行映射验证
        for i in range(l):
            # 处理新字符映射关系
            if s[i] not in dic:
                # 检查是否存在不同字符映射到相同值的冲突
                if t[i] in dic.values():
                    return False
                dic[s[i]]=t[i]
            
            # 验证已有映射的匹配一致性
            if dic[s[i]]!=t[i]:
                return False
        
        # 全部字符通过验证
        return True