算法刷题：[5.26]每日一题+快慢指针+合并区间

[5.26]每日一题+快慢指针+合并区间

一、每日一题：[leetcode:1190] 反转每对括号间的字串

（https://leetcode-cn.com/problems/reverse-substrings-between-each-pair-of-parentheses/）

题解一：栈或者双向队列，开始使用栈，发现最后还需要一次反转，于是使用双向队列

class Solution {
    public String reverseParentheses(String s) {
       LinkedList<Character> stack=new LinkedList<>();
        int i=0;
        char[] temp=s.toCharArray();
        while(i<temp.length){
            if(temp[i]!=')') stack.add(temp[i]);
            else{
                StringBuilder word=new StringBuilder();
                while(stack.peekLast()!='('){
                    word.append(stack.pollLast());
                }
                stack.pollLast();

                for(int j=0;j<word.length();j++){
                    stack.add(word.charAt(j));
                }
            }
            i++;
        }
        StringBuilder res=new StringBuilder();
        System.out.println(stack.toString());
        while(!stack.isEmpty()){
            res.append(stack.pop());
        }
        return res.toString();
    }
}

二、[leetcode:141] 环形链表

给定一个链表，判断链表中是否有环。

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null) return false;
        ListNode slow=head;
        ListNode fast=head;
        while(fast.next!=null&&fast.next.next!=null){
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast) return true;
        }
        return false;      
    }
}

三、[leetcode:202] 快乐数

编写一个算法来判断一个数 n 是不是快乐数

题解一：判断是否循环

图引用于：

作者：demigodliu
链接：https://leetcode-cn.com/problems/happy-number/solution/ha-xi-biao-kuai-man-zhi-zhen-kuai-le-shu-ghj4/
来源：力扣（LeetCode）

class Solution {
     public int getNext(int n) {
        int totalSum = 0;
        while (n > 0) {
            int d = n % 10;
            n = n / 10;
            totalSum += d * d;
        }
        return totalSum;
    }
    public boolean isHappy(int n) {
        int slowRunner = n;
        int fastRunner = getNext(n);
        while (fastRunner != 1 && slowRunner != fastRunner) {
            slowRunner = getNext(slowRunner);
            fastRunner = getNext(getNext(fastRunner));
        }
        return fastRunner == 1;
    }
}

四、[leetcode:876] 链表的中间结点

直接用快慢指针，当快指针到最后面的时候，慢的指针就正好在中间

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
}

五、[leetcode:56] 合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

解法一：先排序，然后再进行合并区间

要注意区间的边界问题！！！

public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]==o2[0]) return o1[1]-o2[1];
                return o1[0]-o2[0];
            }
        });
        System.out.println(Arrays.deepToString(intervals));
        List<int[]> merged = new ArrayList<int[]>();
        for (int i = 0; i < intervals.length; ++i) {
            int L = intervals[i][0], R = intervals[i][1];
            if (merged.size() == 0 || merged.get(merged.size() - 1)[1] < L) {
                merged.add(new int[]{L, R});
            } else {
                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], R);
            }
        }
        return merged.toArray(new int[merged.size()][]);

    }