二刷Leetcode-Days05

字符串：

    /**
     * 541. 反转字符串 II
     * @param s
     * @param k
     * @return
     */
    public String reverseStr(String s, int k) {
        StringBuilder res = new StringBuilder();
        int length = s.length();
        int start = 0;
        while (start < length) {
            // 找到k处和2k处
            StringBuilder temp = new StringBuilder();
            // 与length进行判断，如果大于length了，那就将其置为length
            int first = (start + k > length) ? length : start + k;
            int second = (start + 2 * k > length) ? length : start + 2 * k;
            // 无论start所处位置，至少会反转一次
            temp.append(s, start, first);
            res.append(temp.reverse());
            // 如果firstK到secondK之间有元素，这些元素直接放入res里即可。
            if (first < second) {
                // 此时剩余长度一定大于k。
                res.append(s, first, second);
            }
            start += (2 * k);
        }
        return res.toString();
    }

    // 其实就是每隔k个反转k个
    public String reverseStr2(String s, int k) {
        char[] ch = s.toCharArray();
        // 1. 每隔 2k 个字符的前 k 个字符进行反转
        for (int i = 0; i< ch.length; i += 2 * k) {
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= ch.length) {
                reverse(ch, i, i + k -1);
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转
            reverse(ch, i, ch.length - 1);
        }
        return  new String(ch);

    }
    
    // 定义翻转函数
    public void reverse(char[] ch, int i, int j) {
        for (; i < j; i++, j--) {
            char temp = ch[i];
            ch[i] = ch[j];
            ch[j] = temp;
        }
    }

双指针：

    /**
     * 344. 反转字符串
     * @param s
     */
    public void reverseString(char[] s) {
        int left = 0;
        int right = s.length - 1;
        // 左闭右闭区间，所以right=s.length-1
        while (left <= right) {
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        }
    }

    public static void reverseString2(char[] s) {
        int l = 0;
        int r = s.length - 1;
        while (l < r) {
            s[l] ^= s[r];  //构造 a ^ b 的结果，并放在 a 中
            s[r] ^= s[l];  //将 a ^ b 这一结果再 ^ b ，存入b中，此时 b = a, a = a ^ b
            s[l] ^= s[r];  //a ^ b 的结果再 ^ a ，存入 a 中，此时 b = a, a = b 完成交换
            l++;
            r--;
        }
    }

栈与队列：

    /**
     * 225. 用队列实现栈
     */
    class MyStack {
        // 和栈中保持一样元素的队列
        private Queue<Integer> queue1;
        // 辅助队列
        private Queue<Integer> queueAssitant;

        public MyStack() {
            queue1 = new LinkedList<>();
            queueAssitant = new LinkedList<>();
        }

        public void push(int x) {
            // 先放在辅助队列中
            queueAssitant.offer(x);
            while (!queue1.isEmpty()){
                queueAssitant.offer(queue1.poll());
            }
            Queue<Integer> queueTemp = queue1;
            queue1 = queueAssitant;
            // 最后交换queue1和queue2，将元素都放到queue1中
            queueAssitant = queueTemp;
        }

        public int pop() {
            // 因为queue1中的元素和栈中的保持一致，所以这个和下面两个的操作只看queue1即可
            return queue1.poll();
        }

        public int top() {
            return queue1.peek();
        }

        public boolean empty() {
            return queue1.isEmpty();
        }
    }

// 排序算法：堆排序、归并排序、快排