销魂结构作业8

最新推荐文章于 2024-05-30 16:17:47 发布
最新推荐文章于 2024-05-30 16:17:47 发布
阅读量305 收藏 1
点赞数
分类专栏： 数据结构作业 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qa666qa/article/details/127705943
版权

问题 A: 二叉树非递归前序遍历-附加代码模式

用二叉树的带虚结点表示的前序遍历序可以唯一的确定一棵二叉树，请用非递归算法实现二叉树的前序遍历。

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <queue>
#include <stack>
using namespace std;
 
struct BiNode
{
    string data;
    BiNode *lchild, *rchild;
};
typedef BiNode *BiTree;
 
int InitBiTree(BiTree &T)
{
    T = NULL;
return 0;
}
 
// 非递归前序遍历，返回遍历结果字符串
string PreTraverse_nonRec(BiTree T)
{
    string result = "";
    stack<BiTree>st;
    if(T==NULL) return result;
    st.push(T);
    while(!st.empty()){
        BiTree node=st.top();
        st.pop();
        result=result+node->data;
        if(node->rchild) st.push(node->rchild);
        if(node->lchild) st.push(node->lchild);
    }
    return result;
}
 
// 用带虚结点的前序遍历串str（每个字符对应一个结点）构造二叉树T，并返回剩余字符串
char *CreateBiTree(BiTree &T, char *str)
{
    // 约定#表示空结点
    if (*str == '#')
    {
        T = NULL;
        return str + 1;
    }
 
    // 创建结点
    T = new BiNode;
    T->data = *str;
 
    // 继续输入并构造左子树和右子树
    char * strAfterLeft = CreateBiTree(T->lchild, str + 1);
    char * strAfterRight = CreateBiTree(T->rchild, strAfterLeft);
 
    // 返回剩余的字符串
    return strAfterRight;
}
 
int PreTraverse(BiTree T){
    if (T == NULL) return 0;
    cout << T->data;
    PreTraverse(T->lchild);
    PreTraverse(T->rchild);
    return 0;
}
 
int DestroyBiTree(BiTree &T){
    if (T == NULL) return 0;
    DestroyBiTree(T->lchild);
    DestroyBiTree(T->rchild);
    delete T;
    T = NULL;
    return 0;
}
 
// please comment the following code when you sumbit to OJ
/*int main(){
    // char *str = "abd###ceg##h##f#i##";
    char str[2000];
    while(cin >> str)
    {
        BiTree tree;
        InitBiTree(tree);
        // 根据带空节点的前序遍历字符串构造二叉树
        CreateBiTree(tree, str);
        // 前序遍历递归算法
        PreTraverse(tree);
        cout << endl;
        // 前序遍历非递归算法
        string result = PreTraverse_nonRec(tree);
        cout << result << endl;
        DestroyBiTree(tree);
    }
    return 0;
}*/

问题 B: 二叉树非递归中序遍历-附加代码模式

用二叉树的带虚结点表示的前序遍历序可以唯一的确定一棵二叉树，请用非递归算法实现二叉树的中序遍历。

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <queue>
#include <stack>
using namespace std;
 
struct BiNode
{
    string data;
    BiNode *lchild, *rchild;
};
typedef BiNode *BiTree;
 
int InitBiTree(BiTree &T)
{
    T = NULL;
return 0;
}
 
// 非递归中序遍历，返回遍历结果字符串
string InTraverse_nonRec(BiTree T)
{
    // please write your code here
    string result = "";
    if(T==NULL) return result;
    stack<BiTree>st;
    while(!st.empty()||T){
        while(T){
            st.push(T);
            T=T->lchild;
        }
        T=st.top();
        st.pop();
        result=result+T->data;
        T=T->rchild;
    }
    return result;
}
 
// 用带虚结点的前序遍历串str（每个字符对应一个结点）构造二叉树T，并返回剩余字符串
char *CreateBiTree(BiTree &T, char *str)
{
    // 约定#表示空结点
    if (*str == '#')
    {
        T = NULL;
        return str + 1;
    }
 
    // 创建结点
    T = new BiNode;
    T->data = *str;
 
    // 继续输入并构造左子树和右子树
    char * strAfterLeft = CreateBiTree(T->lchild, str + 1);
    char * strAfterRight = CreateBiTree(T->rchild, strAfterLeft);
 
    // 返回剩余的字符串
    return strAfterRight;
}
 
int InTraverse(BiTree T){
    if (T == NULL) return 0;
     
    InTraverse(T->lchild);
    cout << T->data;
    InTraverse(T->rchild);
    return 0;
}
 
int DestroyBiTree(BiTree &T){
    if (T == NULL) return 0;
    DestroyBiTree(T->lchild);
    DestroyBiTree(T->rchild);
    delete T;
    T = NULL;
    return 0;
}
 
// please comment the following code when you sumbit to OJ
/*int main(){
    // char *str = "abd###ceg##h##f#i##";
    char str[2000];
    while(cin >> str)
    {
        BiTree tree;
        InitBiTree(tree);
        // 根据带空节点的前序遍历字符串构造二叉树
        CreateBiTree(tree, str);
        // 中序遍历递归算法
        InTraverse(tree);
        cout << endl;
        // 中序遍历非递归算法
        string result = InTraverse_nonRec(tree);
        cout << result << endl;
        DestroyBiTree(tree);
    }
    return 0;
}*/

问题 C: 二叉树非递归后序遍历-附加代码模式

用二叉树的带虚结点表示的前序遍历序可以唯一的确定一棵二叉树，请用非递归算法实现二叉树的后序遍历。

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <queue>
#include <stack>
#include<algorithm> 
using namespace std;
 
struct BiNode
{
    string data;
    BiNode *lchild, *rchild;
};
typedef BiNode *BiTree;
 
int InitBiTree(BiTree &T)
{
    T = NULL;
return 0;
}
 
// 非递归中序遍历，返回遍历结果字符串
string SucTraverse_nonRec(BiTree T)
{
    // please write your code here
    string result = "";
    if(T==NULL) return result;
    stack<BiTree>st;
    st.push(T);
    while(!st.empty()){
        BiTree node=st.top();
        st.pop();
        result=result+node->data;
        if(node->lchild) st.push(node->lchild);
        if(node->rchild) st.push(node->rchild);
    }
    reverse(result.begin(),result.end());
    return result;
}
 
// 用带虚结点的前序遍历串str（每个字符对应一个结点）构造二叉树T，并返回剩余字符串
char *CreateBiTree(BiTree &T, char *str)
{
    // 约定#表示空结点
    if (*str == '#')
    {
        T = NULL;
        return str + 1;
    }
 
    // 创建结点
    T = new BiNode;
    T->data = *str;
 
    // 继续输入并构造左子树和右子树
    char * strAfterLeft = CreateBiTree(T->lchild, str + 1);
    char * strAfterRight = CreateBiTree(T->rchild, strAfterLeft);
 
    // 返回剩余的字符串
    return strAfterRight;
}
 
int SucTraverse(BiTree T){
    if (T == NULL) return 0;
     
    SucTraverse(T->lchild);
    SucTraverse(T->rchild);
    cout << T->data;
    return 0;
}
 
int DestroyBiTree(BiTree &T){
    if (T == NULL) return 0;
    DestroyBiTree(T->lchild);
    DestroyBiTree(T->rchild);
    delete T;
    T = NULL;
    return 0;
}
 
// please comment the following code when you sumbit to OJ
/*int main(){
    // char *str = "abd###ceg##h##f#i##";
    char str[2000];
    while(cin >> str)
    {
        BiTree tree;
        InitBiTree(tree);
        // 根据带空节点的前序遍历字符串构造二叉树
        CreateBiTree(tree, str);
        // 中序遍历递归算法
        SucTraverse(tree);
        cout << endl;
        // 中序遍历非递归算法
        string result = SucTraverse_nonRec(tree);
        cout << result << endl;
        DestroyBiTree(tree);
    }
    return 0;
}*/

问题 D: 求二叉树中序遍历序根节点的下标

题目描述

用一棵二叉树的前序遍历序和中序遍历序可以唯一确定一棵二叉树，这个算法的核心操作是根据前序遍历序，查找中序遍历序中根节点的位置，以确定左子树序列，根节点，和右子树序列。然后递归找到每个子树的根节点就可以完成二叉树的构造。

前序遍历第一个字母就是根节点。在第二个字符串里查找它的下标即可。

#include <iostream>
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <queue>
#include <stack>
#include<algorithm> 
using namespace std;
int main()
{
    string a,b;
    while(cin>>a>>b){
        char ch=a[0];
        for(int i=0;i<b.length();i++){
            if(b[i]==ch){
                cout<<i<<endl;
                break;
            }
        }
    }
 
    return 0;
}

问题 E: 根据前序+中序还原二叉树

用一棵二叉树的前序遍历序和中序遍历序可以唯一确定一棵二叉树。

对于前序遍历中的任意两个连续节点 u 和 v，根据前序遍历的流程，我们可以知道 u 和 v 只有两种可能的关系：

    v 是 u 的左儿子。这是因为在遍历到 uu 之后，下一个遍历的节点就是 u 的左儿子，即 v；

    u 没有左儿子，并且 v 是 u 的某个祖先节点（或者 u 本身）的右儿子。如果 uu 没有左儿子，那么下一个遍历的节点就是 uu 的右儿子。如果 uu 没有右儿子，我们就会向上回溯，直到遇到第一个有右儿子（且 u 不在它的右儿子的子树中）的节点 ua​，那么 v 就是 ua​ 的右儿子。

#include <iostream>
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <queue>
#include <stack>
#include<algorithm> 
using namespace std;
typedef struct node{
    struct node *l;
    struct node *r;
    char val;
}node,*tnode;
tnode buildtree(string a,string b){
    if(!a.length()) return NULL;
    tnode root=new node;
    root->val=a[0];
    stack<tnode>st;
    st.push(root);
    int index=0;
    for(int i=1;i<a.length();i++){
        char ch=a[i];
        tnode rost=st.top();
        if(rost->val!=b[index]){
            rost->l=new node;
            rost->l->val=ch;
            st.push(rost->l);
        }
        else{
            while(!st.empty()&&st.top()->val==b[index]){
                rost=st.top();
                st.pop();
                index++;
            }
            rost->r=new node();
            rost->r->val=ch;
            st.push(rost->r);
        }
    }
    return root;
}
void endsolve(tnode root){
    if(root==NULL) return;
    endsolve(root->l);
    endsolve(root->r);
    cout<<root->val;
}
 
int main()
{
    string a,b;
    while(cin>>a>>b){
        tnode T=buildtree(a,b);
        endsolve(T);
        cout<<endl;
    }
    return 0;
}

问题 F: 算法6-12：自底向上的赫夫曼编码

#include <bits/stdc++.h>
using namespace std;
typedef struct node{
    int l,r,fat,val;
}hoff;
hoff t[1005];
int check(int n){
    for(int i=n;i<2*n-1;i++) t[i].val=0;
    for(int i=0;i<2*n-1;i++) t[i].fat=t[i].l=t[i].r=-1;
    for(int i=n;i<n*2-1;i++){
        int min1=INT_MAX,min2=INT_MAX;
        int ind1,ind2;
        for(int j=0;j<i;j++){
            if(t[j].val<min1&&t[j].fat==-1){
                min1=t[j].val;
                ind1=j;
            }
        }
        t[ind1].fat=i;
        for(int j=0;j<i;j++){
            if(t[j].val<min2&&t[j].fat==-1&&j!=ind1){
                min2=t[j].val;
                ind2=j;
            }
        }
        t[ind2].fat=i;
        if(ind1>ind2){
            swap(ind1,ind2);
            swap(min1,min2);
        }
        t[i].val=min1+min2;
        t[i].l=ind1;
        t[i].r=ind2;
    }
    return 0;
}
int created(int n){
    int start=0;
    char ch[105];
    for(int i=0;i<n;i++){
        for(int j=i,par=t[i].fat;par!=-1;j=par,par=t[par].fat){
            if(t[par].l==j) ch[start]='0';
            else ch[start]='1';
            start++;
        }
        string str;
        while(start){
            start--;
            str=str+ch[start];
        }
        cout<<str<<endl;
        start=0;
    }
    return 0;
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++) cin>>t[i].val;
    check(n);
    created(n);
    return 0;
}

问题 G: 视频合并问题

题目描述

有多个视频需要合并为一个视频，假设一次只能将两个视频进行合并，合并需要的时间为该两个视频的时间之和。请计算将多个视频合并为一个视频需要的最小时间为多少？

每次挑最小的两个合并，合并后塞回数组。可以考虑用 priority_queue。

#include <iostream>
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <queue>
#include <stack>
#include<algorithm> 
using namespace std;
int a[10086];
bool cmp(int a,int b){
    return a>b;
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    int sum=0;int t=0;
    for(int i=n-1;i>0;i--){
        sort(a,a+i+1,cmp);
        t=a[i-1]+a[i];
        sum+=t;
        a[i-1]=t;
    }
    cout<<sum;
    return 0;
}

问题 H: 二叉树实现的简单物种识别系统-附加代码模式

用二叉树可以实现一个简单的物种识别系统，举例如下：

请编写代码根据上面的系统完成物种识别过程。注意问题对应的左节点表示回答的是no，右节点表示回答的yes
 

太坑了，给的模板写好的地方不全是对的，还要再补上，不然会MLE。。。

函数头不是void 的，都把 return 补上。

#include <bits/stdc++.h>
using namespace std;
  
struct BiNode
{
    string data;
    BiNode *lchild, *rchild;
};
typedef BiNode *BiTree;
  
int InitBiTree(BiTree &T)
{
    T = nullptr;
    return 0;
}
  
BiTree getNode(string data){
    BiTree node = new BiNode;
    node->data = data;
    node->lchild = nullptr;
    node->rchild = nullptr;
    return node;
}
BiNode *StartRecognize(BiTree T)
{
    /*BiTree n3 = getNode("rabbit");
    BiTree n4 = getNode("tiger");
    BiTree n5 = getNode("swallow");
    BiTree n6 = getNode("eagle");*/
    BiTree p=T;
    /*char a,b;
    cin>>a>>b;
    if((a=='y'||a=='Y')&&(b=='y'||b=='Y')) p=getNode("eagle");
    if((a=='y'||a=='Y')&&(b=='n'||b=='N')) p=getNode("swallow");
    if((a=='n'||a=='N')&&(b=='y'||b=='Y')) p=getNode("tiger");
    if((a=='n'||a=='N')&&(b=='N'||b=='n')) p=getNode("rabbit");*/
    char c;
    for(int i=0;i<2;i++){
        cin>>c;
        if(c=='y'||c=='Y') p=p->rchild;
        else p=p->lchild;
    }
    return p;
}
/*
// please comment the following code when you sumbit to OJ
 
// 构造一个三层的物种识别系统，第一层是一个问题，第二层是两个问题，第三层是四种动物
BiTree setRecognizeSystem(){
    BiTree T = getNode("Can it fly?");
    BiNode* n1 = getNode("Is it dangerous");
    BiNode* n2 = getNode("Does it eat meat?");
    BiNode* n3 = getNode("rabbit");
    BiNode* n4 = getNode("tiger");
    BiNode* n5 = getNode("swallow");
    BiNode* n6 = getNode("eagle");
     
    T->lchild = n1;  T->rchild = n2;
    n1->lchild = n3;  n1->rchild = n4;
    n2->lchild = n5;  n2->rchild = n6;
 
    return T;
}
int main(){
    // freopen("/config/workspace/answer/BiTreeFiles/test.in","r",stdin);
    BiTree T = setRecognizeSystem();
    BiNode *p = StartRecognize(T);
    if(p != nullptr)    cout << "the answer is：" << p->data << endl;
    return 0;
}
*/

问题 I: 静态链表存储的二叉树查找根节点

题目描述

用数组模拟实现链表的功能，即静态链表，也可以用来存储二叉树。
请编写程序，输出静态链表存储的二叉树的根节点

记录下哪个数字没出现过就行了。

#include <iostream>
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <queue>
#include <stack>
#include<algorithm> 
using namespace std;
int main()
{
    int n;
    while(cin>>n){
        if(n==0){
            int x;
            cin>>x;
            cout<<endl;
        }
        else{
        char a[555];
 
        int num[105]={0};
        for(int i=0;i<n;i++){
            cin>>a[i];
            char x,y;
            cin>>x>>y;
            if(x<='9'&&x>='0') num[x-'0']=1;
            if(y<='9'&&y>='0') num[y-'0']=1;
        }
        for(int i=0;i<10;i++) if(!num[i]){
            cout<<a[i]<<endl;
            break;
        }
        }
    }
 
    return 0;
}

问题 J: 基础实验4-2.1：树的同构

给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图2就不是同构的。现给定两棵树，请你判断它们是否是同构的。

dalao的思路。遍历每一个根节点和他的子树，如果不对称就No

#include <bits/stdc++.h>
using namespace std;
struct node{
    int l,r;
    char val;
}a[66],b[66];
map<char,int>mp;
char s1,s2,s3;
bool check(int x,int y){
    if(a[x].val!=b[y].val) return 0;
    if(a[a[x].l].val==b[b[y].l].val&&a[a[x].r].val==b[b[y].r].val) return 1;
    if(a[a[x].l].val==b[b[y].r].val&&a[a[x].r].val==b[b[y].l].val) return 1;
    return 0;
}
int main()
{
    int n,m;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>s1>>s2>>s3;
        //mp[s1]=i;
        a[i].val=s1;
        a[i].l=(s2=='-'?11:s2-'0');
        a[i].r=(s3=='-'?11:s3-'0');
    }
    cin>>m;
    if(m!=n){
        cout<<"No";
        //cout<<65;
        return 0;
    }
    for(int i=0;i<m;i++){
        cin>>s1>>s2>>s3;
        b[i].val=s1;
        mp[b[i].val]=i;
        b[i].l=(s2=='-'?11:s2-'0');
        b[i].r=(s3=='-'?11:s3-'0');
    }
    bool fl=1;
    for(int i=0;i<n;i++){
        if(!check(i,mp[a[i].val])){
            cout<<"No";
            return 0;
            fl=0;
        }
    }
    cout<<"Yes";
    return 0;
}

问题 K: 哈夫曼树--查找值最小的两个叶节点

题目描述

哈夫曼树的构造过程，最重要的是找到值最小的两个叶节点。

#include <bits/stdc++.h>
using namespace std;
int main()
{
    pair<int,int> a[10086];
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>a[i].first;
        a[i].second=i;
    }
    sort(a,a+n);
    cout<<a[0].second<<" "<<a[1].second;
    return 0;
}

问题 L: 静态链表存储的二叉树的非递归遍历算法-附加代码模式

用数组模拟实现链表的功能，即静态链表，也可以用来存储二叉树。
请编写程序，用非递归遍历算法输出静态链表存储前中后三种遍历结果。
本题为附加代码模式，以下代码为自动附加在同学们提交的代码后面。在本题的提示中有代码框架

不会了，copy大佬的。

#include <bits/stdc++.h>
using namespace std;
  
struct BiNode{
    char data;
    char lchild;
    char rchild;
    int flag = 0;
};
  
struct BiTree{
    int nodeNumber;
    BiNode data[10];
    int rootIndex; 
};
  
void FindRootIndex(BiTree &T){
    vector<char> v;
    for (int i = 0; i < T.nodeNumber; ++i) {
        if (T.data[i].lchild != '-') v.push_back(T.data[i].lchild-'0');
        if (T.data[i].rchild != '-') v.push_back(T.data[i].rchild-'0');
    }
    for (int i = 0; i < T.nodeNumber; ++i) {
        if (find(v.begin(), v.end(), i) == v.end()){
            T.rootIndex = i;
            return;
        }
    }
}
  
string getPreTraverseStr(const BiTree &T){
    if (T.nodeNumber <= 0) return "";
    string s;
    stack<BiNode> sta;
    sta.push(T.data[T.rootIndex]);
    while (!sta.empty()){
       BiNode t;
       t = sta.top();
       sta.pop();
       s += t.data;
       if (t.rchild != '-') sta.push(T.data[t.rchild-'0']);
       if (t.lchild != '-') sta.push(T.data[t.lchild-'0']);
    }
    return s;
}
  
string getInTraverseStr(const BiTree &T){
    if (T.nodeNumber <= 0) return "";
    string s;
    stack<BiNode> sta;
    sta.push(T.data[T.rootIndex]);
    while(!sta.empty()){
        if (sta.top().flag == 0){
            sta.top().flag++;
            if (sta.top().lchild != '-') {
                sta.push(T.data[sta.top().lchild - '0']);
            }
        }
        else{
            BiNode t;
            t = sta.top();
            sta.pop();
            s += t.data;
            if (t.rchild != '-')
                sta.push(T.data[t.rchild-'0']);
        }
  
    }
    return s;
}
  
string getSucTraverseStr(const BiTree &T){
    if (T.nodeNumber<=0) return "";
    string s;
    stack<BiNode> sta;
    sta.push(T.data[T.rootIndex]);
    while (!sta.empty()){
        if (sta.top().flag == 0){
            sta.top().flag++;
            if (sta.top().lchild != '-')
                sta.push(T.data[sta.top().lchild-'0']);
        }
        else if (sta.top().flag == 1){
            sta.top().flag++;
            if (sta.top().rchild != '-')
                sta.push(T.data[sta.top().rchild-'0']);
        }
        else{
            s += sta.top().data;
            sta.pop();
        }
    }
 
    return s;
}
/*
// please comment the following code when you sumbit to OJ
void InputBiTree(BiTree & T){
    cin >> T.nodeNumber;
    for(int i=0;i<T.nodeNumber;i++){
        cin >> T.data[i].data >> T.data[i].lchild >> T.data[i].rchild;
    }
}
int main(){
    //freopen("/config/workspace/answer/test.in","r",stdin);
    BiTree T;
    InputBiTree(T);
    FindRootIndex(T);
    string str = getPreTraverseStr(T);
    cout << str << endl;
    str = getInTraverseStr(T);
    cout << str << endl;
    str = getSucTraverseStr(T);
    cout << str << endl;
 
    InputBiTree(T);
    FindRootIndex(T);
    str = getPreTraverseStr(T);
    cout << str << endl;
    str = getInTraverseStr(T);
    cout << str << endl;
    str = getSucTraverseStr(T);
    cout << str << endl;
 
    return 0;
}*/

Qa666qa
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python 网络编程入门——用 Socket 做一个风花雪月服务器
Python作业辅导员 - 天元浪子
11-26 7846
理解 TCP/IP，是程序员从初阶到高阶的必由之路。然而，现在的程序员几乎没有多少实战机会接触到网络编程比较底层的部分。究其原因，一方面是因为流行的网络引擎框架提供了很好的封装，另一个原因是应用层面上多以 http/ftp 等协议为主，程序员不需要从 Socket 做起了。
基础算法题——两种遍历方式可以唯一确定一棵二叉树吗？
热门推荐
dreamiond的博客
11-07 1万+
按照数据结构课本上的说法： 前序遍历+中序遍历 后序遍历+中序遍历 可以唯一确定一棵二叉树。 反例： 1 1 / \ 1 1 上述两棵二叉树的前序序列和中序序列都为（1，1）...
数据结构实验--唯一的确定一棵二叉树
Cheney ' blog
10-31 824
一、问题描述 如果给出了遍历二叉树的前序序列和中序序列，则可以构造出唯一的一棵二叉树。试编写实现上述功能的程序。 【基本要求】 已知一棵二叉树的前序和中序序列，试设计完成下列任务的一个算法： （1）构造一棵二叉树； （2）证明构造正确（即分别以前序和中序遍历该树，将得到的结果与给出的序列进行比较）。 （3）对该二叉树进行后序遍历，输出后序遍历序列。 （4）用凹入法输出该二叉树。 【测试数据】 （1）前序序列为ABDEGCFHIJ，中序序列为DBGEAHFIJC。 （2）前序序列为-+abc/de，中序序列为
二叉树的构造(如何唯一确定一棵二叉树?附证明)
qq_57484399的博客
12-11 2721
通过构造二叉树的先序序列和中序序列,后序序列,我们可以发现,每一步都是有条不紊的,每一步都是分层次的,我们通过构造序列的过程,逆向可以构造出二叉树,就间接地证明了,这个定义的合法性.④ 根据中序序列的第二个节点，就可以确定下一层级的根节点，然后拿这个根节点去查找中序遍历的序列，就可以找到此层级的左子树和右子树，以此类推。③我们通过查找中序序列的根的左边的节点个数，就可以确定二叉树的左子树，根据根右边的节点个数，就可以确定二叉树的右子树。▪ 不同的二叉树可能具有相同的先序序列、中序序列和后序序列。
2022年计算机类数据结构作业7-树
m0_64694079的博客
10-31 324
2022年计算机类数据结构作业7-树
【如何唯一确定一棵二叉树】思想分析及步骤详解
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
04-08 3696
通过前序遍历+中序遍历确定一棵二叉树，通过#号法前序遍历确定一棵二叉树的思想分析及详细步骤。
WindowsMessage
码城的博客
06-30 924
Windows是一个消息（Message）驱动系统，它不是由事件的顺序来控制，而是由事件的发生来控制，而这种事件的发生是随机的、不确定的，并没有预定的顺序，这样就允许程序的用户用各种合理的顺序来安排程序的流程。任何事件的触发与响应均要通过消息的作用才能得以完成...
数据结构 java课件部分代码及实验
10-16
计算机规划教材 数据结构java版 第三版 叶核亚主编
计算机体系结构的分类模型_沈绪榜.pdf
02-28
很好，值得一看，讲的清楚，深刻，很好，值得一看，讲的清楚，深刻
(Java数据结构和算法
05-22
( Java数据结构和算法 ( Java数据结构和算法 ( Java数据结构和算法 ( Java数据结构和算法 ( Java数据结构和算法 ( Java数据结构和算法
mysql8中文参考手册.pdf
11-17
mysql
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 192
unordered_map实现输出前k个高频元素
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 421
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 765
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
24.5.26（树链剖分板子，二分+线段树）
breath_of_yuan的博客
05-27 837
思路：可看出峰值的数量是固定的，为 n/2-1，头尾不可为峰，连续俩数不能都为峰，假如我们让奇数位置的值为峰( 除了头，发现如果p的 n值在偶数位，且挨着1，是无法实现的，但其实也不难解决，将p翻转后 n下标的奇偶性就会改变( 最后输出前记得翻转 q。如果只有偶数子节点，那么0/1的选择是固定的，如果存在奇节点，所有偶节点可以取更大值，对于奇节点的选择，如果偶数个奇节点，0/1各一半，如果奇数个，多的那个取父节点的反，将奇点的 0/1 差值排个序，贪心即可。easy线段树题 建平台。补重庆科技 C 二分。
大气污染溯源算法及其技术实现
weixin_42496466的博客
05-29 1186
高斯分布由均值（μ）、方差（σ²）决定，公式为: [ f(x)=\frac{1}{\sqrt{2\pi\sigma^2}}e^{-\frac{(x-\mu)^2}{2\sigma^2}}]在环境模型中，高斯分布用来描述污染物浓度的概率分布，即在某一特定点的污染物浓度值的概率，随着距离污染源的距离增加而按高斯分布规律衰减小。相关性分析是统计学中一种重要的方法，用于研究两个或多个变量之间相互关系的性质，主要包括关系的方向（正相关或负相关）、强度以及是否存在线性。•偏相关：控制其他变量影响，分析两变量间净相关。
分析和设计算法
日积月累
05-29 257
分析和设计算法
偏微分方程算法之抛物型方程差分格式编程示例一
L_peanut的博客
05-27 226
主要对本专栏所介绍的抛物型偏微分方程的差分格式进行算例补充。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值