复杂度介绍
算法导论给出的解释:大O用来表示上界的,当用它作为算法的最坏情况运行时间的上界,就是对任意数据输入的运行时间的上界。
递归算法的时间复杂度本质上是要看: 递归的次数 * 每次递归中的操作次数。
递归算法的空间复杂度 = 每次递归的空间复杂度 * 递归深度
**那么思考一下 什么时候空间复杂度是 O(logn)呢? 递归 **
// 版本二
int fibonacci(int first, int second, int n) {
if (n <= 0) {
return 0;
}
if (n < 3) {
return 1;
}
else if (n == 3) {
return first + second;
}
else {
return fibonacci(second, first + second, n - 1);
}
}
相当于从头加,用first和second来记录当前的两个数值,而不是重复计算同样的值。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
int fibonacci(int i) {
if(i <= 0) return 0;
if(i == 1) return 1;
return fibonacci(i-1) + fibonacci(i-2);
}
时间复杂度为O(2^n),大量重复计算。空间复杂度就是O(n)。(递归深度为O(n))
数组
704. 二分查找
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1
初步
class Solution {
public int search(int[] nums, int target) {
int low = 0;
int high = nums.length-1;
int mid = (high+low)/2;
while(low <= high){
if (target == nums[mid]) {
return mid;
}else if(target < nums[mid]) {
high = mid-1;
}else {
low = mid+1;
}
mid = (high+low)/2;
}
return -1;
}
}
Q1: 最开始的想法是
high = mid;
}else {
low = mid;
}
mid = (high+low)/2;
当low/high相邻时,此时因为 low/high 会陷入等于mid不变的bug,不能正确对比和变化。
27. 移除元素
给你一个数组 nums
和一个值 val
,你需要 原地 移除所有数值等于 val
的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1)
额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素
暴力解法
最开始只想到了暴力解法,还有很多问题比如数组越界访问和覆盖后原位置不再次检测的bug。
class Solution {
public int removeElement(int[] nums, int val) {
int length = nums.length;
for(int i = 0; i <= length-1; i++){
if(nums[i] == val){
for (int j= i; j <= length-2; j++){
nums[j] = nums[j+1];
}
length--;//新长度防止越界
i--;//回到覆盖移动后的本位置继续检测
}
}
return length;
}
}
Q:第一层循环遇到目标值,每次都依次覆盖后面的值而且不管值是什么,双层循环时间复杂度过高O(n^2),有没有一种办法让一次循环解决问题?可采用扫描并填充的方式,即快慢指针。
- 时间复杂度:O(n^2)
- 空间复杂度:O(1)
双指针法 (20:30)
class Solution {
public int removeElement(int[] nums, int val) {
int slow = 0;
for(int fast = 0; fast<= nums.length-1; fast++) {
if (nums[fast] != val) {
nums[slow++] = nums[fast];
}
}
return slow;
}
}
- 时间复杂度:O(n)
- 空间复杂度:O(1)
虽然双指针法解决了两次循环,并避免了移动不需要的值。但是他仍然移动了需要保留的值,还有一种方法可以在最小程度移动值。
双指针优化(20:52)
第一版:
class Solution {
public int removeElement(int[] nums, int val) {
int left = 0;
int right = nums.length - 1;
while(left <= right) {
while(left <= right && nums[left] != val ) {
++left;//找到左侧需要被替换的值
}
while(left <= right && nums[right] == val ) {
--right;//找到右侧替换的候选值
}
if(left <= right){
nums[left++] = nums[right--];
}
}
return left;
}
}
bug:
nums[right] == val && left <= right
right存在负值情况,如果先判断前面则出现越界!!!
官方:
class Solution {
public int removeElement(int[] nums, int val) {
int left = 0;
int right = nums.length-1;
while (left <= right) {
if (nums[left] == val) {
nums[left] = nums[right];
right--;
} else {
left++;//所有的都更换,不管右侧是否为需要被替换的,一个位置多次替换
}
}
return left;
}
}
977. 有序数组的平方
给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。
1.无脑暴力法
采用了最简单暴力的解法,先平方,再排序,排序采用最垃圾的算法。
class Solution {
public int[] sortedSquares(int[] nums) {
for (int i = 0; i<=nums.length-1 ; i++){
nums[i] = nums[i]*nums[i];
}
for (int i = 0; i<=nums.length-1; i++){
for(int j = i; j<= nums.length-1; j++){
if(nums[i]>nums[j]){
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}
}//或者快速排序,O(nlogn)的时间复杂度。
}
return nums;
}
}
时间复杂度为耗时的垃圾排序O(n^2+n),空间复杂度为O(1)。
此时,没有利用到题中已经进行过非递减排序的条件,因为最大的值一定在两端且按照大小分别进行正反向排序,所以可以利用双指针法。
2.双指针法
class Solution {
public int[] sortedSquares(int[] nums) {
int left = 0;
int right = nums.length-1;
int[] result = new int[nums.length];
for(int i = nums.length-1;left<=right; i--){
if(nums[right]*nums[right]>nums[left]*nums[left]){
result[i] = nums[right]*nums[right--];
}
else {
result[i] = nums[left]*nums[left++];
}
}
return result;
}
}
时间复杂度为O(n),空间复杂度O(n)。
代码随想录版本(使用while循环):
class Solution {
public int[] sortedSquares(int[] nums) {
int left = 0;
int right = nums.length - 1;
int[] result = new int[nums.length];
int index = result.length - 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;
}
}
209. 长度最小的子数组
暴力解法:简简单单超个时
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int min = 0;
int length = 0;
for(int i = 0; i<= nums.length-1; i++) {
int sum = 0;
for(int j= i;j<= nums.length-1;j++) {
sum = sum + nums[j];
length = j - i + 1;
if(sum >= target && (length<=min || min==0)) {
min = length;
break;
}
}
}
return min;
}
}
时间复杂度O(n^2),且是所有情况都双层遍历相加,有大量的重复加法,当数据量较大时,时间过长。
双指针法:滑动窗口
可以利用连续子数组这个特征,通过两个指针,操作头尾数,来减少重复计算。
第一版:
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int min = 0;
int fast = 0;
int slow = 0;
int sum = 0;
while(fast <= nums.length-1) {
sum = sum + nums[fast];
if(sum >= target){
while(sum - nums[slow] >= target) {
sum = sum - nums[slow];
slow++;
}
if(min == 0 || fast - slow + 1 < min) {
min = fast - slow + 1;
}
}
fast++;
}
return min;
}
}
优化版本:
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int min = 0, fast = 0, slow = 0, sum = 0;
while(fast<=nums.length-1) {
sum = sum +nums[fast];
while(sum>=target) {
if(min == 0 ||fast - slow + 1 < min){
min = fast - slow + 1;
}
sum = sum - nums[slow++];
}
fast++;
}
return min;
}
}
时间复杂度是O(n),每个元素在滑动窗后进来操作一次,出去操作一次,每个元素都是被操作两次,所以时间复杂度是 2 × n 也就是O(n)。
长度最小的子数组.html#相关题目推荐相关题目推荐通过滑动的窗口,只进行左右两个值的计算,避免了大量重复运算。
59. 螺旋矩阵 II
给定一个正整数 n,生成一个包含 1 到 n^2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
最直观的方法:绕圈
class Solution {
public int[][] generateMatrix(int n) {
int [][] result = new int[n][n];
int index =2 ;
int num = n*n;
int row = 0;
int column =0;
result[0][0]=1;
while(index <= num){
while(column< n-1 && result[row][column+1] == 0){
result[row][++column] = index++;//看下一个需要填充的位置,如果判断本位置当在拐角时已经被填充,无法进入循环。
}
while(row< n-1 && result[row+1][column] == 0){
result[++row][column] = index++;
}
while(column >0 && result[row][column-1] == 0){
result[row][--column] = index++;
}while(row>0 && result[row-1][column] == 0){
result[--row][column] = index++;
}
}
return result;
}
}
时间复杂度:O(n^2),空间复杂度:O(1)
按层次填充
class Solution {
public int[][] generateMatrix(int n) {
int num = 1;
int[][] matrix = new int[n][n];
int left = 0, right = n - 1, top = 0, bottom = n - 1;
while (left <= right && top <= bottom) {
for (int column = left; column <= right; column++) {//小细节,column<=right
matrix[top][column] = num;
num++;
}
for (int row = top+1; row <= bottom-1; row++) {
matrix[row][right] = num;
num++;
}
for (int column = right; column >= left+1; column--) {
matrix[bottom][column] = num;
num++;
}
for (int row = bottom; row >= top+1; row--) {
matrix[row][left] = num;
num++;
}
left++;
right--;
top++;
bottom--;
}
return matrix;
}
}
Bug: column <= right 这种相似条件必须在四个for中至少出现一个,因为当n为奇数时,最后左右上下相等,必须存在一个合理的条件来赋值。
时间复杂度:O(n^2),空间复杂度:O(1)