LeetCode217.存在重复元素~~~~~~917.仅仅反转字母~~~~~~977.有序数组的平方

LeetCode217.存在重复元素

给定一个整数数组，判断是否存在重复元素。

如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

• 示例 1:
  输入: [1,2,3,1]
  输出: true
• 示例 2:
  输入: [1,2,3,4]
  输出: false
• 示例 3:
  输入: [1,1,1,3,3,4,3,2,4,2]
  输出: true

class Solution {
    public boolean containsDuplicate(int[] nums) {
        /*
        解法1：
        for(int i=0;i<nums.length;i++){
            for(int j=0;j<i;j++){
                if(nums[j]==nums[i]){
                    return true;
                }
            }
        }
        return false;
        */
        /*
        解法2：
        Arrays.sort(nums);
        for(int i=0;i<nums.length-1;i++){
            if(nums[i]==nums[i+1]){
                return true;
            }
        }
        return false;
        */
        解法3：
        Set<Integer> set = new HashSet<>(nums.length);
    for (int x: nums) {
        if (set.contains(x)) return true;
        set.add(x);
    }
    return false;
    }
}

917.仅仅反转字母

给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。

• 示例 1：
  输入：“ab-cd”
  输出：“dc-ba”
• 示例 2：
  输入：“a-bC-dEf-ghIj”
  输出：“j-Ih-gfE-dCba”
• 示例 3：
  输入：“Test1ng-Leet=code-Q!”
  输出：“Qedo1ct-eeLg=ntse-T!”

class Solution {
    public String reverseOnlyLetters(String S) {
        char[] array=S.toCharArray();
        Stack<Character> letters = new Stack();
        for (char c: array)
            if (Character.isLetter(c))
                letters.push(c);

        StringBuilder ans = new StringBuilder();
        for (char c: array) {
            if (Character.isLetter(c))
                ans.append(letters.pop());
            else
                ans.append(c);
        }

        return ans.toString();
        //StringBuilder叫字符串缓存区对象,使用时可以不断添加字符、字符串等已有内容。
        //需要使用时调用toString()获得对象里的所有字符串

		//思路：将 s 中的所有字母单独存入栈中，所以出栈等价于对字母反序操作。（或者，可以用数组存储字母并反序数组。）
		//然后，遍历 s 的所有字符，如果是字母我们就选择栈顶元素输出。

    }
}

977.有序数组的平方

给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

• 示例 1：
  输入：[-4,-1,0,3,10]
  输出：[0,1,9,16,100]

• 示例 2：
  输入：[-7,-3,2,3,11]
  输出：[4,9,9,49,121]

• 提示：
  1 <= A.length <= 10000
  -10000 <= A[i] <= 10000
  A 已按非递减顺序排序。

//解法1：
//思路：排序--创建一个新的数组，它每个元素是给定数组对应位置元素的平方，然后排序这个数组。
class Solution {
    public int[] sortedSquares(int[] A) {
       int N = A.length;
        int[] ans = new int[N];
        for (int i = 0; i < N; ++i)
            ans[i] = A[i] * A[i];

        Arrays.sort(ans);
        return ans;
    }
}
//时间复杂度：O(NlogN)，其中 N 是数组 A 的长度。
//空间复杂度：O(N)。


//解法2：
//我们可以使用两个指针分别读取数组的非负部分与负数部分
//指针 i 反向读取负数部分，指针 j 正向读取非负数部分。

//那么，现在我们就在使用两个指针分别读取两个递增的数组了（按元素的平方排序）。
//接下来，我们可以使用双指针的技巧合并这两个数组。

 class Solution {
    public int[] sortedSquares(int[] A) {
        int N = A.length;
        int j = 0;
        while (j < N && A[j] < 0)
            j++;
        int i = j-1;

        int[] ans = new int[N];
        int t = 0;

        while (i >= 0 && j < N) {
            if (A[i] * A[i] < A[j] * A[j]) {
                ans[t++] = A[i] * A[i];
                i--;
            } else {
                ans[t++] = A[j] * A[j];
                j++;
            }
        }

        while (i >= 0) {
            ans[t++] = A[i] * A[i];
            i--;
        }
        while (j < N) {
            ans[t++] = A[j] * A[j];
            j++;
        }
    	return ans;
    }
}