附加题 54-56

面试题54：表示数值的字符串

这道题的关键也在于讨论清楚情况，把所有可能出现的情况都考虑到。需要注意的是，指数E后面必须跟一个整数，不能没有数，也不能为小数。
LeetCode 65

思路梳理

难点：有很多情况需要考虑

class Solution(object):
    def isNumber(self, s):
    # s字符串
        # 需要判断三种合法情况
        # 1. 开头的正负号
        # 2. e后面只能是整数
        # 3. 不能有其他字母
        
        # 去掉首尾的空格
        s = s.strip(' ')
        if len(s)==0:
            return False
        
        # 如果最后一个字符是e
        if s[-1] in ['e','E']:
            return False
        
        num_flag = False
        e_flag = -1
        dot_flag = -1
        
        # 去掉数字的符号位
        if s[0] in ['+','-']:
            s = s[1:]
            
        # 如果第一个字符是小数点
        elif s[0] in ['.']:
            dot_flag = 1
            s = s[1:]
        
        # 如果第一个字符不是数字
        elif not s[0].isdigit():
            return False
        
        for i in range(len(s)):
            if s[i].isdigit():
                num_flag = True
            # 如果当前符号不是数字，则可能的合法情况有两种
            if not s[i].isdigit():
                # 如果是指数部分
                if s[i] in ['e', 'E']:
                    if e_flag == -1:
                        e_flag = 1
                        # 判断e之后的数字是否整数
                        # 并且e之前必须是一个有效的数字
                        if s[i+1] in ['+','-']:
                            return s[i+2:].isdigit() and num_flag
                        else:
                            return s[i+1:].isdigit() and num_flag
                    else:
                        return False
                # 如果是小数点，则改变小数点的标记
                if s[i] == '.':
                    if dot_flag == -1:
                        dot_flag = 1
                    else:
                        return False
                else:
                    return False
        # 如果整个循环都没有返回值，则该字符串通过考验
        return num_flag       

面试题55：字符流中第一个不重复的字符

请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

思路梳理

新建一个dict，当做哈希表，遍历之后列表中出现的元素是否已经存储在哈希表中。

# -*- coding:utf-8 -*-
class Solution:
    # 返回对应char，使用一个队列和一个哈希表
    # 队列的先入先出特性，保证了可以保存多个出现一次的字符
    def __init__(self):
        self.queue = []
        self.dict = {}
        
    def FirstAppearingOnce(self):
        # 弹出出现多次的字符
        while len(self.queue)>0 and self.dict[self.queue[0]] !=1:
            self.queue.pop(0)
        # 在剩下的队列中找到结果
        if len(self.queue)==0:
            return '#'
        else:
            return self.queue[0]
        
    def Insert(self, char):
        # 将字符加入队列并更新字典
        if char not in self.dict:
            self.queue.append(char)
            self.dict[char] = 1
        else:
            self.dict[char] = 2

面试题56：链表中环的入口结点

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

思路梳理

假设入口结点距离头结点 a(图中的H) 个单位，fast和slow相遇在 X，距离入口结点 E 有 b 个单位的位置，环剩下的长度为c，
则有 slow的步数=fast的步数即 a+b+c+b = 2*(a+b) ，则可以推导出 -> a = c 。

• 所以在找到重合点之后， slow所走的剩下步数 c 等于 从head开始到环起点的距离 a。
  假设 fast 走了n 个loops：a+b=nL => a = nL - b
  

class Solution(object):
    def detectCycle(self, head):
        # 已经判断了是否存在head为空的情况
        try:
        # 找到是否有环
            fast = head.next
            slow = head
            while fast is not slow:
                fast = fast.next.next
                slow = slow.next
        except:
            # if there is an exception, we reach the end and there is no cycle
            return None
        
        # 找到一个重合点之后
        # since fast starts at head.next, we need to move slow one step forward
        slow = slow.next
        while head != slow:
            head = head.next
            slow = slow.next
        return head