华为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文件里了，如下：
1 #include <iostream> 2 using namespace std; 3 4 // 第一题 5 //从后往前比较数组中相应元素，返回不同元素的个数 6 int array_compare(int len1, int array1[], int len2, int array2[]) 7 { 8 int count = 0; // 计数器 9 int loopTimes = len1 < len2 ? len1:len2;//求出循环次数 10 int index1 = len1 - 1; 11 int index2 = len2 - 1; 12 for(int i = 0; i < loopTimes; ++i) 13 { 14 if(array1[index1] != array2[index2]) 15 { 16 ++ count; 17 } 18 --index1; 19 --index2; 20 } 21 return count; 22 } 23 24 // 第二题 25 // 约瑟夫环问题，根据计数值不断移走元素，并以移走的元素值作为计数值 26 void array_iterate(int len, int input_array[], int m, int output_array[]) 27 { 28 int startIndex = 0; // 下一次开始计数的下标 29 int chooseIndex = 0; // 选中的下标 30 int outputIndex = 0; // 输出数组的下标 31 while(len > 0) 32 { 33 startIndex = chooseIndex; 34 chooseIndex = (startIndex + (m - 1) % len) % len; 35 m = input_array[chooseIndex]; 36 output_array[outputIndex++] = m; 37 // 数组左移 38 for(int i = chooseIndex; i <= len - 2; ++i) 39 { 40 input_array[i] = input_array[i + 1]; 41 } 42 -- len; 43 } 44 } 45 46 //第三题 47 //四则运算表达式，用两个栈实现，一个是操作数栈，一个是操作符栈 48 int calculate(int len, char *expStr) 49 { 50 //用两个数组来模拟栈 51 int *operNumber = new int[len]; 52 int operNumberSize = 0; 53 char *operSymbol = new char[len]; 54 int operSymbolSize = 0; 55 bool popFlag = false; //需要进行弹出操作 56 for(int i = 0; i < len; ++i) 57 { 58 char c = expStr[i]; 59 if(c >= '0' && c <= '9') 60 { 61 //是操作数 62 operNumber[operNumberSize++] = (int)(c -'0'); 63 continue; 64 } 65 66 // 是操作符 67 else if(c == '*' || c == '/') 68 { 69 //是高优先级操作符 70 //判断是否满足弹出条件 71 if(operSymbolSize > 0 && 72 (operSymbol[operSymbolSize - 1] == '*' || operSymbol[operSymbolSize - 1] == '/') 73 ) 74 { 75 //弹出 76 popFlag = true; 77 } 78 else 79 { 80 // 不弹出 81 popFlag = false; 82 } 83 } 84 else if(c == '+' || c == '-') 85 { 86 // 是低优先级操作符 87 // 判断是否满足弹出条件 88 if(operSymbolSize == 0) 89 { 90 // 不弹出 91 popFlag = false; 92 } 93 else 94 { 95 // 弹出 96 popFlag = true; 97 } 98 } 99 100 // 弹出操作 101 if(popFlag == true) 102 { 103 int b = operNumber[--operNumberSize]; 104 int a = operNumber[--operNumberSize]; 105 char op = operSymbol[--operSymbolSize]; 106 if(op == '+') 107 { 108 operNumber[operNumberSize++] = a + b; 109 } 110 else if(op == '-') 111 { 112 operNumber[operNumberSize++] = a - b; 113 } 114 else if(op == '*') 115 { 116 operNumber[operNumberSize++] = a * b; 117 } 118 else 119 { 120 operNumber[operNumberSize++] = a / b; 121 } 122 } 123 124 // 现有操作符入栈 125 operSymbol[operSymbolSize++] = c; 126 } 127 128 // 清空操作符栈 129 while(operSymbolSize > 0) 130 { 131 int b = operNumber[--operNumberSize]; 132 int a = operNumber[--operNumberSize]; 133 char op = operSymbol[--operSymbolSize]; 134 if(op == '+') 135 { 136 operNumber[operNumberSize++] = a + b; 137 } 138 else if(op == '-') 139 { 140 operNumber[operNumberSize++] = a - b; 141 } 142 else if(op == '*') 143 { 144 operNumber[operNumberSize++] = a * b; 145 } 146 else 147 { 148 operNumber[operNumberSize++] = a / b; 149 } 150 } 151 152 int temp = operNumber[0]; 153 delete [] operNumber; 154 delete [] operSymbol; 155 156 return temp; 157 } 158 159 160 //输出 161 void output(const int *a, const int len) 162 { 163 for(int i = 0; i < len; ++i) 164 { 165 cout << a[i] << " "; 166 } 167 cout << endl; 168 } 169 170 int main() 171 { 172 // 第一题测试 173 int array1[] = {1,3,5}; 174 int len1 = 3; 175 int array2[] = {77,21,1,3,5}; 176 int len2 = 5; 177 cout << "第一题测试结果："; 178 cout << array_compare(len1, array1, len2, array2) << " "; 179 int array11[] = {1,3,5}; 180 int len11 = 3; 181 int array21[] = {77,21,1,3,5,7}; 182 int len21 = 6; 183 cout << array_compare(len11, array11, len21, array21) << endl; 184 185 186 // 第二题测试 187 cout << endl << "第二题测试结果："; 188 int input_array[] = {3,1,2,4}; 189 int output_array[4]; 190 int len = 4, m=7; 191 array_iterate(len, input_array, m, output_array); 192 output(output_array, len); 193 194 // 第三题测试 195 cout << endl << "第三题测试结果："; 196 char *expStr1 = "1+4*5-8/3"; 197 cout << calculate(strlen(expStr1), expStr1) << " "; 198 char *expStr2 = "8/3*3"; 199 cout << calculate(strlen(expStr2), expStr2) << endl; 200 201 return 0; 202 }
有同学指正第三题的实现（每次至多弹出一个操作符）与结构书（可以连续弹出多个操作符）上的不同，另外，空间可以更优化，数组空间可以静态，且有上界，现完善代码如下（针对第三题）：
1 // 返回优先级 2 int getPriority(const char c) 3 { 4 if(c == '+' || c == '-') 5 { 6 return 1; 7 } 8 else 9 { 10 return 0; 11 } 12 } 13 //第三题 14 //四则运算表达式，用两个栈实现，一个是操作数栈，一个是操作符栈 15 int calculate(int len, char *expStr) 16 { 17 18 //用两个数组来模拟栈 19 int operNumber[3]; // 就题而言，操作数个数最多为3 20 int operNumberSize = 0; 21 char operSymbol[2]; // 就题而言，操作符的个数最多为2 22 int operSymbolSize = 0; 23 for(int i = 0; i < len; ++i) 24 { 25 char c = expStr[i]; 26 int priority; 27 if(c >= '0' && c <= '9') 28 { 29 // 是操作数 30 operNumber[operNumberSize++] = (int)(c -'0'); 31 continue; 32 } 33 34 // 是操作符 35 else 36 { 37 priority = getPriority(c); // 获得优先级，这里定义加减的优先级是大数，乘除的优先级是小数 38 while(operSymbolSize > 0 && getPriority(operSymbol[operSymbolSize - 1]) <= priority) 39 { 40 int b = operNumber[--operNumberSize]; 41 int a = operNumber[--operNumberSize]; 42 char op = operSymbol[--operSymbolSize]; 43 switch(op) 44 { 45 case '+': 46 operNumber[operNumberSize++] = a + b; 47 break; 48 49 case '-': 50 operNumber[operNumberSize++] = a - b; 51 break; 52 53 case '*': 54 operNumber[operNumberSize++] = a * b; 55 break; 56 57 case '/': 58 operNumber[operNumberSize++] = a / b; 59 break; 60 } 61 } 62 // 现有操作符入栈 63 operSymbol[operSymbolSize++] = c; 64 } 65 } 66 67 // 清空操作符栈 68 while(operSymbolSize > 0) 69 { 70 int b = operNumber[--operNumberSize]; 71 int a = operNumber[--operNumberSize]; 72 char op = operSymbol[--operSymbolSize]; 73 switch(op) 74 { 75 case '+': 76 operNumber[operNumberSize++] = a + b; 77 break; 78 79 case '-': 80 operNumber[operNumberSize++] = a - b; 81 break; 82 83 case '*': 84 operNumber[operNumberSize++] = a * b; 85 break; 86 87 case '/': 88 operNumber[operNumberSize++] = a / b; 89 break; 90 } 91 } 92 93 int temp = operNumber[0]; 94 return temp; 95 }
