代码随想录算法训练营day01|数组理论基础 704二分查找 27移除元素

xinrenne

已于 2023-07-26 13:34:55 修改

阅读量649

点赞数

文章标签：算法开发语言 java

于 2023-07-26 13:34:15 首次发布

本文链接：https://blog.csdn.net/xinrenne/article/details/131934401

版权

代码随想录算法训练营day01|数组理论基础 704二分查找 27移除元素

day01 数组理论基础 704二分查找 27移除元素

1.基础知识

1.1静态数组

数组下标都是从0开始的。
数组内存空间的地址是连续的

数组内的元素是连续存储的，所以数组中元素的地址，可以通过其索引计算出来，例如：

int[] array = {1,2,3,4,5}

知道了数组的数据起始地址 BaseAddress ，就可以由公式 BaseAddress + i * size 计算出索引 i 元素的地址

size 是每个元素占用字节，例如 int 占 4 ， double 占 8

空间占用

Java 中数组结构为
- 8 字节 markword
- 4 字节 class 指针（压缩 class 指针的情况）
- 4 字节数组大小（决定了数组最大容量是 2^{32} ）
- 数组元素 + 对齐字节（java 中所有对象大小都是 8 字节的整数倍[^12]，不足的要用对齐字节补足）
例如
```
int[] array = {1, 2, 3, 4, 5};
```
的大小为 40 个字节，组成如下
```
8 + 4 + 4 + 5*4 + 4(alignment)
```

在这里插入图片描述

随机访问性能

即根据索引查找元素，时间复杂度是 O(1)

1.2动态数组

Java: ArrayList

插入，遍历，删除，扩容

插入或删除性能

头部位置，时间复杂度是 O(n)

中间位置，时间复杂度是 O(n)

尾部位置，时间复杂度是 O(1) （均摊来说）

1.3二维数组

int[][] array = {
    {11, 12, 13, 14, 15},
    {21, 22, 23, 24, 25},
    {31, 32, 33, 34, 35},
};

内存图如下
在这里插入图片描述

二维数组占 32 个字节，其中 array[0]，array[1]，array[2] 三个元素分别保存了指向三个一维数组的引用
三个一维数组各占 40 个字节
它们在内层布局上是连续的
像Java是没有指针的，同时也不对程序员暴露其元素的地址，寻址操作完全交给虚拟机。

所以看不到每个元素的地址空间情况，这里我以Java为例，也做一个实验。
```
public static void test_arr() {
    int[][] arr = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}, {9,9,9}};
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    System.out.println(arr[3]);
}
```
输出的地址为：
```
[I@7852e922
[I@4e25154f
[I@70dea4e
[I@5c647e05
```
这里的数值也是16进制，这不是真正的地址，而是经过处理过后的数值了，我们也可以看出，二维数组的每一行头结点的地址是没有规则的，更谈不上连续。

1.4leetCode题

704二分查找

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

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9     
输出: 4       
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2     
输出: -1        
解释: 2 不存在 nums 中因此返回 -1

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

思路：有序数组，无重复元素，二分法

第一种写法：左闭右闭

class Solution {
   public int search(int[] nums, int target) {
       int left=0;
       int right=nums.length-1;
       while(left<=right){
           int mid=(left+right)>>>1;
           if(nums[mid]<target){
               left=mid+1;
           }else if(target<nums[mid]){
               right=mid-1;
           }else{
               return mid;
           }
       }
       return -1;
   }
}

第二种写法：左闭右开

class Solution {
   public int search(int[] nums, int target) {
       int left=0;
       int right=nums.length;
       while(left<right){
           int mid=(left+right)>>>1;
           if(nums[mid]<target){
               left=mid+1;
           }else if(target<nums[mid]){
               right=mid;
           }else{
               return mid;
           }
       }
       return -1;
   }
}

35.搜索插入位置

https://leetcode.cn/problems/search-insert-position/

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法

示例 1:

输入: [1,3,5,6], 5
输出: 2

示例 2:

输入: [1,3,5,6], 2
输出: 1

示例 3:

输入: [1,3,5,6], 7
输出: 4

示例 4:

输入: [1,3,5,6], 0
输出: 0

思路：找到情况和二分一样，找不到情况返回插入点 Java的返回结果：-(返回值+1)
第一种写法：和Java二分一样，改一下返回值

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left=0;
        int right=nums.length-1;
        while(left<=right){
            int mid=(left+right)>>>1;
            if(nums[mid]<target){
                left=mid+1;
            } else if(target<nums[mid]){
                right=mid-1;
            } else{
                return mid;
            }          
        }
       return left; 
    }
}

第二种写法：leftmost 返回≥target的最靠左的索引

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left=0;
        int right=nums.length-1;
        while(left<=right){
            int mid=(left+right)>>>1;
            if(target<=nums[mid]){
                right=mid-1;
            }else {
                left=left+1;
            }
    }
        return left;
   }
}

34. 在排序数组中查找元素的第一个和最后一个位置

力扣链接(opens new window)

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：你可以设计并实现时间复杂度为 $O(\log n)$ 的算法解决此问题吗？

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

思路：用leftmost和rightmost找

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int x=left(nums,target);
        int y=right(nums,target);
        if(x==-1||y==-1){
            return new int[]{-1,-1};
         }else{
            return new int[]{x,y};
         }  
    }       
    public int left(int[] a,int target){
        int left=0;
        int right=a.length-1;
        int candidate=-1;
        while(left<=right){
            int mid=(left+right)>>>1;
            if(target<a[mid]){
                right=mid-1;
            }else if(a[mid]<target){
                left=mid+1;
            }else{
                candidate=mid;
                right=mid-1;
             }
      }
      return candidate;
    }

     public int right(int[] a,int target){
        int left=0;
        int right=a.length-1;
        int candidate=-1;
        while(left<=right){
            int mid=(left+right)>>>1;
            if(target<a[mid]){
                right=mid-1;
            }else if(a[mid]<target){
                left=mid+1;
            }else{
                candidate=mid;
                left=mid+1;
             } 
      }
      return candidate;
    }   
}

27. 移除元素

力扣题目链接(opens new window)

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

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

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

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

你不需要考虑数组中超出新长度后面的元素。

暴力破解法：

// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        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;

    }
};

双指针法：

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

定义快慢指针

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

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

xinrenne

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营day01|数组理论基础 704二分查找 27移除元素

力扣链接(opens new window)给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。进阶：你可以设计并实现时间复杂度为Olog⁡nO(\log n)Ologn的算法解决此问题吗？输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]输入：nums = [5,7,7,8,8,10], target = 6。
复制链接

扫一扫