JAVA 数据结构与算法 学习笔记1--数组

写在前面

最近找实习非常头疼甚至中途打电话给家里崩溃流泪，这是第一次真实感受到大学里面学的东西都非常浅显理论，加上自己又不是什么认真学习的人，基础非常薄弱不扎实，感觉自己一事无成。好担心面试以后被公司永久加入黑名单。因此决定把练习整理下来，这样可以更系统的掌握知识&复习
学习视频：https://www.bilibili.com/video/BV1sy4y1q79M?p=4

数组

一、基础知识
数组需要知道的概念：

1. 连续内存空间 +相同类型元素
2. 索引+元素
3. 访问：得到的元素，通过索引访问；搜索：找到这个元素，和索引没关系，从头到尾找。
4. 访问：O(1) 搜索：O(N) 插入：O(N) 删除：O(N)
5. 适合读，不适合写。读多写少

*数组需要掌握： 创建数组、添加元素、访问元素、修改元素、删除元素、遍历数组、查找元素、数组长度、数组排序

*对应的练习题：leetcode 485、283、27

二、JAVA基本操作

1. 创建数组的方法
   （1）已知数组内容创建

int[] a = {1,2,3);

int[] b = new int[]{1,2,3};

（2）已知数组长度

int[] c = new int[3];
for(int i=0;i<a.length;i++){
	c[i]=i+1;}

（3）不知道长度和内容——创建数组列表（要制定类型）

ArrayList<Integer> arr = new ArrayList<>();
for(int i=0;i<3;i++){
	arr.add(i+1);}

2. 添加元素O(1)
   推荐add。（默认添加在末尾）

   arr.add(索引，元素);
   

3. 访问元素O(1)
   直接用索引访问元素。

   arr.get(索引);
   

4. ArrayList更新O(1)

   arr.set(索引,要更改的值);
   

5. ArrayList删除元素O(n)

   arr.remove(元素)
   

6. 数组长度O(1)

   arr.length;
   

   arr.size();//ArrayList
   

7. 查找元素

   arr.contains(元素);//ArrayList
   

8. 数组排序

   Arrays.sort(c);
   

   Collections.sort(arr);//ArrayList
   

三、例题

1. 485 最大连续1的个数
   给定一个二进制数组， 计算其中最大连续 1 的个数。
   示例：
   输入：[1,1,0,1,1,1]
   输出：3
   解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.

//自己写的垃圾版本
class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
    ArrayList<Integer> arr = new ArrayList<>();
    int count = 0;
    int max=0;
    for(int i = 0; i<nums.length;i++){
    	if(nums[i]==1){
    	count+=1;}
        if(i==nums.length-1){
            arr.add(count);
    	    count=0;
        }else if(nums[i+1]!=1)	{
            arr.add(count);
    	    count=0;
        }	
}
for(int j =0;j<arr.size();j++){
    if(arr.get(j) > max){
        max=arr.get(j);
}    }
return max;
}
}

2. 283.移动零
   给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
   示例:
   输入: [0,1,0,3,12]
   输出: [1,3,12,0,0]

class Solution {
    public void moveZeroes(int[] nums) {
        int j = 0;
       for(int i = 0; i < nums.length ; i++){
           if(nums[i]!=0){
               nums[j++]=nums[i];
           }
       }
       for (;j<nums.length;j++){
           nums[j]=0;
       }
    }
}

3. 27. 移除元素

class Solution {
    public int removeElement(int[] nums, int val) {
        int j=0;
        int i=0;
        int number= nums.length;
        if(number==0){
            return j;
        }
       while(i<number){
            if(nums[i]!=val){
                nums[j++]=nums[i];
            }
            i++;
           
        } return j;
}}

88. 合并两个有序数组
    给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
    请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
    注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        ArrayList<Integer> arr = new ArrayList();
        int i = 0;
        int j = 0;
        while(i < m|| j<n){
            if(i==m)
            {
                arr.add(nums2[j]);
                ++j;
            }else if(j==n){
                arr.add(nums1[i]);
                ++i;
            }else if(nums1[i]>nums2[j])
            {
                arr.add(nums2[j]);
                ++j;
            }else{
                arr.add(nums1[i]);
                ++i;
            }
        }
        for(int number = 0; number<m+n;number++){
            nums1[number]=arr.get(number);
        }

    
    }
}

121. 买卖股票的最佳时机
     给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

class Solution {
    public int maxProfit(int[] prices) {
       int profit=0;
       int min =Integer.MAX_VALUE;
       for(int i = 0;i < prices.length;i++){
           if(prices[i]<min){
               min = prices[i];
           }else if(prices[i]-min>profit){
               profit = prices[i]-min;
           }
       }
        return profit;
    }
}