java算法入门之有效的括号删除有序数组中的重复项实现strStr

public static boolean isValid(String s) {
    if (s.length()%2 != 0) return false;
    Map<Character,Character> hashMap = new HashMap<Character,Character>(){{
        put(')','(');
        put('}','{');
        put(']','[');
    }};
    //"{[]}"
    Queue<Character> queue = new LinkedList<Character>();
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if(hashMap.containsKey(c)){
            char t = queue.peek();
            System.out.println(t);//这个地方弹出的是{
            char tt = hashMap.get(c);//而这个对应的是],,上一处peek应该取得[
            System.out.println(tt);
            System.out.println(queue.peek() != hashMap.get(c));
            if (queue.isEmpty() || queue.peek() != hashMap.get(c)){
                return false;
            }
            queue.poll();
        }else{
            queue.offer(c);
        }
    }
    return queue.isEmpty();
}

public static boolean isValid(String s){
    int n = s.length();
    if (n % 2 == 1) {
        return false;
    }
 
    Map<Character, Character> pairs = new HashMap<Character, Character>() {{
        put(')', '(');
        put(']', '[');
        put('}', '{');
    }};
    Deque<Character> stack = new LinkedList<Character>();
    for (int i = 0; i < n; i++) {
        char ch = s.charAt(i);
        if (pairs.containsKey(ch)) {
            if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {
                return false;
            }
            stack.pop();
        } else {
            stack.push(ch);
        }
    }
    return stack.isEmpty();
}

public static Integer[] removeDuplicates(Integer[] nums) {
    if(nums == null || nums.length == 0){
        return nums;
    }
    List<Integer> tempList = Arrays.asList(nums);
    for (int i = tempList.size() - 1; i >= 0; i--) {
        Integer current = tempList.get(i);
        if(i-1>0){
            Integer next = tempList.get(i - 1);
            if(next == current){
                tempList.remove(current);
            }
        }
    }
    Integer[] ret = new Integer[tempList.size()];
    tempList.toArray(ret);
    return ret;
}

public static Integer[] removeDuplicates(Integer[] nums) {
    if(nums == null || nums.length == 0){
        return nums;
    }
    List<Integer> tempList = Arrays.asList(nums);
    List<Integer> list = new ArrayList<>(tempList);
    for (int i = list.size() - 1; i >= 0; i--) {
        Integer current = list.get(i);
        if(i-1>0){
            Integer next = list.get(i - 1);
            if(next == current){
                list.remove(current);
            }
        }
    }
    Integer[] ret = new Integer[list.size()];
    list.toArray(ret);
    return ret;
}

public static int removeDuplicates2(Integer[] nums) {
    int n = nums.length;
    if (n == 0) {
        return 0;
    }
    int fast = 1, slow = 1;
    while (fast < n) {
        if (nums[fast] != nums[fast - 1]) {
            nums[slow] = nums[fast];
            ++slow;
        }
        ++fast;
    }
    return slow;
}

public static int strStr(String haystack, String needle) {
    if(haystack == null || !haystack.contains(needle)){
        return -1;
    }
    if(needle == ""){
        return 0;
    }
 
    int strLg = haystack.length();
    int findLg = needle.length();
    for (int i = 0; i < strLg; i++) {
        char c = haystack.charAt(i);
        if (c == needle.charAt(0) && i+findLg <= strLg){
            String temp = haystack.substring(i,i + findLg);
            if (temp.equals(needle)){
                return i;
            }
        }
    }
    return -1;
}

public static int strStr(String haystack, String needle) {
    int strLg = haystack.length();
    int findLg = needle.length();
    for (int i = 0; i+findLg <= strLg; i++) {
        boolean flag = true;
        for (int j = 0; j < findLg; j++) {
            if (haystack.charAt(i+j)!=needle.charAt(j)){
                flag = false;
                break;
            }
        }
        if (true == flag){
            return i;
        }
    }
    return -1;
}