剑指Offer Day10

问题一：

请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配

public class Solution {
    public boolean matchStr(char[] str, int i, char[] pattern, int j) {
        if (i == str.length && j == pattern.length) {
            return true;
        }
        else if (j == pattern.length) {   //不能忽略，否则越界！！！
            return false;
        }
        
        if (j + 1 < pattern.length && pattern[j + 1] == '*') {
            if (i < str.length && (pattern[j] == '.' || str[i] == pattern[j])) {
                return matchStr(str, i, pattern, j + 2) || matchStr(str, i + 1, pattern, j);
            }
            else {
                return matchStr(str, i, pattern, j + 2);
            }
        }
        else {
            if (i < str.length && (pattern[j] == '.' || str[i] == pattern[j])) {
                return matchStr(str, i + 1, pattern, j + 1);
            }
            else {
                return false;
            }
        }
    }
    public boolean match(char[] str, char[] pattern)
    {
        return matchStr(str, 0, pattern, 0);
    }
}

问题二：

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

String pattern = "^[+-]?\\d*(?:\\.\\d*)?(?:[eE][+-]?\\d+)?$";  //可以通过测试，但是我觉得可能会出现整数部分小数部分同时为空的情况。

import java.util.regex.Pattern;
public class Solution {
    public boolean isNumeric(char[] str) {
        //String pattern = "^[+-]?\\d*(?:\\.\\d*)?(?:[eE][+-]?\\d+)?$";
        String pattern = "[+-]?(\\d*\\.\\d+|\\d+\\.?)([eE][+-]?\\d+)?";
        String s = new String(str);
        return Pattern.matches(pattern, s);
    }
}

问题三：字符流中第一个不重复的字符

题目描述

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

输出描述:

如果当前字符流没有存在出现一次的字符，返回#字符。

import java.util.Queue;
import java.util.LinkedList;
public class Solution {
    int [] count = new int[128];
    Queue<Character> q = new LinkedList<>();
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        if (count[ch]++ == 0) {
            q.offer(ch);
        }
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        Character ch = null;
        char c = 0;
        while ((ch = q.peek()) != null) {
            c = ch.charValue();
            if (count[c] == 1)
                return c;
            else 
                q.remove();   //不断更新当前流中的不重复字符
        }
        return '#';
    }
}

2. HashMap

import java.util.*;
public class Solution {

    String s = "";
    Map<Character, Integer> map = new HashMap<>();
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        if (!map.containsKey(ch)) {
            map.put(ch, 1);
        }
        else {
            map.put(ch, map.get(ch) + 1);
        }
        s += ch;

    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        int index = Integer.MAX_VALUE;
        char ans = '#';
        for (Character c : map.keySet()) {
            if (map.get(c) == 1) {
                index = s.indexOf(c) < index ? s.indexOf(c) : index;
                ans = s.charAt(index);
            }
        }
        return ans;
    }
}

3.LinkedHashMap

import java.util.*;
public class Solution {
 
    LinkedHashMap<Character, Integer> map = new LinkedHashMap<>();
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        if (!map.containsKey(ch)) {
            map.put(ch, 1);
        }
        else {
            map.put(ch, -1);
        }
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        Iterator<Character> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            char c = iterator.next();
            if (map.get(c) == 1) {
                return c;
            }
        }
        return '#';
    }
}

问题四：链表的环的入口结点

快慢指针法

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        if (pHead == null || pHead.next == null) {
            return null;
        }
        
        ListNode fast = pHead;
        ListNode slow = pHead;

        /*  
        do {
            fast = fast.next.next;
            slow = slow.next;
        }while(fast != slow);  //不判断fast.next是否为null也能通过，为啥？不怕出现空指针吗？
        
        fast = pHead;
        while (fast != slow) {
            slow = slow.next;
            fast = fast.next;
        }
        return fast;*/
        
        while (fast != null || fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                fast = pHead;
                while (fast != slow) {
                    slow = slow.next;
                    fast = fast.next;
                }
                return fast;
            }
        }
        return null;
    }
}

问题五：删除该链表中重复的结点

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if (pHead == null || pHead.next == null) {
            return pHead;
        }
        // 构建辅助头结点
        ListNode head = new ListNode(Integer.MIN_VALUE);
        head.next = pHead;
        ListNode pre = head;
        ListNode cur = pHead;
        while (cur != null) {
            if (cur.next != null && cur.val == cur.next.val) {
                while (cur.next != null && cur.val == cur.next.val) {
                cur = cur.next;
                }
                pre.next = cur.next;
                cur = cur.next;
            }
            else {
                pre = cur;
                cur = cur.next;
            }
        }
        return head.next;
    }
}