当前位置：首页 > news >正文

【2025年清华计算机考研826算法题】

news 2025/10/10 12:28:59

2025年清华计算机考研826算法题

题目

算法题设计与分析（7+1+5+1=14分）
二叉树节点定义如下:

struct BinNode{int data;BstNode *lc,*rc;BstNode *parent;
}

均由n个节点组成的两棵二叉树V和U,若其节点可以分别用1到n之间的整数编号,且每一对编号相等的节点v∈V和u∈U,都满足v->parent和u->parent均为NULL或者编号相等,则成v与u弱同构,进一步地,若还满足v->lc和u->lc均为NULL或者编号相等且v->rc和u->rc均为NULL或者编号相等,则称V与U强同构.
(1)完成以下算法:

//以x为根的二叉树中,共有data域互异的n个节点
void heapify(BinNode *x){
//在O(nlogn)时间内,将其转化为与之强同构的大根堆
}

(2)试说明你的heapify()算法时间复杂度满足要求.

(3)接下来递归地定义二叉树节点的npl值如下:
对于空节点NULL,npl(NULL) =0
对于非空节点v,npl(v)=1+min{npl(v->lc),npl(v->rc)}
若堆中的每个非空节点v,都满足npl(v)=1+npl(v->rc),则称之为左式堆
完成如下算法:

//以x为根的大顶堆中,共有data域互异的n个节点
void leftify(BinNode *x){
//在O(n)时间内,将其转化为与之弱同构的左式堆
}

(4)试说明你的leftify()算法时间复杂度满足要求

解答

(1)算法代码

//考试的代码当然不用写这么多，这里我是为了测试用的
#include <iostream>
#include <vector>using namespace std;struct BinNode {int data;BinNode *lc, *rc;BinNode *parent;BinNode(int val) : data(val), lc(NULL), rc(NULL), parent(NULL) {}
};// 完成数据收集,O(n)
void getData(BinNode* node, vector<int>& data) {if (node == NULL) return;data.push_back(node->data);  getData(node->lc, data);getData(node->rc, data);
}// 归并,O(n)
void merge(vector<int>& arr, int lo, int mid, int hi) {int n1 = mid - lo + 1;int n2 = hi - mid;vector<int> L(arr.begin() + lo, arr.begin() + mid + 1);vector<int> R(arr.begin() + mid + 1, arr.begin() + hi + 1);int i = 0, j = 0, k = lo;while (i < n1 && j < n2) {arr[k++] = (L[i] <= R[j]) ? L[i++] : R[j++];}while (i < n1) arr[k++] = L[i++];while (j < n2) arr[k++] = R[j++];
}// 归并排序,O(nlogn)
void mergeSort(vector<int>& arr, int lo, int hi) {if (lo < hi) {int mid = lo + (hi - lo) / 2;mergeSort(arr, lo, mid);mergeSort(arr, mid + 1, hi);merge(arr, lo, mid, hi);}
}// 先序遍历逆序赋值,构建大根堆,O(n)
void preOrderAssign(BinNode* node, const vector<int>& data, int& index) {if (node == NULL) return;node->data = data[data.size() - 1 - index];  // 从大到小取元素index++;preOrderAssign(node->lc, data, index);preOrderAssign(node->rc, data, index);
}// 主函数:转换为强同构大根堆,O(nlogn)
void heapify(BinNode* x) {if (x == NULL) return;vector<int> data;getData(x, data);  //完成数据收集int n = data.size();mergeSort(data, 0, n - 1);  // 对data进行归并排序int index = 0;preOrderAssign(x, data, index);  // 逆序先序遍历赋值,构建大根堆
}// 先序遍历打印（测试用）
void preOrderPrint(BinNode* node) {if (node == NULL) return;cout << node->data << " ";preOrderPrint(node->lc);preOrderPrint(node->rc);
}int main() {// 构建测试二叉树BinNode* root = new BinNode(3);root->lc = new BinNode(1);root->rc = new BinNode(2);root->lc->parent = root;root->rc->parent = root;root->lc->lc = new BinNode(5);root->lc->lc->parent = root->lc;root->rc->rc = new BinNode(4);root->rc->rc->parent = root->rc;cout << "转换前先序遍历: ";preOrderPrint(root);  // 输出：3 1 5 2 4heapify(root);cout << "\n转换后先序遍历: ";preOrderPrint(root);  // 输出：5 4 3 2 1// 释放内存delete root->lc->lc;delete root->rc->rc;delete root->lc;delete root->rc;delete root;return 0;
}

(2)说明时间复杂度

排序时间是O(nlogn),收集data的时间和先序遍历赋值的时间为都是O(n),总体的时间复杂度为O(nlogn)

(3)代码实现

void leftify(BinNode *x) {leftifyWithNpl(x);
}int leftifyWithNpl(BinNode *x) {if (x == NULL) return 0;int leftNpl = leftifyWithNpl(x->lc); // 递归处理左子树并获取nplint rightNpl = leftifyWithNpl(x->rc); // 递归处理右子树并获取npl// 如果右子树的npl大于左子树，交换左右子树if (rightNpl > leftNpl) {swap(x->lc, x->rc);      // 交换后npl值也需要交换swap(leftNpl, rightNpl);}return 1 + min(leftNpl, rightNpl); // 返回当前节点的npl
}