华为2011上机笔试题1+参考程序

1. 数组比较（20分）

比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果2个数组长度不等，则只比较较短长度数组个数元素。请编程实现上述比较，并返回比较中发现的不相等元素的个数

比如：

数组{1,3,5}和数组{77,21,1,3,5}按题述要求比较，不相等元素个数为0

数组{1,3,5}和数组{77,21,1,3,5,7}按题述要求比较，不相等元素个数为3

要求实现函数：

int array_compare(int len1, int array1[], int len2, int array2[])

【输入】 int len1：输入被比较数组1的元素个数；

int array1[]：输入被比较数组1；

int len2：输入被比较数组2的元素个数；

int array2[]：输入被比较数组2；

【输出】 无

【返回】 不相等元素的个数，类型为int

示例:

1） 输入：int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5}，int len2 = 5

函数返回：0

2） 输入：int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5,7}，int len2 = 6

函数返回：3

2. 约瑟夫问题

输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。从数列首位置开始计数，计数到m后，将数列该位置数值替换计数值m，并将数列该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。如果计数到达数列尾段，则返回数列首位置继续计数。请编程实现上述计数过程，同时输出数值出列的顺序

比如：输入的随机数列为：3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置）

第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数

第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数

第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数

最后一轮计数出列数字为4，计数过程完成。

输出数值出列顺序为：2,3,1,4。

要求实现函数：

void array_iterate(int len, int input_array[], int m, int output_array[])

【输入】 int len：输入数列的长度；

int intput_array[]：输入的初始数列

int m：初始计数值

【输出】 int output_array[]：输出的数值出列顺序

【返回】 无

示例:

输入：int input_array[] = {3,1,2,4}，int len = 4， m=7

输出：output_array[] = {2,3,1,4}

3. 简单四则运算

问题描述：

输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值

注：

3.1、表达式只含 +, -, *, / 四则运算符，不含括号

3.2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况

3.3、要考虑加减乘除按通常四则运算规定的计算优先级

3.4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生

3.5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况

要求实现函数：

int calculate(int len, char *expStr)

【输入】 int len: 字符串长度；

char *expStr: 表达式字符串；

【输出】 无

【返回】 计算结果

示例:

1）输入：char *expStr = “1+4*5-8/3”

函数返回：19

2）输入：char *expStr = “8/3*3”

函数返回：6

参考程序（欢迎讨论）　转载请注明来源http://www.cnblogs.com/jerry19880126/

三道题写在一个CPP文件里了，如下：

#include <iostream>
using namespace std;

// 第一题
//从后往前比较数组中相应元素，返回不同元素的个数
int array_compare(int len1, int array1[], int len2, int array2[])
{
    int count = 0; // 计数器
    int loopTimes = len1 < len2 ? len1:len2;//求出循环次数
    int index1 = len1 - 1;
    int index2 = len2 - 1;
    for(int i = 0; i < loopTimes; ++i)
    {
        if(array1[index1] != array2[index2])
        {
            ++ count;
        }
        --index1;
        --index2;
    }
    return count;
}

// 第二题
// 约瑟夫环问题，根据计数值不断移走元素，并以移走的元素值作为计数值
void array_iterate(int len, int input_array[], int m, int output_array[])
{
    int startIndex = 0; // 下一次开始计数的下标
    int chooseIndex = 0; // 选中的下标
    int outputIndex = 0; // 输出数组的下标
    while(len > 0)
    {    
        startIndex = chooseIndex;
        chooseIndex = (startIndex + (m - 1) % len) % len;
        m = input_array[chooseIndex];
        output_array[outputIndex++] = m;
        // 数组左移
        for(int i = chooseIndex; i <= len - 2; ++i)
        {
            input_array[i] = input_array[i + 1];
        }
        -- len;
    }
}

//第三题
//四则运算表达式，用两个栈实现，一个是操作数栈，一个是操作符栈
int calculate(int len, char *expStr)
{
    //用两个数组来模拟栈
    int *operNumber = new int[len];
    int operNumberSize = 0;
    char *operSymbol = new char[len];
    int operSymbolSize = 0;
    bool popFlag = false; //需要进行弹出操作
    for(int i = 0; i < len; ++i)
    {
        char c = expStr[i];
        if(c >= '0' && c <= '9')
        {
            //是操作数
            operNumber[operNumberSize++] = (int)(c -'0');
            continue;
        }
        
        // 是操作符
        else if(c == '*' || c == '/')
        {
            //是高优先级操作符
            //判断是否满足弹出条件
            if(operSymbolSize > 0 && 
                (operSymbol[operSymbolSize - 1] == '*' || operSymbol[operSymbolSize - 1] == '/')
                )
            {
                //弹出
                popFlag = true;
            }
            else
            {
                // 不弹出
                popFlag = false;
            }
        }
        else if(c == '+' || c == '-')
        {
            // 是低优先级操作符
            // 判断是否满足弹出条件
            if(operSymbolSize == 0)
            {
                // 不弹出
                popFlag = false;
            }
            else
            {
                // 弹出
                popFlag = true;
            }
        }

        // 弹出操作
        if(popFlag == true)
        {
            int b = operNumber[--operNumberSize];
            int a = operNumber[--operNumberSize];
            char op = operSymbol[--operSymbolSize];
            if(op == '+')
            {
                operNumber[operNumberSize++] = a + b;
            }
            else if(op == '-')
            {
                operNumber[operNumberSize++] = a - b;
            }
            else if(op == '*')
            {
                operNumber[operNumberSize++] = a * b;
            }
            else
            {
                operNumber[operNumberSize++] = a / b;
            }
        }

        // 现有操作符入栈
        operSymbol[operSymbolSize++] = c;
    }

    // 清空操作符栈
    while(operSymbolSize > 0)
    {
        int b = operNumber[--operNumberSize];
        int a = operNumber[--operNumberSize];
        char op = operSymbol[--operSymbolSize];
        if(op == '+')
        {
            operNumber[operNumberSize++] = a + b;
        }
        else if(op == '-')
        {
            operNumber[operNumberSize++] = a - b;
        }
        else if(op == '*')
        {
            operNumber[operNumberSize++] = a * b;
        }
        else
        {
            operNumber[operNumberSize++] = a / b;
        }
    }

    int temp = operNumber[0];
    delete [] operNumber;
    delete [] operSymbol;

    return temp;
}


//输出
void output(const int *a, const int len)
{
    for(int i = 0; i < len; ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main()
{
    // 第一题测试
    int array1[] = {1,3,5};
    int len1 = 3;
    int array2[] = {77,21,1,3,5};
    int len2 = 5;
    cout << "第一题测试结果：";
    cout << array_compare(len1, array1, len2, array2) << " ";
    int array11[] = {1,3,5};
    int len11 = 3;
    int array21[] = {77,21,1,3,5,7};
    int len21 = 6;
    cout << array_compare(len11, array11, len21, array21) << endl;

    
    // 第二题测试
    cout << endl << "第二题测试结果：";
    int input_array[] = {3,1,2,4};
    int output_array[4];
    int len = 4, m=7;
    array_iterate(len, input_array, m, output_array);
    output(output_array, len);

    // 第三题测试
    cout << endl << "第三题测试结果：";
    char *expStr1 = "1+4*5-8/3";
    cout << calculate(strlen(expStr1), expStr1) << " ";
    char *expStr2 = "8/3*3";
    cout << calculate(strlen(expStr2), expStr2) << endl;

    return 0;
}

有同学指正第三题的实现（每次至多弹出一个操作符）与结构书（可以连续弹出多个操作符）上的不同，另外，空间可以更优化，数组空间可以静态，且有上界，现完善代码如下（针对第三题）：

// 返回优先级
int getPriority(const char c)
{
    if(c == '+' || c == '-')
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
//第三题
//四则运算表达式，用两个栈实现，一个是操作数栈，一个是操作符栈
int calculate(int len, char *expStr)
{
    
    //用两个数组来模拟栈
    int operNumber[3]; // 就题而言，操作数个数最多为3
    int operNumberSize = 0;
    char operSymbol[2]; // 就题而言，操作符的个数最多为2
    int operSymbolSize = 0;
    for(int i = 0; i < len; ++i)
    {
        char c = expStr[i];
        int priority;
        if(c >= '0' && c <= '9')
        {
            // 是操作数
            operNumber[operNumberSize++] = (int)(c -'0');
            continue;
        }
        
        // 是操作符
        else
        {
            priority = getPriority(c); // 获得优先级，这里定义加减的优先级是大数，乘除的优先级是小数
            while(operSymbolSize > 0 && getPriority(operSymbol[operSymbolSize - 1]) <= priority)
            {
                int b = operNumber[--operNumberSize];
                int a = operNumber[--operNumberSize];
                char op = operSymbol[--operSymbolSize];
                switch(op)
                {
                case '+':
                    operNumber[operNumberSize++] = a + b;
                    break;

                case '-':
                    operNumber[operNumberSize++] = a - b;
                    break;

                case '*':
                    operNumber[operNumberSize++] = a * b;
                    break;

                case '/':
                    operNumber[operNumberSize++] = a / b;
                    break;
                }
            }        
            // 现有操作符入栈
            operSymbol[operSymbolSize++] = c;
        }
    }

    // 清空操作符栈
    while(operSymbolSize > 0)
    {
        int b = operNumber[--operNumberSize];
        int a = operNumber[--operNumberSize];
        char op = operSymbol[--operSymbolSize];
        switch(op)
        {
        case '+':
            operNumber[operNumberSize++] = a + b;
            break;

        case '-':
            operNumber[operNumberSize++] = a - b;
            break;

        case '*':
            operNumber[operNumberSize++] = a * b;
            break;

        case '/':
            operNumber[operNumberSize++] = a / b;
            break;
        }
    }

    int temp = operNumber[0];
    return temp;
}