关于数组的一些简单方法案例及测试（一）

1.合并两个有序数组
2.最大子序列和
3.数组中的重复数字
4.找出所有重复元素
5.顺时针打印矩阵
6.在排序数组中查找数字
7. 0～n-1中缺失的数字

import java.util.*;

public class ArrayTest{
    //1.合并两个有序数组
/*    给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
    初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
    假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。*/
    public static void merge(int[] nums1, int m, int[] nums2, int n){
        //1.先把nums2的数据放在nums1中，然后对nums1进行排序
       /* for(int i=0;i<n;i++){
            nums1[i+m]=nums2[i];
        }
        //如果不调用sort函数，这里排序，可以使用数据结构的几种排序算法
        Arrays.sort(nums1);*/
       //2.定义中间数组nums存储有序数组nums1和nums2,然后把nums3的数据赋值给nums1
        int[] nums3=new int[m+n];
        int i=0,j=0;
        int num=0;
        while(i<m||j<n){
            if(i==m){
                num=nums2[j++];
            }else if(j==n){
                num=nums1[i++];
            }else if(nums1[i]<=nums2[j]){
                num=nums1[i++];
            }else{
                num=nums2[j++];
            }
            nums3[i+j-1]=num;

        }
        for(int g=0;g<m+n;g++){
            nums1[g]=nums3[g];
        }
    }
    //2.最大子序列和
    /*
    给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
     */
    public static int maxSubArray(int[] nums){
        /*1.
        假设sum<=0，那么后面的子序列肯定不包含目前的子序列，只会越加越小
        如果sum > 0对于后面的子序列是有好处的，
        maxSum=Math.max(sum,maxSum);保证可以找到最大的子序和。
        */
       /* int maxSum=nums[0];
        int sum=0;
        for (int num:nums
             ) {
            if(sum>=0)
                sum=sum+num;
            else
                sum=num;
            maxSum=Math.max(sum,maxSum);
        }
        return maxSum;*/
       //2.动态规划
        int maxSum=nums[0];
        int sum=0;
        for (int num:nums
             ) {
            sum=Math.max(num,num+sum);
            maxSum=Math.max(sum,maxSum);
        }
        return maxSum;
    }
    //3.数组中的重复数字
    /*
    在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。
    数组中某些数字是重复的，但不知道有几个数字重复了，
    也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
     */
    public static int findRepeatNumber(int[] nums){
        //1.利用在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内的条件,不会越界
      /*  int[] arr=new int[nums.length];
        for (int num:nums
             ) {
          arr[num]++;
          if(arr[num]>1)return num;
        }
        //没有重复元素返回-1
        return -1;*/
      //2.如果没有一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内的条件，可以利用集合
        HashSet<Integer> set=new HashSet<>();
        for (int num:nums
             ) {
            if(set.contains(num))return num;
                set.add(num);
        }
        return -1;

    }
    //4.找出所有重复元素
    public static int[] findNRepeatNumber(int[] nums){
      int[] arr=new int[nums.length/2];
        HashMap<Integer,Integer> map=new HashMap<>();
        for (int num:nums
             ) {
            if(map.containsKey(num)){
                map.put(num,map.get(num)+1);
            }else{
                map.put(num,1);
            }
        }
        Set entrySet=map.entrySet();
        Iterator it=entrySet.iterator();
        int i=0;
        while(it.hasNext()){
            Map.Entry entry=(Map.Entry)it.next();//获取集合中键值对映射
           int value=(int)entry.getValue();
           if(value>1){
               int key=(int)entry.getKey();
               arr[i++]=key;
           }

        }
        int[] arr1=new int[i];
        for (int j = 0; j <i ; j++) {
            arr1[j]=arr[j];
        }
        return arr1;
    }
    //5.顺时针打印矩阵
    /*
    输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
     */
    public static int[] spiralOrder(int[][] matrix){
        int left=0,right=matrix[0].length-1,top=0,low=matrix.length-1;
        int  m=matrix.length,n=matrix[0].length;
        int[]arr=new int[m*n];
        if(m==0)return new int[0];
        int index=0;
        while(index<m*n){
            for (int i =left; i <=right ; i++) {
                arr[index++]=matrix[top][i];
            }
            if(++top>low)break;
            for (int i = top; i <=low ; i++) {
                arr[index++]=matrix[i][right];
            }
            if(--right<left)break;
            for (int i=right;i>=left;i--){
                arr[index++]=matrix[low][i];
            }
            if(--low<top)break;
            for (int i = low; i>=top ; i--) {
                arr[index++]=matrix[i][left];
            }
            if(++left>right)break;;
        }
        return arr;


    }
    //6.在排序数组中查找数字
    /*
    统计一个数字在排序数组中出现的次数。
     */
    public static int search(int[] nums, int target){
       int left=0,right=nums.length-1;
       while(left<=right){
           int mid=(left+right)/2;
           if(nums[mid]>=target){
              right=mid-1;
           }else{
               left=mid+1;
           }
       }
       int count=0;
        for (int i = left; i <nums.length&&nums[i]==target ; i++) {

            count++;
        }
        return count;
    }
    //7. 0～n-1中缺失的数字
    /*
    一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。
    在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。
     */
    public static int missingNumber(int[] nums) {
        //nums[i]=i为右子数组缺数，nums[i]!=i为左子数组缺数
        int left=0,right=nums.length-1;
        while(right>=left)
        {
            int  mid=(left+right)/2;
            if(nums[mid]!=mid)
                right=mid-1;
            else
                left=mid+1;

        }
        return left;
    }
    public static void main(String[] args){
        //1.测试merge（）方法
        int[] nums1=new int[3+4];
        for (int i = 0; i < 4; i++) {
            nums1[i]=i+1;
        }
        int[] nums2=new int[]{2,5,6};
        ArrayTest.merge(nums1,4,nums2,3);
        for (int i = 0; i <7 ; i++) {
            System.out.print(nums1[i]+" ");
        }
        System.out.println();
        //---------------------------------
        //2.测试maxSubArray
       int[] nums = new int[]{-2,1,-3,4,-1,2,1,-5,4};
        System.out.println("数组最大子数组和："+ArrayTest.maxSubArray(nums));
        //3.测试findRepeatNumber方法
        System.out.println("数组的一个重复数:"+ArrayTest.findRepeatNumber(nums));
        //4.测试findNRepeatNumber方法
        int[] arr1 = new int[]{2,1,4,4,0,2,1,-5,4};
        int[] arr=ArrayTest.findNRepeatNumber(arr1);
        System.out.println("数组中所有重复数：");
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        //5.测试顺时针打印矩阵方法
        int[][] towArr=new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        int[] arr2=ArrayTest.spiralOrder(towArr);
        System.out.println("顺时针打印的数组：");
        for (int i = 0; i <arr2.length ; i++) {
            System.out.print(arr2[i]+" ");
        }
        //6.测试在排序数组中查找数字方法
        int[] arr3=new int[]{5,7,7,8,8,10};
        System.out.println();
        System.out.println("数字在数组的个数："+ArrayTest.search(arr3,8));
        //7. 0～n-1中缺失的数字
        int[] arr4=new int[]{0,1,3};
        System.out.println("缺失的数："+ArrayTest.missingNumber(arr4));
    }
}