算法刷题——数组Java语言

二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1

class Solution{
    public int search(int[]nums,int target){
        //避免当target小于nums[0]nums[nums.length-1]时多次循环运算
        if(target < nums[0]||target>nums[nums.length-1]){
            return -1;
        }
        int left=0,right=nums.lengtg-1;
        while(left<=right){
            int mid = left + ((right-left)>>1)//>>1即二进制右移两位=除以2
                if(nums[mid]==target)
                    return mid;
            else if(nums[mid]<target)
                left = mid + 1;
            else if(nums[mid]>target)
                right = mid - 1;
        }
        return -1;
    }
}

移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

暴力解法

class Soluttion{
    public int removeElement(int[]nums,int val){
        int sieze = nums.size();
        for(int i = 0; i < size; i++){
            if(nums[i] == var){//发现与要移除的元素相同，数组集体向前移动
                for(int j = i+1;j<size;j++){
                    nums[j-1]=nums[j];//往前移                }
            }
                i--;//下标都往前移了一位，所以i也想前移动一位
                size--;
        }
    }
}
快慢指针

class Solution{
    pubilc int removeElement(int[]nums,int val){
        int slowIndex = 0;
        for(int fastIndex=0;fastIndex < nums.lengeh; fastIndex++){
            if(nums[fastIndex]!=val){
                nums[slowIndex]=nums[fastIndex];
                sloeIndex++;
            }
        }
        return slowIndex;
    }
}

有序数组的平方

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

暴力排序

class Solution{
    public int[]sortedSquares(int[nums]){
        for(int i =0;i<nums.sieze();i++){
            nums[i]*=nus[i];
        }
        sort(nums.begin(),nums.end());
        return nums;
    }
}
双指针法

class Solution{
    public int[]sortedSqueares(int[]nums){
        int right = nums.length-1;
        int left = 0;
        int[]result = nuw int[nums.length];
        int index = result.lenth-1;
        while(left<=right){
            if(nums[left]*nums[left]>nums[right]*nums[right]){
                //正数的相对位置是不变的，需要调整的是负数平方后的相对位置
                result[index--]=nums[left]*nums[left];
                ++left;
            }else{
                result[index--]=nums[right]*nums[right];
                --right
            }
        }
        return result;
    }
}

长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

暴力解法

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX; // 最终的结果
        int sum = 0; // 子序列的数值之和
        int subLength = 0; // 子序列的长度
        for (int i = 0; i < nums.size(); i++) { // 设置子序列起点为i
            sum = 0;
            for (int j = i; j < nums.size(); j++) { // 设置子序列终止位置为j
                sum += nums[j];
                if (sum >= s) { // 一旦发现子序列和超过了s，更新result
                    subLength = j - i + 1; // 取子序列的长度
                    result = result < subLength ? result : subLength;
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};
滑动窗口

class Solution{
    public int minSubArrayLen(int s,int[]nums){
        int left=0;//滑动窗口起始位置
        int sum=0;//滑动窗口数值之和
        int result=Integer.Max_VALUE;//滑动窗口的长度
        for(int right=0;right<nums.length;right++){
            sum+=nums[right];
            while(sum>=s){//如果窗口值大于S即所给值时 窗口变大
                result=Math.min(result,right-left+1);
            }
        }
    }
​
}

螺旋矩阵

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;  // 控制循环次数
        int[][] res = new int[n][n];
        int start = 0;  // 每次循环的开始点(start, start)
        int count = 1;  // 定义填充数字
        int i, j;
​
        while (loop++ < n / 2) { // 判断边界后，loop从1开始
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {
                res[start][j] = count++;
            }
​
            // 模拟右侧从上到下
            for (i = start; i < n - loop; i++) {
                res[i][j] = count++;
            }
​
            // 模拟下侧从右到左
            for (; j >= loop; j--) {
                res[i][j] = count++;
            }
​
            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                res[i][j] = count++;
            }
            start++;
        }
​
        if (n % 2 == 1) {
            res[start][start] = count;
        }
​
        return res;
    }
}