【算法】-- 【計算兩個有序整型數組的交集、判斷一個數組中數值是否連續相鄰、求解數組中反序對的個數、如何求解最小三元組距離】

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));

    }