#G100. GESP level4 真题模拟3

GESP level4 真题模拟3

GESP level4 - 真题模拟3

  1. 冒泡排序的平均时间复杂度为O(n²),但最优情况下为O(n)。 {{ select(1) }}
  • 正确
  • 错误
  1. 下面的描述中,( )正确定义一个名为Person的结构体并正确初始化了一个Person结构体的变量p。 {{ select(2) }}
  • struct Person {
      string name;
      int age;
    </li>
    </ul>
    

    }; Person p("Yang", 10);

    </p>
    • struct Person {
        string name,
        int age;
      </li>
      </ul>
      

      }; Person p; p.age = 10; p.name = "Yang";

      </p>
      • struct Person {
          string name;
          int age;
        </li>
        </ul>
        

        }; Person p = { "Yang", 10 };

        </p>
        • struct Person {
            string name;
            int age;
          </li>
          </ul>
          

          }; Person p = new Person("Yang", 10);

          </p>
          1. 运行下面代码片段的结果是( )。
            int y = 24;
            int x = 20;
            int* p = &x;
            int* q = &y;
            p = q;
            {{ select(3) }}
          • x将赋值为24
          • y将赋值为20
          • p将指向y的地址
          • q将指向x的地址
          1. 下面程序两个输出结果是一样的。
            #include<iostream>
            using namespace std;
            int main()
            {
            int a[2][3] = {0};
            cout << a << endl;
            cout << &a[0][0] << endl;
            return 0;
            }
            {{ select(4) }}
          • 正确
          • 错误
          1. 函数不可以调用自己。 {{ select(5) }}
          • 正确
          • 错误
          1. 函数参数传递过程中,如果传常量值、常量引用和常量指针都是不能被修改的,它们可以防止函数对实参的值或地址进行修改。 {{ select(6) }}
          • 正确
          • 错误
          1. 递推算法通常有初始值。 {{ select(7) }}
          • 正确
          • 错误
          1. 冒泡排序是一种稳定的排序算法。 {{ select(8) }}
          • 正确
          • 错误
          1. C++语言中,如果异常发生,但没有处理异常的代码,则程序会由于一直等待处理而死机。 {{ select(9) }}
          • 正确
          • 错误
          1. C++语言中的局部变量在函数调用结束后会被销毁。 {{ select(10) }}
          • 正确
          • 错误
          1. &和&&都是C++语言的运算符,*和**也都是。 {{ select(11) }}
          • 正确
          • 错误
          1. 给定如下算法,其时间复杂度为( )。
            bool f(int arr[], int n, int target) {
            for (int i = 0; i < (1 << n); i++) {
            int sum = 0;
            for (int j = 0; j < n; j++) {
            if (i & (1 << j)) {
            sum += arr[j];
            }
            }
            if (sum == target)
            return true;
            }
            return false;
            }
            {{ select(12) }}
          • O(n²)
          • O(n×2ⁿ)
          • O(2ⁿ)
          • O(n×log n)
          1. 下面关于排序稳定性的描述,正确的是( )。 {{ select(13) }}
          • 稳定性指算法的时间复杂度恒定
          • 稳定排序保证相同元素的相对顺序不变
          • 选择排序是稳定排序
          • 插入排序不是稳定排序
          1. 给定如下代码,下面描述错误的是( )。
            struct Person {
            std::string name;
            int age;
            struct Address {
            std::string street;
            std::string city;
            };
            Address address;
            };
            {{ select(14) }}
          • 结构Person内嵌套结构Address
          • Person有一个Address类型的address成员
          • 一个Person类型的变量p的address的初始化可以写成:p.address.street = "123 Main St"; p.address.city = "Anytown";
          • 结构的嵌套可以减少命名冲突,因此可以不必控制嵌套层次
          1. 假设int arr[2][3] = {{1,2,3},{4,5,6}};,则arr[1][2]的值是( )。 {{ select(15) }}
          • 2
          • 3
          • 5
          • 6
          1. 下面( )正确定义了二维数组。 {{ select(16) }}
          • int arr[3,4];
          • int arr[3][4];
          • int arr(3,4);
          • int a[3-4];
          1. 在C++中,函数的返回类型可以省略,默认为int。 {{ select(17) }}
          • 正确
          • 错误
          1. 结构体的成员默认是public访问权限。 {{ select(18) }}
          • 正确
          • 错误
          1. 假设整数数组arr[4] = {0,1,2,3}的第一个元素在内存中的地址为0x7ffee4065820,经过int* p = arr; p += 1;后,指针p的值是1。 {{ select(19) }}
          • 正确
          • 错误
          1. 二维数组作为函数参数时,必须显式指定所有维度的大小。 {{ select(20) }}
          • 正确
          • 错误
          1. 运行如下代码会输出( )。
            int value = 100;
            void print1() {
            int value = 50;
            cout << value << " ";
            cout << ::value << " ";
            }
            void print2() {
            cout << value << " ";
            }
            int main() {
            print1();
            print2();
            return 0;
            }
            {{ select(21) }}
          • 100 100 100
          • 50 50 50
          • 50 100 100
          • 50 50 100
          1. 小杨在整理一副扑克牌的所有红心扑克牌,使其从小到大排列。他的做法是:最开始抓到第1张扑克牌被认为已经排好序;然后抓第2张扑克牌,将其插入至有序部分的正确位置;不断循环步骤,每次将新抓到扑克牌插入至有序部分,直至抓完所有扑克牌,这样抓牌结束时就完成了扑克牌的排序。小杨这种整理扑克牌的方式与( )排序的方式最接近。 {{ select(22) }}
          • 冒泡排序
          • 插入排序
          • 选择排序
          • 直接排序
          1. 以下哪种情况是使用插入排序的合适场景? {{ select(23) }}
          • 数据量非常大,且乱序严重
          • 希望获得稳定排序,但不要求实时性
          • 数据几乎有序,只需少量调整
          • 想在交换次数最少的前提下排好大数组
          1. 以下关于递推算法基本思想的描述,正确的是( )。 {{ select(24) }}
          • 递推算法通过将问题分解为相互独立的子问题来解决。
          • 递推算法从已知的基础情况出发,通过某种关系逐步推导出更大规模问题的解。
          • 递推算法通常用于穷举所有可能的解决方案。
          • 递推算法适用于在每一步做出局部最优选择以达到全局最优。
          1. 下面C++代码实现将Hello写入data.txt。
            ofstream out("data.txt");
            out << "Hello";
            out.close();
            {{ select(25) }}
          • 正确
          • 错误