代码随想录 Day1 数组理论基础，704.二分查找，27.移除元素，977.有序数组的平方。

get_zhang_

已于 2024-11-05 22:54:03 修改

阅读量833

点赞数 26

CC 4.0 BY-SA版权

分类专栏：代码随想录训练营文章标签：算法 java 笔记

于 2024-11-05 00:13:53 首次发布

本文链接：https://blog.csdn.net/get_money_/article/details/143476517

代码随想录训练营专栏收录该内容

52 篇文章

订阅专栏

1.数组理论基础

数组是存放在连续内存空间上的相同类型数据的集合。

数组可以方便的通过下标索引的方式获取到下标对应的数据。

（1）数组下标都是从0开始的。

（2）数组内存空间的地址是连续的。

所以在删除或增添元素时，就难免要移动其他元素的地址。

数组的元素是不能删的，只能覆盖。

Java的二维数组每一行头节点的地址是没有规则的，可能是如下排列的方式：

[left,right)区间左边界是有意义可以取到的，右边界是取不到的。right初始化为num.length（因为right取不到，如果赋值为num.length-1就漏掉了最后一个值），然后在循环判断的时候left和right是不能相等的，left和right相等左闭右开区间中没有有效的值，然后在条件判断的时候，right的更新是middle，因为right是不可以取到的。

public class binary_search {
public int search_2(int[] nums, int target) {
        int left = 0;
        int right = nums.length;
        while (left < right) {//左闭右开
            int mid = left + (right - left) / 2;//两个整数相加可能导致它们的和超过 int 类型的最大值（Integer.MAX_VALUE），从而导致溢出。而先计算差值再除以 2 可以减少这种风险，因为差值通常比原始的 left 和 right 值小得多。
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] > target) {
                right = mid;//！！！
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
}

时间复杂度：O(log n)
空间复杂度：O(1)

2.移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

元素的顺序可以改变，不需要考虑数组中超出新长度后面的元素。

数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。

暴力解法

两层for循环，一个for循环遍历数组元素，第二个for循环更新数组。

public class remove_element {
    public int removeElement1(int[] nums, int val) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
}

时间复杂度：O(n^2)
空间复杂度：O(1)

双指针法

（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组。
慢指针：指向更新新数组下标的位置。

public class remove_element {
 public  int removeElement2(int []nums,int val){
        int slowIndex=0;
        for (int fastIndex=0;fastIndex<nums.length;fastIndex++){
            if (val!=nums[fastIndex]){
                nums[slowIndex++]=nums[fastIndex];
            }
        }
        return  slowIndex;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

3.有序数组的平方

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

暴力排序：每个数平方之后，排个序。

public class sorted_array_of_squares {
        public int[] sortedSquares1(int[] nums) {
            for (int i = 0; i < nums.length; i++) {
                nums[i] = nums[i] * nums[i];
            }
            Arrays.sort(nums);
            return nums;
        }
}

这个时间复杂度是 O(n + nlogn)，可以说是O(nlogn)的时间复杂度，但为了和下面双指针法算法时间复杂度有鲜明对比，我记为 O(n + nlog n)。

双指针法

数组其实是有序的，只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法了，i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

如动画所示：

public class sorted_array_of_squares {
   public  int[]sortedSquares2(int []nums){
            int l = 0;
            int r = nums.length - 1;
            int[] res = new int[nums.length];
            int j = nums.length - 1;
            while(l <= r){
                if(nums[l] * nums[l] > nums[r] * nums[r]){
                    res[j--] = nums[l] * nums[l++];
                }else{
                    res[j--] = nums[r] * nums[r--];
                }
            }
            return res;
        }
}

此时的时间复杂度为O(n)，相对于暴力排序的解法O(n + nlog n)还是提升不少的。

空间复杂度：O(1)。