数组交集

package baseMethod.algorithm.searchForm;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

public class Intersect {
    //nums1 = [1,2,2,1], nums2 = [2,2]
    //输出：[2,2]
    @Test
    public void run() {
/*        int[] nums1 = {4, 4, 8, 9, 5, 7};
        int[] nums2 = {4, 4, 8, 9, 9, 1, 2};*/
        int[] nums1 = {1,2,2,1,2}; int nums2[] = {2,2,1};
        //4 4 9
        System.out.println(Arrays.toString(intersect(nums1, nums2)));
        System.out.println(Arrays.toString(inter(nums1, nums2)));
        System.out.println(Arrays.toString(interSet(nums1, nums2)));
    }

    public int[] intersect(int[] nums1, int[] nums2) {
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int length1 = nums1.length, length2 = nums2.length;
        int[] intersection = new int[Math.min(length1, length2)];
        System.out.println(intersection.length);
        int index1 = 0, index2 = 0, index = 0;
        while (index1 < length1 && index2 < length2) {
            if (nums1[index1] < nums2[index2]) {
                index1++;
            } else if (nums1[index1] > nums2[index2]) {
                index2++;
            } else {
                intersection[index] = nums1[index1];
                index1++;
                index2++;
                index++;
            }
        }
        return Arrays.copyOfRange(intersection, 0, index);
    }

    public int[] inter(int[] nums1,int[] nums2){
        sort(nums1);
        sort(nums2);
        int[] interInts = new int[Math.min(nums1.length,nums2.length)];
        int length1 = nums1.length;
        int length2 = nums2.length;
        int index1=0;
        int index2=0;
        int indexInter=0;
        while (index1<length1&&index2<length2){
            //nums2[0]=4,nums1[0]=1
            //nums1[0]<nums[0]
            //获取nums1下一位比较大值
            if (nums1[index1]>nums2[index2]) {
                index2++;
            }
            else if (nums1[index1]<nums2[index2]) {
                index1++;
            }else {
                //当nums1[2]=4,nums2[0]=4 相等时
                //交集索引改变，同时nums1和nums2的索引也各自后移一位，表示已使用
                 interInts[indexInter]=nums1[index1];
                 indexInter++;
                 index1++;
                 index2++;
            }
        }
       return Arrays.copyOfRange(interInts,0,indexInter);
    }
    public void sort(int[] nums) {
        int temp;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }

    public int doublePointer(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        while (right >= left) {
            int pivot = left + (right - left) / 2;
            if (nums[pivot] == target) {
                return nums[pivot];
            } else if (nums[pivot] > target) {

                right = pivot - 1;
            } else {
                left = pivot + 1;
            }
        }

        return -1;
    }
    //java8的交集过滤器的问题
    //只能在set使用,意义上不是交集关系，而是被包含的关系
    public int[] interSet(int[] nums1,int[] nums2){
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        for (int i : nums1) {
            list1.add(i);
        }
        for (int i : nums2) {
            list2.add(i);
        }
        //这种部署求交集，而是求在数组1里面包含多少个数组2元素的集合,list是集合组合求
        //要是set就可以
        List<Integer> filterList = list1.stream().filter(e -> list2.contains(e)).collect(Collectors.toList());
        Set<Integer> filterSet2 = list1.stream().filter(e -> list2.contains(e)).collect(Collectors.toSet());
        //List，由于是包含和被包含关系，会出现重复元素
        int[] returnInts = new int[filterList.size()];
        for (int i = 0; i < returnInts.length; i++) {
            returnInts[i]=filterList.get(i);
        }
        int[] returnIntsSet = new int[filterSet2.size()];
        //Set，在Set使用更像是交集
        int index=0;
        for (Integer integer : filterSet2) {
            returnIntsSet[index]=integer;
            index++;
        }
//        return  returnIntsSet;
        return  returnInts ;
    }
}

3个数组
3组索引
交集的容量，在最小数组之下，
为什么排序？
：排序后两数组的值比较，只有三种情况大于小于等于，排序后值比较可以更好索引后移遍历数组
在值相等时候获取交集。
新建获取最小的容量的数组
获取三组数组的边界索引
在边界索引区间中，对交集的两个数组遍历获取索引
边界动态变化，跳出循环的条件是边界之内
获取值是否相等
条件包括大于小于等于的值对比
比如数组1的0索引大于数组2的0索引会怎样？
：如果数组1索引的值大于数组2索引的值，数组2的索引后移一位进行遍历
等等意味着两个交集获得相等的值，应该存到交集的数组中去，同时原数组的索引也要后移一位，不能重复消费
最后截取符合长度的新数组