算法4---数组

 

 

1 数组基本概念

 

2 数组有关的编程练习

 

 

 

1  数组的基本概念

 

数组就是用下标表示位置的相同类型数据的顺序数据类型，其中机器在给数据分配空间的时候分配的是一块连续的空间。

 

数组没有什么很多的东西需要补充，值得注意的是，数组作为参数的时候，使用指针的情况；

 

2 编程练习

 

 

1 remove duplicates from sorted array

 

discription:

     given a sorted array,remove the deplicates in place such that each element appear only once and return the new length;

     do not allocate extra space for another array,you must do this in place with constant memory.

     for example:

given input array A=[1,1,2]

your function should return length=2 ,and A is now [1,2];

 

#include <stdio.h>

int removeDeduplication(int A[],int n);

int main()
{
    /*int n;
    int A[]={};
    printf("please input the array with the length of n:
");
    scanf("%d",&n);
    printf("the length is %d
",n );
    for (int c = 0; c < n; c++)
    {
        scanf("%d",&A[c]);
    }
    for (int i = 0; i < n; i++)
    {
        //printf("the array is: 
");
        printf("%d 
",A[i]);
    }
    int l=removeDeduplication(A,n);
    printf("after deduplcate ,the length is:%d
",l);
    printf("the array now is: 
");
    for (int j = 0; j < l; j++)
    {       

        printf("%d
",A[j]);
    }
    */
    int A[10]={1,1,2,2,3,3,3,4,5,6};
    int l=removeDeduplication(A,10);
    printf("the length is %d
",l);
    printf("the array now is: 
");
    for (int j = 0; j < l; j++)
    {       
        printf("%d 
",    A[j]);
    }
    return 0;
}

int removeDeduplication(int A[],int n)
{
    int l=0;
    if (n==0)
    {
        printf("worry array!
");
    }
    for (int i = 1; i < n; i++)
    {
        if (A[l]!=A[i])
        {
            A[++l]=A[i];
        }
    }
    return l+1;
}

2 remove deplicates from sorted array2

 

descript:

     follow up for "remove duplicate":what if duplicates are allowed at most twice?

     for example,given sorted array A=[1,1,1,2,2,3];

     your function should return length =5,and A is now [1,1,2,2,3]

 

 

solve method:

 

两种解决办法；

 

#include <stdio.h>

int removeDeplication(int A[],int n);
int removeDeplication2(int A[],int n);
int main()
{
    int A[10]={1,1,1,2,3,3,3,4,5,6};
    int l=removeDeplication(A,10);
    int l=removeDeplication2(A,10);
    printf("the length is %d
",l);
    printf("the array now is: 
");
    for (int j = 0; j < l; j++)
    {       

        printf("%d 
",    A[j]);
    }
    return 0;
}

int removeDeplication(int A[],int n)
{
    int l=2;
    if (n<=2)
        return n;

    for (int i = 2; i < n; i++)
    {
        if (A[i]!=A[l-2])
        {
            A[l++]=A[i];
        }
    }
    return l;
}


int removeDeplication2(int A[],int n)
{
    int l=0;
    for (int i = 0; i < n; ++i)
    {
        if (i>0&&i<n-1&&A[i]==A[i-1]&&A[i]==A[i+1])
        {
            continue;
        }
        A[l++]=A[i];
    }
    return l;
}

3 Search in Rotated Sorted Array

 

discript:

     suppose a array is rotated at some pivot unknown to you beforehand

     (i.e, 0,2,3,4,5,6,7 might become 4,5,6,7,0,1,2)

     you are given a target value to search .if found in the array return its index,otherwise return -1;

     you might assume no dedulicate exists in the array!

 

 

methed 1 ,time complex is O(n),space complex is O(1)

#include <iostream>

using namespace std;

int search(int A[],int n,int target);

int main()
{
    int A[7]={4,5,6,7,0,1,2};
    int target;
    cout<<"please input the target you want to search!"<<endl;
    cin>>target;
    int index=search(A,7,target);
    if (index==-1)
    {
        cout<<"can't find the target!"<<endl;
    }
    else
        cout<<"find it! the index is :"<<index<<endl;
    return 0;
}

int search(int A[],int n,int target)
{
    for (int i = 0; i < n; i++)
    {
        if (A[i]==target)
        {
            cout<<"find the target!"<<endl;
            cout<<"the index is :"<<i<<endl;
            return i;
        }
    }
    return -1;
}

另一种解决办法

#include <iostream>

using namespace std;

int search2(int A[],int n,int target);

int main()
{
    int A[7]={4,5,6,7,0,1,2};
    int target;
    cout<<"please input the target you want to search!"<<endl;
    cin>>target;
    int index=search2(A,7,target);
    if (index==-1)
    {
        cout<<"can't find the target!"<<endl;
    }
    else
        cout<<"find it! the index is :"<<index<<endl;
    return 0;
}

int search2(int A[],int n,int target)
{
    int first =0,last =n;
    while(first!=last)
    {
        const int mid =(first+last)/2;
        if (A[mid]==target)
        {
            return mid;
        }
        if (A[first]<=A[last])
        {
            if (A[first]<=target && target<A[mid])
            {
                last=mid;
            }
            else
                first=mid+1;
        }
        else
        {
            if (A[mid]<=target && target<A[last-1] )
            {
                first=mid+1;
            }
            else
                last=mid;
        }
    }
    return -1;
}

4 search in roated sorted Array2

 

discript:

     follow us for "search in roated sorted Array ":what if duplicates sre allowed?

     would this sffect the run-time complexity ?how and why?

     write a function to determine if a given target is in the array.

 

 

method 1 ,just as the same way in 4 ,O(n) in time complex,O(1) in the space complex.

 

要注意这个continue的使用，否则不能够度多个相同的数据。

同时也要注意到那个else i++的作用，负责不能够继续读下去，只能查询前两个；

 

#include <iostream>

using namespace std;

int search(int A[],int n,int target);

int main()
{
    int A[7]={4,4,6,7,0,0,2};
    int target;
    cout<<"please input the target you want to search!"<<endl;
    cin>>target;
    int index=search(A,7,target);
    if (index==-1)
    {
        cout<<"can't find the target!"<<endl;
    }
    else
        cout<<"find it! the index is :"<<index<<endl;
    return 0;
}

int search(int A[],int n,int target)
{
    int i=0;
    while(i<n)
    {
        if (A[i]==target)
        {
            cout<<"find the target!"<<endl;
            cout<<"the index is :"<<i<<endl;
            i++;
            continue;
            return 0;
        }
        else
            i++;
    }
    return -1;
}

第二种方法，虽然时间复杂度依然是O(n)，空间复杂度是O（1），但是也提供了一种思路；

首先分析一下

允许重复元素，那么上一题中如果A[m]>=A[1],那么[1,m]中为递增序列的假设就不成立了，比如[1,3,1,1,1,]

如果A[m]>A[1]不能确定递增，那就把它拆分成两个条件：

若A[m]>A[1]，则区间【1，m】一定递增；

若A[m]==A[1]确定不了，那就l++,继续下一步就行了；

 

#include <iostream>

using namespace std;

int search(int A[],int n,int target);

int main()
{
    int A[7]={4,5,6,7,0,1,2};
    int target;
    cout<<"please input the target you want to search!"<<endl;
    cin>>target;
    int index=search(A,7,target);
    if (index==-1)
    {
        cout<<"can't find the target!"<<endl;
    }
    else
        cout<<"find it!  "<<endl;
    return 0;
}

int  search(int A[],int n,int target)
{
    int first =0,last =n;
    while(first!=last)
    {
        const int mid =(first+last)/2;
        if (A[mid]==target)
        {
            return 0;
        }
        if (A[first]<A[last])
        {
            if (A[first]<=target && target<A[mid])
            {
                last=mid;
            }
            else
                first=mid+1;
        }
        else if(A[first]>A[mid])
        {
            if (A[mid]<=target && target<A[last-1] )
            {
                first=mid+1;
            }
            else
                last=mid;
        }
        else
            first++;
    }
    return -1;
}

5 Median of two sorted arrays

 

there are two sorted arrays A,B of size m and n respectively. find the median of the two sorted arrays .the overal run time complexity should be O(log(m+n)).

 

首先只要解出来就好了，那么分配一个新的数组，大小是两个数组的大小和；

按照大小排序之后，很容易就求得了；时间复杂度O（n+m），空间复杂度O（1），因为需要的大小固定；

 

 

第二种方法是采用指针来实现；

其实如果不是规定了时间复杂度的话，很容易就能得到

下面我们先解决这个问题，不考虑时间复杂度的要求；

 

#include <iostream>
using namespace std;

int find_k(int A[],int m,int B[],int n,int k);

int main()
{
    int A[4]={1,3,4,6};
    int B[6]={2,4,5,7,8,9};
    int m=find_k(A,4,B,6,3);
    cout<<"the ans is "<<m<<endl;
    return 0;

}

int find_k(int A[],int m,int B[],int n,int k)
{
    if (m==0)
    {
        return B[n/2];
    }
    if (n==0)
    {
        return A[n/2];
    }


    int *p,*q;
    p=A;
    q=B;
    int i=0;
    int ans=0;
    while(i<k)
    {
        if (*p<=*q)
        {
            ans=*p;
             p++;
             i++;

        }
        else
        {
            ans=*q;
            q++;
            i++;
        }
    }
    return ans;
}

考虑时间复杂度的要求

方法如下：

 

#include <iostream>
using namespace std;


double findMedianSortedArrays(int A[],int m,int B[],int n);

int find_kth(int A[],int m,int B[],int n,int k);

int min(int a,int b);


int main()
{
    int A[4]={1,3,4,6};
    int B[6]={1,2,4,5,6,8};
    int ans= findMedianSortedArrays(A,4,B,6);
    cout<<"the meidan of two array is:"<<ans<<endl;
    return 0;
}

double findMedianSortedArrays(int A[],int m,int B[],int n)
{
    int total=m+n;
    if (total & 0x1)
    {
        return find_kth(A,m,B,n,total/2+1);
    }
    else
        return (find_kth(A,m,B,n,total/2)+find_kth(A,m,B,n,total/2+1))/2;
}

int find_kth(int A[],int m,int B[],int n,int k)
{
    if (m>n)
    {
        return find_kth(B,n,A,m,k);
    }
    if (m==0)
    {
        return B[k-1];
    }
    if (k==1)
    {
        return min(A[0],B[0]);
    }
    int ia=min(k/2,m),ib=k-ia;
    if (A[ia-1]<B[ib-1])
    {
        return find_kth(A+ia,m-ia,B,n,k-ia);
    }
    else if (A[ia-1]>B[ib-1])
    {
        return find_kth(A,m,B+ib,n-ib,k-ib);
    }
    else
        return A[ia-1];
}

int min(int a,int b)
{
    if (a<=b)
    {
        return a;
    }
    else
        return b;
}