两道考研算法设计题- 2010 2013

2010：

设将n（n>1）个整数存放到一维数组R中。试设计一个在时间和空间两方面都尽可能高效的算法，将R中保存的序列循环左移P（0<P<n）个位置，即将R中的数据由（x0,x1,…,xn-1）变换为(xp,xp+1,…,xn-1,x0,x1,…,xp-1)。要求：
　　（1）给出算法的基本设计思想。
　　（2）根据设计思想，采用C或C++或JAVA语言描述算法，关键之处给出注释。
　　（3）说明设计算法的时间复杂度和空间复杂度。

【解析】：

（1）前P个数依次进队，while(i<n-p) A[i]=A[i+p]；P个数依次出队，进入数组末尾；

或者，使用数学里的分析方法：

循环左移p个位置，也就是将数组分为2部分，前一部分从0到p-1，后一部分从p到n-1，将数组的前一部分跟后一部分进行了交换。 

首先逆序前一部分，然后逆序后一部分，左后整个逆序。以此实现循环左移：酷酷的！

其数学原理：(a^-1b^-1)^-1=ba

代码如下：

#include<iostream>
#include<string>
using namespace std;

void reverse(int a[],int begin,int end)
{
    int i = begin, j = end,temp;
    while (i < j)
    {
        a[i] = a[j];
        a[j] = temp;
        ++i;
        --j;
    }
}
void loop(int *a, int len, int p)
{
    reverse(a, 0, p - 1);
    reverse(a, p, len-1);
    reverse(a, 0, len-1);
}

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    loop(a, 5, 3);
    for (int i = 0; i < 5; i++)
    cout << a[i] << " ";
    return 0;//输出结果：4 5 1 2 3
}

（3）时间复杂度O(N)，空间复杂度O(1)。 

 

 

 

2013：

【解析：】

（1）算法思想：

首先保存整数序列的第一个数到res中，并计数count=1，然后从后往前（从前往后也一样）遍历，若是第二个数等于res，则count自增，否则count自减，若是count等于0，则res保存整数序列中将要遍历的下一个整数。

其次，我们来进行验证，遍历一遍整数序列，若是整数等于上一步中的res，则count自增，否则不做处理；如果最后count大于n/2，则说明res就是主元素，否则返回-1，说明主元素不存在。

（2）c++实现的代码如下：

#include<iostream>
using namespace std;
int getNum(int *arr, int len)
{
    int res=arr[0],count=1;
    while (len > 0)
    {
        if (arr[len] == res)
            count++;
        else
        {
            --count;
            if (count == 0)
                res = arr[len - 1];
        }
        len--;
    }
    return res;
}
int verify(int *arr, int len)
{
    int count = 0;
    int num = getNum(arr, len);
    for (int i = 0; i < len;i++)
    if (num == arr[i])
        ++count;
    if (count>len / 2)
        return num;
    else
        return -1;
}
int main()
{
    int arr[] = { 0,5,5,3,5,7,5,5 };
    int result = verify(arr, 8);
    cout << result << endl;
    return 0;
}

update-2015-8-20：网上一段更简洁的代码：

class Solution {
public:
    int majorityElement(vector<int> &num) {
        int nTimes = 0;
        int candidate = 0;
        for(int i = 0; i < num.size(); i ++)
        {
            if(nTimes == 0)
            {
                candidate = num[i];
                nTimes = 1;
            }
            else
            {
                if(candidate == num[i])
                    nTimes ++;
                else
                    nTimes --;
            }
        }
        return candidate;
    }
};

 

（3）数组遍历了两次，但是每次都是O（n），空间上只使用了几个辅助变量，所以时间复杂度为O（n），空间复杂度为O（1）。