数据结构作业13

已于 2022-12-30 13:12:47 修改
阅读量465 收藏 2
点赞数
分类专栏： 数据结构作业 文章标签： 数据结构 算法
于 2022-12-08 23:04:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_60538401/article/details/128245279
版权

问题 A: Hash表-线性探测法解决冲突

题目描述

给定一个长度为10，标号为[0..9]的存储表
给定一组关键字，你需要把这组数据以规定的方法放进存储表中
首先把关键字的后四位数字求和，该和对10求模，然后按照求模结果，放进存储表中对应标号的位置。
（例如，求模结果是2，则这个关键字应该放在存储表中标号为2的位置）

但是，不同的关键字可能会产生相同的求模结果，本题要求用线性探测法解决冲突。
那么你需要在存储表中为较晚输入的关键字探测到一个空闲位置，该探测方法为标号+1、-1、+2、-2、+3、-3...
例如当前求模结果依然是2，但是标号为2的位置已经被占用了，那么首先对该求模结果+1得到3，如果标号为3的位置是空闲，则把该关键字放进标号为3的位置中。
如果标号为3的位置依然被占用了或者不存在，则改为-1、+2、-2、+3、-3...以此类推。


最终按行输出存储表中每一个位置内存储的关键字，如果为空，则输出#

输入格式

第一行是一个整数n，表示接下来会输入的n个关键字
接下来是n个关键字，按行输入
(n小于等于10)

输出格式

按行输出存储表中每一个位置内存储的关键字，如果为空，则输出#

输入样例 复制

6
PV1031
STM1104
PV0301
TI0103
STM0012
TI1205

输出样例 复制

#
#
STM0012
TI0103
PV0301
PV1031
STM1104
#
TI1205
#

code

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define MAX_SIZE 15

string save[10];
int visited[MAX_SIZE]={0};
int main(){
    int n;cin>>n;
    for(int i=0;i<10;i++){
        save[i]="#";
    }
    while(n--){
        string s;cin>>s;
        int len=s.length();
        int sum=0;
        for(int i=len-1;i>=len-4;i--){
            sum+=s[i]-'0';
        }
        sum%=10;
        if(visited[sum]==0){
            save[sum]=s;
            visited[sum]=1;
        }
        else{
            int temp=1;
            while(1){
                if(visited[sum+temp]==0){
                    save[sum+temp]=s;
                    visited[sum+temp]=1;
                    break;
                }         
                if(temp>0) temp=temp*(-1);
                else temp=temp*(-1)+1;
            }
        }
    }   
    for(int i=0;i<10;i++){
        cout<<save[i]<<endl;
    } 
}

问题 B: 求3阶B-树的深度 

题目描述

给定n个正整数，请构造3阶B-树，输出深度

输入格式

第一行为正整数n（n<20)
第二行是空格分割的n个不重复的正整数

输出格式

一个正整数，3阶B-树的深度

输入样例 复制

1
2

输出样例 复制

1

code

前面用了C题代码构建B树

int DepthBtree(BTreeNode* root){
    if(root->isLeaf) return 1;
    return DepthBtree(root->children[0])+1;
}

int main(){
    BTree B;
    B.degree=3;
    B.root=nullptr;
    int n;cin>>n;
    for(int i=0;i<n;i++){
        int t;cin>>t;
        Insert(B,t);
    }
    cout<<DepthBtree(B.root);
    return 0;
}

 问题 C: 输出3阶B-树的构造过程

题目描述

给定n个正整数，请构造3阶B-树，输出构造过程

输入格式

第一行为正整数n（n<20)
第二行是空格分割的n个不重复的正整数

输出格式

输出构造过程。
采用深度优先遍历的方法，从B树的根节点（第0层）开始输出所有节点。每个节点的输出包括空格和关键字两部分。针对每个节点，首先根据节点所在的层数level，输出level*4个空格，然后用空格隔开输出这个节点的所有关键字，最后换行。

输入样例 复制

12
45 32 16 77 94 38 44 21 39 68 33 26

输出样例 复制

====insert a key:45
45 
==================
====insert a key:32
32 45 
==================
====insert a key:16
32 
    16 
    45 
==================
====insert a key:77
32 
    16 
    45 77 
==================
====insert a key:94
32 77 
    16 
    45 
    94 
==================
====insert a key:38
32 77 
    16 
    38 45 
    94 
==================
====insert a key:44
44 
    32 
        16 
        38 
    77 
        45 
        94 
==================
====insert a key:21
44 
    32 
        16 21 
        38 
    77 
        45 
        94 
==================
====insert a key:39
44 
    32 
        16 21 
        38 39 
    77 
        45 
        94 
==================
====insert a key:68
44 
    32 
        16 21 
        38 39 
    77 
        45 68 
        94 
==================
====insert a key:33
44 
    32 38 
        16 21 
        33 
        39 
    77 
        45 68 
        94 
==================
====insert a key:26
32 44 
    21 
        16 
        26 
    38 
        33 
        39 
    77 
        45 68 
        94 
==================

code

// 3阶B-树的构造代码框架

#include <queue>
#include <iostream>
#include <cstdio>
using namespace std;
#define MAXSIZE 4

// B树结点的结构体定义
struct BTreeNode{
    int n; // 关键字个数
    bool isLeaf; //是否叶结点
    int keys[MAXSIZE]; // 有序关键字序列
    BTreeNode* children[MAXSIZE]; // 子结点集合
    BTreeNode* parent; // 父结点
    int level; // 层数，用于层次遍历
};

// 初始化节点，确保每个数据都有初始值
BTreeNode* getInitNode(){
    BTreeNode* node = new BTreeNode();
    node->isLeaf = true;
    node->n = 0;
    node->parent = nullptr;
    for(int i=0;i<MAXSIZE;i++){
        node->children[i] = nullptr;
        node->keys[i] = 0;
    }
    node->level = 0;
    return node;
}

// B树结构体定义
struct BTree{
    BTreeNode* root; // B树的根结点
    int degree; // B树的维数
};

// 深度优先遍历B树
void DFS(const BTreeNode* root){
    for(int i=0;i<root->level;i++) cout<<"    ";
    for(int i=0;i<root->n;i++) cout<<root->keys[i]<<" ";
    cout<<endl;
    if(root->isLeaf) return;
    for(int i=0;i<root->n+1;i++){
        root->children[i]->level=root->level+1;
        DFS(root->children[i]);
    }
}

// 先用层次遍历的思想求每个节点的层数，再用深度优先遍历的方法输出BTree
void PrintBTree(BTree& B){
    DFS(B.root);
}

// 查找插入关键字key的节点
BTreeNode* findNodeToInsertKey( BTreeNode* root, int key){
    int i=0;
    for(i=0;i<root->n;i++){
        if(root->keys[i]>=key){
            break;
        }
    }
    if(root->isLeaf) return root;
    else return findNodeToInsertKey(root->children[i],key);
}

// 在节点中插入关键字，并返回关键字在keys数组中的下标，用于更新字节点下标
// 可能在叶节点插入，也有可能在非叶节点插入（分裂操作）
int InsertKeyToNode(BTreeNode*& node, int key){
    // 关键字按照升序排列
    int index = node->n;
    while(index >= 1 && node->keys[index-1] > key){
        node->keys[index] = node->keys[index-1];
        node->children[index+1] = node->children[index];
        index--;
    }
    node->keys[index] = key;
    node->n++;
    return index;
}

// 分裂操作：将节点一分为二
void SplitNode(BTree& B, BTreeNode*& node){
    BTreeNode* temp = node;
    BTreeNode* node1 = getInitNode();
    BTreeNode* node2 = getInitNode();
    node1->n = node2->n = 1;
    node1->isLeaf = node2->isLeaf = node->isLeaf;

    // 新构造的2个节点，父子指针
    node1->keys[0] = (node->keys[0]);
    node1->children[0] = node->children[0];
    node1->children[1] = node->children[1];
    if(node1->children[0] != nullptr) node1->children[0]->parent = node1;
    if(node1->children[1] != nullptr) node1->children[1]->parent = node1;
    node2->keys[0] = (node->keys[2]);
    node2->children[0] = node->children[2];
    node2->children[1] = node->children[3];
    if(node2->children[0] != nullptr) node2->children[0]->parent = node2;
    if(node2->children[1] != nullptr) node2->children[1]->parent = node2;
    BTreeNode* parent = node->parent;
    if(parent == nullptr){// 父节点是空节点，表示是在根结点分裂
        parent = getInitNode();
        parent->isLeaf = false;
        parent->n = 1;
        parent->keys[0] = node->keys[1];
        parent->children[0] = node1;
        parent->children[1] = node2;
        node1->parent = node2->parent = parent;
        B.root = parent;
    }else{//在父节点中插入一个新关键词，更新子节点指针
        int index = InsertKeyToNode(parent, node->keys[1]);
        parent->children[index] = node1;
        parent->children[index+1] = node2;
        node1->parent = node2->parent = parent;
        if(parent->n == B.degree){// 继续分裂
            SplitNode(B, parent);
        }
    }
    delete temp;
}

// 在B-树中插入关键字key
void Insert(BTree& B, int key){
    if(B.root == nullptr){
        B.root = getInitNode();
        B.root->keys[0] = key;
        B.root->n = 1;
    }else{
        BTreeNode* node = findNodeToInsertKey(B.root, key);
        InsertKeyToNode(node, key);
        if(node->n == B.degree){
            SplitNode(B, node);
        }
    }
}

int main(){
    freopen("/config/workspace/answer/test.in", "r", stdin);
    BTree B;
    B.degree = 3;
    B.root = nullptr;
    int n; cin >> n;
    for(int i=0;i<n;i++){
        int t; cin >> t;
        cout << "====insert a key:" << t << endl;
        Insert(B, t);
        PrintBTree(B);
        cout << "==================" << endl;
    }
    return 0;
}

问题 D: Hash表-链表法解决冲突

题目描述

给定一个长度为10，标号为[0..9]的存储表
给定一组关键字，你需要把这组数据以规定的方法放进存储表中
首先把关键字的后四位数字求和，该和对10求模，然后按照求模结果，放进存储表中对应标号的位置。
（例如，求模结果是2，则这个关键字应该放在存储表中标号为2的位置）

但是，不同的关键字可能会产生相同的求模结果，用链表法解决冲突。
注意在存储的链表表中，把较晚输入的关键字拼接在原来此处关键字的前面，用空格分隔。

最终按行输出存储表中每一个位置内存储的关键字，如果为空，则输出#

输入格式

第一行是一个整数n，表示接下来会输入的n个关键字
接下来是n个关键字，按行输入
(n小于等于30)

输出格式

按行输出存储表中每一个位置内存储的关键字，如果为空，则输出#

输入样例 复制

6
PV1031
STM1104
PV0301
TI0103
STM0012
TI1205

输出样例 复制

#
#
#
STM0012
TI0103 PV0301
PV1031
STM1104
#
TI1205
#

code

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define MAX_SIZE 15

struct Node{
    string s;
    Node* next;
}save[10];//头节点

int main(){
    int n;cin>>n;
    for(int i=0;i<10;i++){
        save[i].s="#";
        save[i].next=NULL;
    }
    while(n--){
        string str;cin>>str;
        int len=str.length();
        int sum=0;
        for(int i=len-1;i>=len-4;i--){
            sum+=str[i]-'0';
        }
        sum%=10;

        //头插法
        Node *t=(Node*)malloc(sizeof(Node));    //!!!!!!!!!!!!
        t->s=str;
        t->next=save[sum].next;
        save[sum].next=t;

    }   

    for(int i=0;i<10;i++){
        if(save[i].next==NULL) cout<<"#"<<endl;
        else{
            Node* p;
            p=save[i].next;
            while(p){
                cout<<p->s<<" ";
                p=p->next;
            }
            cout<<endl;
        }
    } 
}
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值