剑指Offer-学习计划（四）双指针（下）

剑指 Offer 57. 和为s的两个数字

剑指 Offer 58 - I. 翻转单词顺序

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

题目一：调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4] 
注：[3,1,2,4] 也是正确的答案之一。

 解法一：先获取奇数的数量，之后遍历判断偶数放在后面，奇数正常放 O(n)的时间复杂度 

public int[] exchange1(int[] nums) {
        int len = nums.length;
        int[] arr = new int[len];
        int ji = 0;
        for (int i = 0; i < len; i++) {
            if (nums[i] % 2 == 1) ji++;
        }
        int index = 0;
        int index2 = 0;
        for (int i = 0; i < len; i++) {
            if (nums[i] % 2 == 1) {
                arr[index++] = nums[i];
            } else {
                arr[ji + index2++] = nums[i];
            }
        }
        return arr;
    }

解法二：双指针不失为一种好评解法，第一个指针从0开始第二个从最后一个位置开始

public int[] exchange2(int[] nums) {
        int len = nums.length;
        int[] arr = new int[len];
        int left = 0, right = len - 1;
        for (int i = 0; i < len; i++) {
            if (nums[i] % 2 == 1) {
                arr[left++] = nums[i];
            } else {
                arr[right--] = nums[i];
            }
        }
        return arr;
    }

解法三：和解法一类似，但是可读性更好一些，拆开来做奇偶数判断

public int[] exchange3(int[] nums) {
        int index = 0;
        int[] arr = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] % 2 == 1) {
                arr[index] = nums[i];
                index += 1;
            }
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] % 2 == 0) {
                arr[index] = nums[i];
                index += 1;
            }
        }
        return arr;
    }

题目二：

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]
示例 2：

输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]

 解法一：很像二分查经典，其实就是个双指针

 public int[] twoSum(int[] nums, int target) {
        int low = 0, high = nums.length-1;
        while (low <= high){
            int sum = nums[low] + nums[high];
            if (sum < target){
                low++;
            }else if (sum>target){
                high--;
            }else {
                return new int[]{nums[low],nums[high]};
            }
        }
        return new int[]{};
    }

题目三：

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. "，则输出"student. a am I"。

示例 1：

输入: "the sky is blue"
输出: "blue is sky the"
示例 2：

输入: "  hello world!  "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：

输入: "a good   example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

解法一：使用StringBuilder 拼接字符串即可 

public String reverseWords(String s) {
        StringBuilder buffer = new StringBuilder();
        s = s.trim();
        String[] arrStr = s.split(" ");
        for (int i = arrStr.length-1; i >=0; i--) {
            if (!arrStr[i].equals("")){
                buffer.append(arrStr[i]).append(" ");
            }
        }
        return buffer.toString().trim();
    }

 解法二：经典双指针用法，去掉收尾的空白字符，

public String reverseWords(String s) {
        int left = 0, right = s.length() - 1;
        // 去掉字符串开头的空白字符
        while (left <= right && s.charAt(left) == ' ') {
            ++left;
        }

        // 去掉字符串末尾的空白字符
        while (left <= right && s.charAt(right) == ' ') {
            --right;
        }

        Deque d = new ArrayDeque();
        StringBuilder word = new StringBuilder();
        
        while (left <= right) {
            char c = s.charAt(left);
            if ((word.length() != 0) && (c == ' ')) {
                // 将单词 push 到队列的头部
                d.offerFirst(word.toString());
                word.setLength(0);
            } else if (c != ' ') {
                word.append(c);
            }
            ++left;
        }
        d.offerFirst(word.toString());

        return String.join(" ", d);
    }