Java习题总结------1

1、

分析：当时间序列只有一个时间点时，中毒时间总和就是一次中毒时间长度、当两个时间点之间的时间差小于一次中毒时间时那么这一段时间就是中毒时间，如果两个时间点的时间差大于中毒时间，那么中毒时间就是中毒时间。

代码

import java.util.Scanner;
class Demo_36{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int[] getTimeSeries=new int[10000];
        int i=0;
        System.out.println("请输入时间序列，0为结束：");
        while(true){//从键盘获取时间序列
            getTimeSeries[i]=scanner.nextInt();
            if(getTimeSeries[i]==0)break;//如果输入0，则表示时间序列结束。
            i++;
        }
        int[] timeSeries=new int[i];
        for(int j=0;j<i;j++){//将从键盘获得的时间序列存入timeSeries中
            timeSeries[j]=getTimeSeries[j];
        }
        int duration;
        System.out.print("请输入中毒持续时间：");
        duration=scanner.nextInt();
        System.out.println("中毒总时长为："+findPoisoneDuration(timeSeries,duration));
    }
    public static int findPoisoneDuration(int[] timeSeries,int duration){
        if(timeSeries.length==1)return duration;
        int sum=0;//存中毒时间
        for(int i=1;i<timeSeries.length;i++){
            if(timeSeries[i]-timeSeries[i-1]<duration)sum+=(timeSeries[i]-timeSeries[i-1]);
            else sum+=duration;
        }
        return sum;
    }
}

2、

分析：采用两个指针，一个用来遍历原数组，一个用来在原数组上进行修改，已知原数组是排好序的，那么使用i来遍历数组，j来修改数组，定义一个middle初始为第一个数，用来存当前相同的数。原数组第一个元素不变，从第二个元素开始如果第二个元素等于middle那么i向后，如果第二个元素不等于middle那么就将middle变为第二个元素，原数组第j个元素变为当前元素，j++ …

代码

class Demo_37{
    public static void main(String[] args){
        int[] nums={0,0,1,1,1,2,2,3,3,4};
        System.out.println("数组新长度为："+removeDuplicates(nums));
    }
    public static int removeDuplicates(int[] nums){
        if(nums.length==1){
            return 1;
        }
        int middle=nums[0];
        int j=1;
        for(int i=1;i<nums.length;i++){
            if(nums[i]!=middle){
                nums[j]=nums[i];
                j++;
                middle=nums[i];
            }
        }
        return j;
    }
}

3、

分析：动态滑窗问题

代码

class Demo_38{
    public static void main(String[] args){
        int[] nums={2,3,1,2,4,3};
        int s=7;
        System.out.println("长度最小连续子数组长为："+minSubArrayLen(s,nums));
    }
    public static int minSubArrayLen(int s,int[] nums){
        int length=Integer.MAX_VALUE;
        for(int i=0;i<nums.length;i++){
            int sum=0;
            int j;
            for(j=i;j<nums.length;j++){
                sum+=nums[j];
                if(sum>=s)break;
            }
            if(j-i<length)length=j-i;
        }
        return length+1;
    }
}

4、
代码

import java.util.*;
class Demo_39{
    public static void main(String[] args){
        String[] words={"gin","zen","gig","msg","h"};
        System.out.println("不同密码数为："+uniqueMorseRepresentations(words));
    }
    public static int uniqueMorseRepresentations(String[] words){
        String[] morse={".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
        String[] wordsMorse=new String[words.length];
        for(int i=0;i<words.length;i++){
            for(int j=0;j<words[i].length();j++){
                wordsMorse[i]+=morse[words[i].charAt(j)-'a'];
            }
        }
        int nums=1;
        for(int k=1;k<wordsMorse.length;k++){
            int t;
            for(t=0;t<k;t++){
                if(wordsMorse[k].equals(wordsMorse[t])){
                    break;
                }
            }
            if(t==k){
                nums+=1;
            }
        }
        return nums;
    }
}

5、

class Demo_40{
    /*
    我们可以发现顺时针就是先向右，后向下，后向左，后向上，再向右......
    */
    public static void main(String[] args){
        int[][] matrix={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
        int[] a=spiralOrder(matrix);
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
    public static int[] spiralOrder(int[][] matrix){
        int[] nums=new int[matrix.length*matrix[0].length];
        int flag=0;//标记，表示遍历二维数组的方向，初始为0，表示向右
        int rightEnd=matrix[0].length;//第一次向右最右元素列下标+1
        int downEnd=matrix.length-1;//第一次向下最下元素行下标
        int liftEnd=0;//第一次向左最左元素列下标
        int upEnd=1;//第一次向上最上元素行下标
        int row=0;//初始行为0
        int col=0;//初始列为0
        for(int i=0;i<matrix.length*matrix[0].length;i++){//需要循环总元素个数次
            switch(flag%4){
                case 0://向右
                    nums[i]=right(matrix,row,col);
                    col+=1;
                    if(col==rightEnd){
                        flag+=1;
                        rightEnd-=1;
                        col-=1;
                    }
                    break;
                case 1://向下
                    row+=1;
                    nums[i]=down(matrix,row,col);
                    if(row==downEnd){
                        flag+=1;
                        downEnd+=1;
                    }
                    break;
                case 2://向左
                    col-=1;
                    nums[i]=lift(matrix,row,col);
                    if(col==liftEnd){
                        flag+=1;
                        liftEnd+=1;
                    }
                    break;
                case 3://向上
                    row-=1;
                    nums[i]=up(matrix,row,col);
                    if(row==upEnd){
                        flag+=1;
                        upEnd-=1;
                        col+=1;
                    }
                    break;
            }
        }
        return nums;
    }
    public static int right(int[][] matrix,int row,int col){//二维数组向右读取
        return matrix[row][col];
    }
        public static int down(int[][] matrix,int row,int col){//二维数组中向下读取
        return matrix[row][col];
    }
        public static int lift(int[][] matrix,int row,int col){//二维数组中向左读取
        return matrix[row][col];
    }
        public static int up(int[][] matrix,int row,int col){//二维数组中向上读取
        return matrix[row][col];
    }
}