二叉树进阶题目

northheng127

已于 2024-04-19 21:56:26 修改

阅读量367

点赞数 6

分类专栏：树文章标签：算法数据结构 c++ 学习

于 2024-04-19 21:56:09 首次发布

本文链接：https://blog.csdn.net/northheng127/article/details/137977741

版权

树专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1还原二叉树

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
char pre[N],mid[N];
int w[N];
int ans;
struct node{
    int l,r;
}t[N];
int build(int prel,int prer,int midl,int midr){
    int asc=pre[prel];
    int pos=w[asc];
    if(midl<pos)t[asc].l=build(prel+1,pos-midl+prel,midl,pos-1);
    if(midr>pos)t[asc].r=build(pos-midl+prel+1,prer,pos+1,midr);
    return asc;
}
void dfs(int x,int high){
    if(x==0)return;
    dfs(t[x].l,high+1);
    dfs(t[x].r,high+1);
    ans=max(high,ans);
}
signed main(){
    int n;
    while(cin>>n){
        //init
        ans=0;
        for(int i='A';i<='z';i++){
            t[i].l=0;
            t[i].r=0;
        }
       cin>>pre+1>>mid+1;
        for(int i=1;i<=n;i++)
           w[mid[i]]=i;
        int root=build(1,n,1,n);
        dfs(root,1);
        cout<<ans<<endl;
    }
}

2并查集朋友圈

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int p[N],s[N];//并查集p[],检索深度s[]
int n,m,k,ans;
void init(){
    for(int i=1;i<=n;i++)
    p[i]=i,s[i]=1;
}
int find(int x){
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
}
void merge(int x,int y){
    int fx=find(x),fy=find(y);
    if(fx!=fy){
        p[fx]=fy;
        s[fy]+=s[fx];
    }
}
signed main(){
    scanf("%d%d",&n,&m);
    init();
    while(m--){
        int x,y;
        scanf("%d%d",&k,&x);
        for(int i=2;i<=k;i++){
            scanf("%d",&y);
            merge(x,y);
        }
    }
    for(int i=1;i<=n;i++)
        ans=max(ans,s[i]);
    printf("%d",ans);
}

3中序后序遍历还原二叉树的前序遍历

#include <iostream>
#include <vector>
using namespace std;
int last,cnt=1,n;
// 根据后序遍历和中序遍历输出前序遍历
void printPreorder(vector<int>& inorder, vector<int>& postorder, int inStart, int inEnd, int postStart, int postEnd, bool lastNode) {
    if (inStart > inEnd || postStart > postEnd) return;
    int rootVal = postorder[postEnd];
    if(last==cnt)cout<<rootVal;
    else{
    cout << rootVal<<" ";
    cnt++;
    }
    int rootIndex;
    for (rootIndex = inStart; rootIndex <= inEnd; ++rootIndex) {
        if (inorder[rootIndex] == rootVal) {
            break;
        }
    }
    // 左子树节点个数
    int leftSize = rootIndex - inStart;
    // 输出左子树的前序遍历
    printPreorder(inorder, postorder, inStart, rootIndex - 1, postStart, postStart + leftSize - 1, false);
    // 输出右子树的前序遍历
    printPreorder(inorder, postorder, rootIndex + 1, inEnd, postStart + leftSize, postEnd - 1, lastNode);
}
signed main() {
    cin >> n;
    vector<int> postorder(n);
    vector<int> inorder(n);
    for (int i = 0; i < n; ++i) {
        cin >> postorder[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> inorder[i];
    }
    last = n;
    cout << "Preorder: ";
    printPreorder(inorder, postorder, 0, n - 1, 0, n - 1, true); // 最后一个节点传入true
    cout << endl;
}

4中序前序还原二叉树玩转二叉树

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
int pre[N],mid[N];
int w[N];
int ans;
struct node{
    int l,r;
}t[N];
int build(int prel,int prer,int midl,int midr){
    int asc=pre[prel];
    int pos=w[asc];
    if(midl<pos)t[asc].l=build(prel+1,pos-midl+prel,midl,pos-1);
    if(midr>pos)t[asc].r=build(pos-midl+prel+1,prer,pos+1,midr);
    return asc;
}
void bfs(int x){
    queue<int> q;
    if(x)q.push(x);
    while(q.size()){
        int tr=q.front();
        q.pop();
        if(t[tr].r!=0)
        q.push(t[tr].r);
        if(t[tr].l!=0)
        q.push(t[tr].l);
        if(q.size()!=0)
        cout<<tr<<" ";
        else cout<<tr<<endl;
    }
}
signed main(){
    int n;
    while(cin>>n){
        //init
        ans=0;
        for(int i=1;i<=n;i++){
            t[i].l=0;
            t[i].r=0;
        }
        for(int i=1;i<=n;i++){
            cin>>mid[i];
        }
        for(int i=1;i<=n;i++){
            cin>>pre[i];
        }
        for(int i=1;i<=n;i++)
           w[mid[i]]=i;
        int root=build(1,n,1,n);
        bfs(root);
    }
}

5列出叶节点

#include<iostream>
#include<queue>
#include<cstdio>
#include<vector>
using namespace std;
struct node{
   int l,r;
}q[10];
int v[10];
vector<int> vv;//用来存放要输出的叶节点 
queue<int> Q;
void bfs(){
   for(int i=0;i<Q.size();i++){
      int num=Q.front();
      Q.pop(); 
      if(q[num].l==-1&&q[num].r==-1)
         vv.push_back(num);
      if(q[num].l!=-1)
         Q.push(q[num].l);
      if(q[num].r!=-1)
         Q.push(q[num].r);
    }
   if(Q.size())
     bfs();
}
signed main(){
   int n;
   cin>>n;
   char a,b;
   //数组v用来标记出现的结点，根节点不会出现在左右子树中，不会被标记 
   for(int i=0;i<n;i++){
      cin>>a>>b;
      if(a=='-')
         q[i].l=-1;
      else{
          q[i].l=a-'0';
          v[a-'0']=1;
       }
      if(b=='-')
         q[i].r=-1;
      else{
          q[i].r=b-'0';
          v[b-'0']=1;
       } 
    }
    //找到根节点 
    int root;
    for(int i=0;i<n;i++){
      if(v[i]==0){
        root=i;
        break;
       }
     }
    Q.push(root);
    bfs();
    for(int i=0;i<vv.size()-1;i++)
        cout<<vv[i]<<" ";
    cout<<vv[vv.size()-1]<<endl;
    return 0;
}

6Huffman树

哈夫曼树是什么呢，由博主娓娓道来，哈夫曼要的是最小的路权值，何为路权，就是节点*深度，而这个节点嘛，是叶子节点，为什么呢，咱们先设最底下的叶子结点为a,b吧，a和b的父节点其实是a+b这是哈夫曼编码而来的规定，就这样理解，所以说咱们每次取数就从最小的开始取，因为最下面的深度很深要取小数，才能使得最后的路权最小，取好了的节点建树，再把a+b返回原来的队列里面。

而这个结构体排序的优先队列需要定义布尔排序函数才能构成，按照上面我说的方法记住就好了，没别的技巧，就是记住就好了，到时候工作或者是考研保研灵活运用。、

然而你看哈夫曼编码就知道了，越是频繁出现的字符它的编码长度越小就会对字符串的识别更加轻松，而编码长度就是它对应的二进制的符号长度，越是频繁出现的字符二进制越短。

还有个小技巧就是哈夫曼树权值越大的离着根节点越近，也就是越频繁越近。

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
// 定义哈夫曼树的节点结构体
struct Node {
    int weight;
    Node *left;
    Node *right;
    Node(int w) : weight(w), left(nullptr), right(nullptr) {}
};
// 优先队列中的比较函数，用于构建哈夫曼树时选择权值最小的节点
struct Comp {
    bool operator()(Node* a, Node* b) {
        return a->weight > b->weight;
    }
};
// 构建哈夫曼树
Node* buildHuffmanTree(vector<int>& weights) {
    // 使用优先队列存储节点，并根据权值排序
    priority_queue<Node*, vector<Node*>, Comp> pq;
    for (int w : weights) {
        pq.push(new Node(w));
    }
    // 构建哈夫曼树
    while (pq.size() > 1) {
        Node* left = pq.top(); pq.pop();
        Node* right = pq.top(); pq.pop();
        Node* parent = new Node(left->weight + right->weight);
        parent->left = left;
        parent->right = right;
        pq.push(parent);
    }
    // 最后队列中剩余的节点即为根节点
    return pq.top();
}
// 计算哈夫曼树的带权路径长度（WPL）
int calcWPL(Node* root, int depth) {
    if (!root->left && !root->right) return root->weight * depth;
    return calcWPL(root->left, depth + 1) + calcWPL(root->right, depth + 1);
}
int main() {
    int n;
    cin >> n;
    vector<int> weights(n);
    for (int i = 0; i < n; ++i) {
        cin >> weights[i];
    }
    // 构建哈夫曼树
    Node* root = buildHuffmanTree(weights);
    // 计算WPL
    int wpl = calcWPL(root, 0);
    // 输出结果
    cout << wpl << endl;
    return 0;
}

到这里就完事了，不久还有更新敬请期待。

也可以看看我的树专栏

northheng127

关注

6
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
二叉树进阶题目

哈夫曼树是什么呢，由博主娓娓道来，哈夫曼要的是最小的路权值，何为路权，就是节点*深度，而这个节点嘛，是叶子节点，为什么呢，咱们先设最底下的叶子结点为a,b吧，a和b的父节点其实是a+b这是哈夫曼编码而来的规定，就这样理解，所以说咱们每次取数就从最小的开始取，因为最下面的深度很深要取小数，才能使得最后的路权最小，取好了的节点建树，再把a+b返回原来的队列里面。而这个结构体排序的优先队列需要定义布尔排序函数才能构成，按照上面我说的方法记住就好了，没别的技巧，就是记住就好了，到时候工作或者是考研保研灵活运用。
复制链接

扫一扫