算法复习-查找有序数组的公共部分

一.在数组中查找指定元素

首先在查找数组的公共部分之前，先了解如何在一个有序数组中查找目标元素。

1.遍历算法

     遍历数组，比较数组中每个元素和目标元素。如果存在相等元素则返回true，否则返回false。

public boolean find(int target,int[] array) {
    boolean bool=false;
    for (int i = 0; i < array.length; i++)
    {
        if (target==array[i])
        {
            bool=true;
            break;
        }
    }
    return bool;
}

时间复杂度为O(n).

2.二分查找

    每次比较数组中值和目标元素，如果中值大于目标，则将end赋中值对应的位置，若中值小于目标，则将start赋值中值对应的位置。

public boolean mid_find(int target,int[] array)
{
    boolean bool=false;
    int start=0;
    int end=array.length;
    int mid;
    while (start<end)
    {
        mid=(start+end)/2;
        if (target<array[mid]) {
            end = mid;
        }
        else if(target>array[mid])
        {
            start=mid;
        }
        else
        {
            bool=true;
            break;
        }
    }
    return bool;
}

时间复杂度为O(logN)。

二.现在我们来看看如何查找两个有序数组的公共部分。

     e.g现有一个数组a[1,2,3,4,5,6]，而另一个数组b为[2,4,7,9]。那么现在要求打印出两个数组的公共元素，算法如下。

1.遍历算法

对于数组a中的任意一个元素，都在b中进行遍历，找到相同元素则停止并进行打印。

public void find(int[] a,int[] b) {

    for (int target:a)
    for (int i = 0; i < b.length; i++)
    {
        if (target==b[i])
        {
            System.out.println(target);
        }
    }

}

假设数组a中的元素个数为N，数组b中的元素个数为M,则算法的复杂度为O(M*N);

2.二分算法

对于数组a中任意一个元素，在b中都进行二分查找。

public void mid_find(int[] a,int[] b)
{


    int mid;
    for (int target:a) {
        int start=0;
        int end=b.length;
        while (start < end) {
            mid = (start + end) / 2;
            if (target < b[mid]) {
                end = mid;
            } else if (target > b[mid]) {
                start = mid;
            } else {
                System.out.println(target);
                break;
            }
        }
    }

}

  若a得个数为N，b的个数为M,则复杂度为O(N*logM)。

3.模拟栈

对于数列a和b，分别设置两个指针指向两个数列的头指针

1）若a[i]小于b[j]，则i=i+1。

2）若a[i]等于n[j]，则打印该数，并i=i+1;j=j+1。

3)其中任意一个数组到达尾部算法结束。

public void stack(int[] a,int[] b)
{
    int i=0;
    int j=0;
    while (i<a.length&&j<b.length)
    {
        if (a[i]<b[j])
        {
            i++;
        }
        else if (a[i]>b[j])
        {
            j++;
        }
        else
        {
            System.out.println(a[i]);
            i++;
            j++;

        }
    }
}

复杂度为O(N+M)；