GESP四级真题考点分析和解题思路

GESP 四级真题完整题单分析

四级核心考点分布统计

四级必备代码模板

1. 冒泡排序（多关键字）

struct Node {
    int mainKey;  // 主关键字
    int subKey;   // 次关键字
};

void bubbleSort(Node arr[], int n) {
    for(int i=0; i<n-1; i++) {
        for(int j=0; j<n-i-1; j++) {
            // 先按次关键字排序
            if(arr[j].subKey > arr[j+1].subKey) {
                swap(arr[j], arr[j+1]);
            }
        }
    }
    
    for(int i=0; i<n-1; i++) {
        for(int j=0; j<n-i-1; j++) {
            // 再按主关键字稳定排序
            if(arr[j].mainKey > arr[j+1].mainKey) {
                swap(arr[j], arr[j+1]);
            }
        }
    }
}

2. 拓扑排序（字符依赖）

const int MAX = 26;
int graph[MAX][MAX]; // 邻接矩阵
int indegree[MAX];   // 入度数组

void topoSort() {
    queue<int> q;
    // 初始化队列
    for(int i=0; i<MAX; i++) {
        if(indegree[i] == 0) q.push(i);
    }
    
    while(!q.empty()) {
        int cur = q.front();
        q.pop();
        cout << char('A'+cur);
        
        for(int i=0; i<MAX; i++) {
            if(graph[cur][i]) {
                indegree[i]--;
                if(indegree[i] == 0) {
                    q.push(i);
                }
            }
        }
    }
}

3. 双指针（宝箱问题）

int maxTreasures(int values[], int n, int k) {
    // 先排序价值数组
    bubbleSort(values, n);
    
    int left = 0, maxLen = 0;
    for(int right=0; right<n; right++) {
        // 调整左指针直到差值≤k
        while(values[right] - values[left] > k) {
            left++;
        }
        // 更新最大区间
        maxLen = max(maxLen, right - left + 1);
    }
    return maxLen;
}

4. 幻方填充（取模回绕）

void fillMagicSquare(int n) {
    int grid[15][15] = {0};
    int i = 0, j = n/2;
    
    for(int num=1; num<=n*n; num++) {
        grid[i][j] = num;
        // 计算下一个位置
        int ni = (i-1+n) % n;
        int nj = (j+1) % n;
        
        // 目标位置已填充则下方填数
        if(grid[ni][nj] != 0) {
            i = (i+1) % n;
        } else {
            i = ni;
            j = nj;
        }
    }
}

易错点及解决方案

1. 数组越界（出现率80%）

   • 场景：矩阵操作、字符串处理
   • 方案：数组声明增加冗余空间 int arr[105]（实际需求100）

2. 边界条件错误（出现率70%）

   • 场景：双指针、循环遍历
   • 方案：测试边界数据（空数组、单元素、最大值）

3. 排序稳定性处理（出现率40%）

   • 场景：多关键字排序
   • 方案：使用稳定排序（冒泡），先排次关键字再排主关键字

4. 死循环风险（出现率30%）

   • 场景：BFS、递归
   • 方案：设置最大递归深度/循环次数