C++数据结构（第三四次实习）

已于 2022-10-11 18:05:54 修改
阅读量307 收藏
点赞数 2
分类专栏： 数据结构+算法 文章标签： c++ 数据结构 算法
于 2022-03-08 09:42:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51287641/article/details/121446161
版权

目录


本次实习主要关于树的操作，在这里简单记录一下，防止以后忘掉。

由于牛客网面试平台提交答案后无法查看，所以只能凭记忆简单描述一下题目要求

1.前，中，后序遍历输出

题目所用数据都为整型，且为完全二叉树所以选择通过数组实现
代码如下：

#include <iostream>

using namespace std;

class BinaryTree{
private:
    int *a;
    int maxSize;
public:
    BinaryTree(int sz){
        maxSize = sz;
        a = new int[maxSize+1];
    }
    ~BinaryTree(){delete a;}

    void Creat(){
        for(int i = 1;i <= maxSize;i++){
            cin >> a[i];
        }
    }

    void preOrder(int n){
        if(a[n] == 0 || n > maxSize){
            cout << "";
        }
        else{
            cout << a[n] << " " ;
            preOrder(2*n);
            preOrder(2*n+1);
        }
    }

    void inOrder(int n){
        if(a[n] == 0 || n > maxSize){
            cout << "";
        }
        else{
            inOrder(2*n);
            cout << a[n] << " ";
            inOrder(2*n+1);
        }
    }

    void postOrder(int n){
        if(a[n] == 0 || n > maxSize){
            cout << "";
        }
        else {
            postOrder(2*n);
            postOrder(2*n+1);
            cout << a[n] << " ";
        }
    }
};



int main()
{
    int m;
    cin >> m;
    BinaryTree *tree = new BinaryTree(m);
    tree->Creat();

    tree->preOrder(1);
    cout << endl;
    tree->inOrder(1);
    cout << endl;
    tree->postOrder(1);
    return 0;
}

2.由前序和中序遍历构造二叉树，并后续和层序输出

“递归狗都不用”，作为菜狗的我，毫不犹豫地选择了递归，希望等我下次看到笔记地时候，我已经用迭代把它重新解决了一遍。

这道题的思路为通过前序遍历确定根节点，然后在中序遍历中找到对应的根节点下标，下标之前则为左子树的中序遍历，之后则为右子树的中序遍历。

根据左子树和右子树的节点数，可以将前序遍历的左右子树划分出来，从而通过递归解决。

还是直接上代码，估计只有我自己能看懂，再次提醒一下自己养成写注释的习惯。

#include <iostream>
#include <queue>

using namespace std;

struct Node{
    int value;
    Node *left;
    Node *right;
    Node(int v = 0,Node *l = NULL,Node *r = NULL){
        value = v;
        left = l;
        right = r;
    }
};
class BinaryTree{
public:
    Node *root;
public:
    BinaryTree(){root = new Node();}
    ~BinaryTree(){}

    void postOrder(Node *n){
        if(n == NULL) return;
            postOrder(n->left);
            postOrder(n->right);
            cout << n->value << " ";
    }

    void levelOrder(Node *n){
        queue<Node*> q;
        q.push(n);
        while(!q.empty()){
            cout << q.front()->value << " ";
            if(q.front()->left != NULL) q.push(q.front()->left);
            if(q.front()->right != NULL) q.push(q.front()->right);
            q.pop();
        }
    }


};

 Node* Create(int *pre,int *in,int pre_left,int pre_right,int in_left,int in_right){
        if(pre_left > pre_right) return NULL;
        int pre_root = pre_left;
        int in_root;
        for(int i = in_left;i <= in_right;i++){
            if(in[i] == pre[pre_root]){
                in_root = i;
                break;
            }
        }
        int dis = in_root - in_left;
        Node *root = new Node(pre[pre_root],Create(pre,in,pre_left+1,pre_left+dis,in_left,in_root-1),Create(pre,in,pre_left+dis+1,pre_right,in_root+1,in_right));
        return root;
    }

int main()
{
    BinaryTree tree;
    int m;
    cin >> m;
    int *a = new int[m];
    int *b = new int [m];
    for(int i = 0;i < m;i++){
        cin >> a[i];
    }
    for(int i = 0;i < m;i++){
        cin >> b[i];
    }

    tree.root = Create(a,b,0,m-1,0,m-1);
    tree.levelOrder(tree.root);
    cout << endl;
    tree.postOrder(tree.root);
    return 0;
}

3.由中序和层序遍历构造二叉树，并前序和后续输出

这题在网上参考了其他大佬的代码，都是通过容器存放数据，但我的c艹是混过来的，所以打算用最原始的数组实现

结果现在看着这道题的代码自己都不想看了，只有一句我是傻逼，还是得把STL给补起来，不然以后每次写笔记都得来一句我是傻逼

主要思路是通过每次层序遍历的第一个元素都肯定为根节点，然后在中序遍历中找到对应根节点的下标，划分出左右子树，从而确定左右子树的层序遍历，返回根节点，这样就可以用递归解决了。

傻逼代码如下

#include <iostream>

using namespace std;

struct Node{
    int value;
    Node *left;
    Node *right;
    Node(int v = 0,Node *l = NULL,Node *r = NULL){
        value = v;
        left = l;
        right = r;
    }
};

class BinaryTree{
public:
    Node *root;
    BinaryTree(){root = new Node();}

    void preOrder(Node *n){
        if(n == NULL) return;
        cout << n->value << " ";
        preOrder(n->left);
        preOrder(n->right);
    }

    void postOrder(Node *n){
        if(n == NULL) return;
        postOrder(n->left);
        postOrder(n->right);
        cout << n->value << " ";
    }
//     void levelOrder(Node *n){
//        queue<Node*> q;
//        q.push(n);
//        while(!q.empty()){
//            cout << q.front()->value << " ";
//            if(q.front()->left != NULL) q.push(q.front()->left);
//            if(q.front()->right != NULL) q.push(q.front()->right);
//            q.pop();
//        }
//    }
};

Node *Create(int *level,int *in,int level_left,int level_right,int in_left,int in_right){
    if(level_left > level_right) return NULL;
    int level_root;
    int in_index;
    int k = 0;
    int next_level1,next_level2;
    level_root = level[level_left];
    for(int i = in_left;i <= in_right;i++){
        if(in[i] == level_root){
            in_index = i;
            break;
        }
    }
    int *left_level = new int[in_index-in_left];
    int *right_level = new int[in_right-in_index];
    for(int i = 1;i <= level_right;i++){
        for(int j = in_left;j < in_index;j++){
            if(level[i] == in[j]){
                left_level[k] = level[i];
                k++;
                break;
            }
        }
    }
    next_level1 = k-1;
    k = 0;
    for(int i = 1;i <= level_right;i++){
        for(int j = in_index+1;j <= in_right;j++){
            if(level[i] == in[j]){
                right_level[k] = level[i];
                k++;
                break;
            }
        }

    }
    next_level2 = k-1;
    Node *root = new Node(level_root,Create(left_level,in,0,next_level1,in_left,in_index-1),Create(right_level,in,0,next_level2,in_index+1,in_right));

    return root;

}

int main()
{
    BinaryTree tree;
//    int m = 6;
//    int a[m] = {1,2,3,5,6,7};
//    int b[m] = {2,5,1,6,3,7};
    int m;
    cin >> m;
    int *a = new int[m];
    int *b = new int[m];
    for(int i = 0;i < m;i++){
        cin >> a[i];
    }
    for(int i = 0;i < m;i++){
        cin >> b[i];
    }
    tree.root = Create(a,b,0,m-1,0,m-1);
    //cout << tree.root->value;
//    tree.levelOrder(tree.root);
//    cout << endl;
    tree.preOrder(tree.root);
    cout << endl;
    tree.postOrder(tree.root);
    return 0;
}

4.括号匹配多叉树并层序遍历输出

这道题还行，主要通过栈实现括号匹配之后，将括号内的子节点都接在此括号前的节点上，如此循环，直到将字符串读取完毕，然后返回根节点，最后通过队列实现层序遍历输出。

上代码

#include <iostream>
#include <queue>
#include <string>
#include <stack>

using namespace std;

struct Node{
    char value;
    Node *children[10];
    int chNum;
    Node(char v = '0'){
        value = v;
    }
};

class Tree{
public:
    Node *root;
    Tree(){
        root = new Node();
    }
    ~Tree(){}

    void levelSort(Node *n){
        queue<Node*> q;
        q.push(n);
        while(!q.empty()){
            Node *tem = q.front();
            q.pop();
            cout << tem->value;
            for(int i = 0;i < tem->chNum;i++){
                if(tem->children[i] != NULL) q.push(tem->children[i]);
            }
        }
    }
};

Node *Create(string str){
    stack<Node*> s1;
    stack<Node*> s2;
    for(int i = 0;i < str.length()-1;i++){
        if(str[i] == ')'){
            int num = 0;
            while(s1.top()->value != '('){
                num++;
                s2.push(s1.top());
                s1.pop();

            }
            s1.pop();
            s1.top()->chNum = num;

            for(int j = 0;j < num;j++){
                s1.top()->children[j] = s2.top();
                s2.pop();
            }
        }
        else{
            if(str[i] != ','){
                Node *in = new Node(str[i]);
                s1.push(in);
            }
        }
    }
    return s1.top();
}

int main()
{
    string str;
    Tree tree;
    cin >> str;
    tree.root = Create(str);
    tree.levelSort(tree.root);
    return 0;
}

5. 哈夫曼树编码

本题要求输入大写英文字母，并根据字母出现频率，确定权重，最后根据权重输出字母、权重、以及编码。

主要思路
getWeight()函数中通过大小为26的数组确定每个字母的频率，并将数据不为0 的丢入优先级队列priority_queue<Node*,vector<Node*>,com> q;，

通过Create()函数构造二叉树，将权重最小的两个节点作为一个新节点的左右子节点，并出队，然后将新节点入队，做n-1此循环，

最后通过Print()函数输出，其中通过父节点将每个节点所存的编码放入栈，存到根节点后，再将栈中编码遍历输出。

上代码

#include <iostream>
#include <queue>
#include <stack>

using namespace std;

struct Node{
    int weight;
    char value;
    int code;
    Node *left,*right,*farther;
    Node(int weight1 = 0,char value1 = '0',Node *left1 = NULL,Node *right1 = NULL){
        weight = weight1;
        value = value1;
        left = left1;
        right = right1;
    }

};
struct com{
    bool operator() (Node *n1,Node *n2){
        return n1->weight > n2->weight;
    }
};

class Huff{
private:
    Node *root;
    priority_queue<Node*,vector<Node*>,com> q;
public:
    Huff(){root = new Node();}

    void getWeight(int n){
        Node *temp;
        int a[26] = {0};
        char s;
        for(int i = 0;i < n;i++){
            cin >> s;
            a[s-'A']++;
        }
        for(int i = 0;i < 26;i++){
            if(a[i] != 0){
                temp = new Node(a[i],char(i+'A'));
                q.push(temp);
            }
        }
    }

    void Create(){
        Node *n1;
        Node *n2;
        Node *temp;
        int Size = q.size();
        for(int i = 0;i < Size-1;i++){
            n1 = q.top();
            q.pop();
            n2 = q.top();
            q.pop();
            if(n1->weight < n2->weight){
                temp = new Node(n1->weight+n2->weight,'0',n2,n1);
                n1->farther = temp;
                n2->farther = temp;
                n1->code = 0;
                n2->code = 1;
            }
            else{
                temp = new Node(n1->weight+n2->weight,'0',n1,n2);
                n2->farther = temp;
                n1->farther = temp;
                n2->code = 0;
                n1->code = 1;
            }
            q.push(temp);
        }
        root = q.top();
    }

    void Print(){
        queue<Node*> que;
        stack<int> s;
        Node *current;
        que.push(root);
        while(!que.empty()){
            if(que.front()->left==NULL && que.front()->right==NULL){
                cout << que.front()->value << " " << que.front()->weight << " ";
                current = que.front();
                while(current != root){
                    s.push(current->code);
                    current = current->farther;
                }
                while(!s.empty()){
                    cout << s.top();
                    s.pop();
                }
                cout << endl;
            }
            if(que.front()->left != NULL) que.push(que.front()->left);
            if(que.front()->right != NULL) que.push(que.front()->right);
            que.pop();
        }
    }
};


int main()
{
    Huff tree;
    int m;
    cin >> m;
    tree.getWeight(m);
    tree.Create();
    tree.Print();
    return 0;
}

2021.11.20

如果我是海
关注
专栏目录
solve函数程序详解(NOIP2004 提高组)
codingheroman的博客
09-22 7548
此题为笔试题的读程序题。 题目程序代码如下： #include&lt;iostream&gt; using namespace std; int number,ndata,data[100],sum; void solve(int s,int sign,int n){ int i; for(i=s;i&lt;ndata;i++){ sum+=sign*(number/n/data[i...
c++ 数据结构——二叉树的构建及其应用，实现左右子树交换并输出前序递归结果
Arana的博客
04-06 3396
数据结构实习——二叉树及其应用 一、实习题目及要求 1、题目： 二叉树基本算法的实现 2、功能要求： （1）键盘输入二叉树结点前序序列，创建一棵二叉树； （2）实现SwapTree方法，以根结点为参数，交换每个结点的左子树和右子树（提示：前序递归）； （3）实现Find方法，查找值为key的结点，并输出该结点的所有祖先结点。 3、创建要求： （1）要求键盘输入二叉树前序序列（程序5.12） （2...
1202
weixin_45476788的博客
07-31 207
#include<iostream> using namespace std; int a[1000100]; int main() { int n,x,i; a[1]=1; a[2]=2; for(i=3;i<=1000000;i++) a[i]=((2*a[i-1])+a[i-2]) % 32767; cin>&g...
C++ 语法基础课 习题4 —— 数组
qq_42731062的博客
11-19 1652
数组
Java数组：一维数组中元素移动问题
m0_46695871的博客
05-30 1574
描述 【描述】 给定一组整数，要求利用数组把这组数保存起来，实现对数组中的数循环移动。假定共有n个整数，则要使前面各数顺序向后移m个位置，并使最后m个数变为最前面的m个数。 要求只用一个数组的方式实现，一定要保证在输出结果时，输出的顺序和数组中数的顺序是一致的。 【输入】 第一行包含一个正整数n和一个正整数m，n和m以空格间隔。 第二行包含n个正整数，整数以空格间隔。 【输出】 依次输出经过循环移动后数组中元素值，元素值以空格间隔。 【输入示例】 11 4 15 3 76 67 84 87 13 67 45
生成1-N*N的矩阵，一圈一圈的
haoshen's blog
04-03 1280
#include using namespace std; int N; int data[100][100]; bool visit[100][100]; void getNext(int status, int& nx, int &ny) { switch (status) { case 0: //right nx = 0, ny = 1; break; case 1:
数据结构实习报告C++
06-08
### 数据结构实习报告知识点概述 #### 一、实习作业说明及要求 - **作业选择**：实习生可以从提供的题目中选择一题，或者自行选择题目。为了确保实习作业的质量，建议自选题目的难度应不低于提供的题目。 - **团队...
数据结构上机实习 唯一确定一颗二叉树
02-21
### 数据结构上机实习知识点详解 #### 一、题目背景及目标 本次上机实习的主要目的是根据给定的前序序列和中序序列构造出一棵唯一的二叉树，并通过多种方式验证构造结果的正确性。此外，还需要了解如何通过中序...
数据结构 c++编写实习2
03-18
这是数据结构的实习。用双向列表解决多项式相加及存储问题。第一次做，可能比较简陋。
第一次数据结构实习。。。
在雾里行走的人。。。。。。。
01-18 954
            今天是8点到12点实习数据结构。昨天快2点才睡。。。。。最近发现我不怎么想睡觉了，不停的在看书，没办法想当程序员是要付出代价的。。。。。。。昨天竟然下雪了。。。。下了很大很大很大的雪，心里很高兴。。。呵呵我还是喜欢纯纯的色彩啊           早上一起来便收拾好本本，带去科教楼开始实习。。。。。。刚进里面便感觉很暖和，毕竟外面可正在下雪啊，今天对自己的要求也不搞，搞
C++基础
最新发布
qq_39223444的博客
05-20 1187
C++相较于C语言特有的三大特性：封装、继承、多态等内容，命名空间。
基础知识&左值&this指针
Accowo的博客
10-05 599
左值代表着一块可以被更新的内存区域，可以被取地址，右值不能被取地址。 内存泄漏是调用了malloc/new等内存申请操作，但是缺少对应的free/delete来释放内存。 类的定义不会引起数据的内存分配，实例化对象才会给这个对象分配存储空间。（类对象所占的存储空间等于它的数据成员所占的空间（不包含成员函数代码所占的空间），每个类对象都有自己的数据成员。） 类的声明 //定义两个类A和类B, 类A中有一个指向类B对象的指针，类B中有一个类A的对象。 #include <stdio.h&g..
用循环链表求解约瑟夫环问题
hnjzsyjyj的专栏
09-28 2435
【约瑟夫环问题】 模型构建：因为是圆桌问题，使用链表解决的话需要构建循环链表。 出列问题：设计思路是将指向链表的指针移动到需要出列的人的位置，然后根据正常的链表删除进行操作即可。
C++对象创建与释放
热门推荐
奔放的菜鸟
04-03 2万+
创建对象有以下四种形式： #include using namespace std; class A{ private: int i; public: A(){ cout<<"调用没有参数的构造函数"<<endl; } A(int a):i(a){ cout<<"调用有一个参数的构造函数"<<endl; } ~A(){cout<<"成员变量为:"<<i<<"\t调用析构函数"<<en
C++学习笔记 类和对象(二)
L200378098的博客
06-30 967
类与对象知识点
数据结构上机实习 一元稀疏多项式运算器
02-21
### 数据结构上机实习知识点详解 #### 一、实习题目与要求 本次实习的主要目标是设计并实现一个**一元稀疏多项式运算器**。具体的要求包括： 1. **输入并建立两个多项式**：用户需输入两个一元稀疏多项式的系数和...
C++实例（三）数据结构
yang_jianfeng的博客
09-29 269
数据结构 一、结构体 二、指针、地址与引用 三、数组
2022第二周周赛题解
qq_52752908的博客
03-06 817
A.Binary Tree 题意 根为（a,b），则左孩子为（a+b,b），右孩子为（a,a+b）。给定（m,n），初始根为（1,1）,从（1,1）到（m,n）需要往左子树走几次，往右子树走几次。 解题思路 思路一：逆向思维，从（m,n）到（1,1）。给定（m,n），求其父亲，如果m>n，则他父亲是（m-n,n），否则（m,n-m）。但是这种方法会超时。 思路二：用除法代替减法，得到的商即为往左走的次数，最后的m=m%n。n>m时情况类推。需要特别注意的是：如果m>n,m%n == 0 怎
顺序二叉树三序输出
xiaogoumaogou的专栏
08-12 464
#include #include using namespace std;int BiTree[100];int C;int CreateBiTree(){ for(int i=1;i  if(scanf("%d",&BiTree[i]) == EOF)   return i-1; return 1;}void PreOrder(int N){ if(N  {  printf("%d "
关于node N= (node){l,r,sum} 和node N= node(l,r,sum)
u012659423的专栏
07-17 803
以前不知在哪看了node N= （node）｛l, r, sum｝
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值