算法的数组学习

package com.company;

import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // write your code here
        int[] num1={0,0,1,1,1,2,2,3,3,4};
        int[] num2={1,1,2};
        int[][] matrix={{1,2,3},{4,5,6},{7,8,9}};
        rotate2(matrix);
    }
    //删除排序数组中的重复项
    public static int removeDuplicates(int[] nums) {
        int length=nums.length-1;
        int start=nums[0];
        int count=1;
        for(int i=1;i<=length;i++){
            if (nums[i]!=start){
                start=nums[i];
                nums[count]=nums[i];
                count++;
            }
        }
        return count;
    }

    //买卖股票的最佳时机 II
    public static int maxProfit1(int[] prices) {
        //只有当上升的时候卖，下降的时候不卖，连续上升时，取最大，卖
        int total=0,index=0,length=prices.length;
        while (index<length){
            //股票下跌就一直找
            while (index <length-1&&prices[index]>=prices[index+1]){
                index++;
            }
            //股票上涨开始的值
            int min=prices[index];

            while (index <length-1&& prices[index]<=prices[index+1]){
                index++;
            }

            total +=prices[index++]-min;
        }
        return total;
    }

    public static int maxProfit2(int[] prices) {
        //手上有股票时    手上无股票时
        int[][] dp=new int [2][prices.length];
        int length=prices.length;
        dp[0][1]=-prices[0];
        dp[0][0]=0;
        for (int i=0;i<prices.length;i++){
            //有 没卖，卖
            dp[i][0]=Math.max(dp[i-1][1]+prices[i],dp[i-1][0]);
            //无 卖了 没买
            dp[i][1]=Math.max(dp[i-1][0]-prices[i],dp[i-1][1]);
        }
        return dp[length-1][0];
    }

    //旋转数组
    public static void rotateStr(int[] nums, int k) {

        int length=nums.length;
        int[] clone=nums.clone();

        //直接%
        for (int i=0;i<clone.length;i++){
            nums[(i+k)%length]=clone[i];
        }
    }

    //存在重复元素
    public static boolean containsDuplicate(int[] nums) {
        Set<Integer> set=new HashSet<Integer>();
        for (int i=0;i<nums.length;i++){
            if(!set.add(nums[i])){
                return true;
            }
        }
        return false;
    }

    //只出现一次的数字
    public static int singleNumber(int[] nums) {
        int num=0;
        Set<Integer> set=new HashSet<Integer>();
        for (int i=0;i<nums.length;i++){
             if (!set.add(nums[i])){
                 set.remove(nums[i]);
             }
        }
        for (int i:set){
            num=i;
        }
        return num;
    }
    //两个数组的交集 II
    public int[] intersect(int[] nums1, int[] nums2) {
        Map<Integer,Integer> map=new HashMap<Integer,Integer>();
        List<Integer> list=new ArrayList<Integer>();
        for(int i=0;i<nums1.length;i++){
            map.put(nums1[i],map.getOrDefault(nums1[i],0)+1);
        }

        for (int i=0;i<nums2.length;i++){
            if(map.get(nums2[i])!=0){
                map.put(nums2[i],map.get(nums2[i])-1);
                list.add(nums2[i]);
            }
        }
        int[] res=new int[list.size()];
        for (int i=0;i<list.size();i++){
            res[i]=list.get(i);
        }
        return res;
    }

    //加一
    public static int[] plusOne(int[] digits) {
        //如果对9有余，进行处理
        int length=digits.length;
        for (int i=length-1;i>0;i--){
            if(digits[i]!=9){
                digits[i]++;
                return digits;
            }else {
                digits[i]=0;
            }
        }
        int temp[] =new int[length+1];
        temp[0]=1;
        return temp;
    }

    //移动零
    public static void moveZeroes(int[] nums) {
        int index=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=0){
                nums[index++]=nums[i];
            }
        }
        while (index <nums.length){
            nums[index++]=0;
        }
    }

    //有效的数独
    public static boolean isValidSudoku(char[][] board) {
        int length=board.length;
        int[][] col=new int[length][length];
        int[][] row=new int[length][length];
        int[][] cell=new int[length][length];
        for (int i=0;i<length;i++){
            for (int j=0;j<length;j++){
                if (board[i][j]=='.'){
                    continue;
                }
                //当前格子数
                int num=board[i][j]-1-'0';
                //k是第几个格子
                int k=i/3*3+j/3;
                //查看
                if (col[i][num]!=0||row[j][num]!=0||cell[k][num]!=0){
                    return false;
                }
                col[i][num]=row[j][num]=cell[k][num]=1;
            }
        }
        return true;
    }
    //旋转图像
    public static void rotate1(int[][] matrix) {
        //使用上下交换
        int length=matrix.length;
        for(int i=0;i<length/2;i++){
            int temp[]=matrix[i];
            matrix[i]=matrix[length-1-i];
            matrix[length-1-i]=temp;
        }
        //对角线交换
        for (int i=0;i<length;i++){
            for (int j=i+1;j<length;j++){
                int temp=matrix[i][j];
                matrix[i][j]=matrix[j][i];
                matrix[j][i]=temp;
            }
        }
    }

    public static void rotate2(int[][] matrix) {
        int length=matrix.length;
        for (int i=0;i<length/2;i++){
            for (int j=i;j<length-i-1;j++){
                int temp=matrix[i][j];
                int m=length-j-1;
                int n=length-i-1;
                matrix[i][j]=matrix[m][i];
                matrix[m][i]=matrix[n][m];
                matrix[n][m]=matrix[j][n];
                matrix[j][n]=temp;
            }
        }
    }
}