【算法】-- 【计算两个有序整型数组的交集、判断一个数组中数值是否连续相邻、求解数组中反序对的个数、如何求解最小三元组距离】

01 如何计算两个有序整型数组的交集

问题描述：假设两个含有n个元素的有序整型数组a和b，其中a1={1,5,9,10,12,13}， a2={2,3,5,10,15}，那么他们的交集{5,10}
方法：二路归并法

 public static ArrayList<Integer> mixed(int a1[],int a2[]){
        ArrayList<Integer> mix=new ArrayList<>();
        int l1=a1.length;
        int l2=a2.length;
        int i=0,j=0;
        while (i<l1&&j<l2){
            if (a1[i]==a2[j]){
                mix.add(a1[i]);
                i++;
                j++;
            }
            else if (a1[i]>a2[j])
                j++;
            else
                i++;
        }
        return mix;
    }

    public static void main(String[] args) {
        int []a1={1,5,9,10,12,13};
        int []a2={2,3,5,10,15};
        ArrayList<Integer> mixed = mixed(a1, a2);
        System.out.println(mixed);
    }

02 如何判断一个数组中数值是佛连续相邻的

问题描述：一个数组序列，元素取值可能是0~65535中的任意一个数，相同数值不会重复出现。0是例外，可以反复出现。设计一种算法，当从数组序列中随意选取5个数值，判断这5个数值是否连续相邻。

 public static Boolean isContinuous(int [] a){
        int n=a.length;
        int min=-1,max=-1;
        for (int i=0;i<n;i++){
            if (a[i]!=0){
                if (min>a[i]||-1==min){
                    min=a[i];
                }
                if (max<a[i]||-1==max){
                    max=a[i];
                }
            }
        }
        if (max-min>n-1){
            return false;
        }else
            return true;

    }

    public static void main(String[] args) {
        int array[]={8,7,5,0,6};
        if (isContinuous(array))
            System.out.println("数组是连续数组");
        else
            System.out.println("数组不是连续数组");
    }

03 如何求解数组中反序对的个数

问题描述：给定一个数组a，如果a[i]>a[j] ( i<j )，那么a[i] 与a[j] 被称为一个反序，例如：{5,4,3,2,1}

方法一：蛮力法

对数组的每一数字，遍历它后面的所有的数字，如果后面的数字比它小，那么就找到一个逆序对。

    public static int reversCount(int a[]){
        int n=a.length;
        int count=0;
        for (int i=0;i<n;i++){
            for (int j=i+1;j<n;j++){
                if (a[i]>a[j])
                    count++;
            }
        }
        return count;
    }


    public static void main(String[] args) {
        int a[]={5,4,3,2,1};
        System.out.println(reversCount(a));
    }

方法二：分治归并法

可以参考归并排序的方法。在归并排序的基础上额外使用一个计数器来记录逆序对的个数。

   public static int reverseCount=0;

    public static void merge(int array[],int begin,int mid,int end){
        int i,j,k,n1,n2;
        n1=mid-begin+1;
        n2=end-mid;
        int [] L=new int[n1];
        int [] R=new int[n2];
        for (i=0,k=begin;i<n1;i++,k++)
            L[i]=array[k];
        for (i=0,k=mid+1;i<n2;i++,k++)
            R[i]=array[k];
        for (k=begin,i=0,j=0;i<n1&&j<n2;k++){
            if (L[i]<R[i]){
                array[k]=L[i++];
            }else {
                reverseCount+=mid-i+1;
                array[k]=R[j++];
            }
        }
        if (i<n1){
            for (j=i;j<n1;j++,k++)
                array[k]=L[j];
        }
        if (j<n2){
            for (i=j;i<n2;j++,k++)
                array[k]=R[i];
        }

    }

    public static void merge_sort(int a[],int begin,int end){
        if (begin<end){
            int mid=(end+begin)/2;
            merge_sort(a,begin,mid);
            merge_sort(a,mid+1,end);
            merge(a,begin,mid,end);
        }
    }

    public static void main(String[] args) {
        int a[]={5,4,3,2,1};
        merge_sort(a,0,a.length-1);
        System.out.println(reverseCount);
    }

04 如何求解最小三元数组距离

问题描述：已知3个升序整数数组a[l]、b[m]和c[n]。请在3个数组中各找一个元素，使的组成三元组距离最短。
三元组的距离定义是：假设a[i]、b[j]、c[k]是一个三元数组，那么距离为Distance = max（|a[i] - b[j] |, | a[i] - c[k] | , | b[j] - c[k] |）;

方法一：蛮力法，就是分别遍历3个数组中的元素，分别求出它们的距离，然后从这里面找最小值。

    public static int max(int a,int b,int c){
        int max=a>b?a:b;
        return (max>c)?max:c;
    }


  public static int solvingViolence(int a[],int b[],int c[]){
        int minDist=max(a[0],b[0],c[0]);
        int dist=0;
        for (int i=0;i<a.length;i++){
            for (int j=0;j<b.length;j++){
                for (int k=0;k<c.length;k++){
                    dist=max(Math.abs(a[i]-b[j]),Math.abs(a[i]-c[k]),Math.abs(b[j]-c[k]));
                    if (minDist>dist)
                        minDist=dist;
                }
            }
        }

        return minDist;
    }
  public static void main(String[] args) {
        int a[]={3,4,5,6,7};
        int b[]={10,12,14,16,18};
        int c[]={20,22,23,25,26,30,34,37};

        System.out.println(solvingViolence(a,b,c));

    }

方法二：最小距离法
从三个数组的第一个元素开始，先求出它们的距离minDist，接着找出3个数组中当前元素的距离，若比mindist小，则把当前距离赋值给minDIst。以此类推，知道遍历完其中一个数组。

 public static int max(int a,int b,int c){
        int max=a>b?a:b;
        return (max>c)?max:c;
    }

    public static int min(int a,int b,int c){
        int min = a>b?b:a;
        return (min>c)?c:min;
    }

    public static int mindDistance(int a[],int b[],int c[]){
        int aLen=a.length;
        int bLen=b.length;
        int cLen=c.length;

        int curDist=0;
        int min=0;
        int minDist=Integer.MAX_VALUE;
        int i=0;
        int j=0;
        int k=0;

        while(true){
            curDist =max(Math.abs(a[i]-b[j]),Math.abs(a[i]-c[k]), Math.abs(b[j]-c[k]));
            if (curDist<minDist)
                minDist=curDist;
            //找出当前遍历到3个数组中的最小值
            min=min(a[i],b[j],c[k]);
            if (min==a[i]){
                if (++i>=aLen)
                    break;
            }else if (min==b[j]){
                if (++j>=bLen)
                    break;
            }else {
                if (++k>=cLen)
                    break;
            }
        }
        return minDist;
    }



    public static void main(String[] args) {
        int a[]={3,4,5,6,7};
        int b[]={10,12,14,16,18};
        int c[]={20,22,23,25,26,30,34,37};

        System.out.println(mindDistance(a,b,c));

    }