B-树(B-Tree)的C++演示代码

本文提供了B-树(B-Tree)的C++实现,包括搜索、插入、删除等操作。代码遵循算法导论中的伪代码,特别地,文章详细解释了删除过程。虽然B-树主要用于硬盘存储,但这里简化为仅在内存中操作。代码包括BTreeNode类和BTree类的定义,以及相关操作函数的实现。
摘要由CSDN通过智能技术生成

 B-树(B-Tree)的C++演示代码

    按照算法导论中伪代码转化,其中删除过程算法导论没有给出伪代码,所以对删除相关函数做了说明。另外B-Tree本来是用于硬盘的,但为了简便只阐明B-Tree的基本流程,没有加入硬盘扇区的直接读写操作,全部在内存中进行。

1.头文件(B-Tree.h)

#ifndef BTREE__JOHN__DMRC
#define BTREE__JOHN__DMRC
/*************************** Class BTreeNode ***************************/
template <typename T>
class BTreeNode{
public:
 BTreeNode(int, bool);
 ~BTreeNode();

// Varies
 int t;
 int len;
 bool leaf;
 T* key;
 BTreeNode<T>** child;
};

/**************************** Class BTree ******************************/
template <typename T>
class BTree{
public:
 BTree(int);
 ~BTree();
 bool BTree_Search(T);
 void BTree_Insert(T);
 bool BTree_Delete(T);
 // debug start
 void print_root();
 // debug end
private:
 bool btree_search(BTreeNode<T>*, T);
 void delete_tree(BTreeNode<T>*);
 void btree_split_child(BTreeNode<T>*, int, BTreeNode<T>*);
 void btree_insert_nonfull(BTreeNode<T>*, T);
 void btree_merge_child(BTreeNode<T>*, int);
 void btree_rotate_child(BTreeNode<T>*, int, bool);
 bool btree_delete_nonfew(BTreeNode<T>*, T);
 BTreeNode<T>* root;
 int t;
};

#endif

2 cpp文件(B-Tree.cpp)

#include "B-Tree.h"

/*************************** Class BTreeNode ***************************/
template <typename T>
BTreeNode<T>::BTreeNode(int a, bool b){
 this ->t = a;
 this ->len = 0;
 this ->leaf = b;
 this ->key = new int[2 * a - 1];
 this ->child = new BTreeNode*[2 * a];
}

template <typename T>
BTreeNode<T>::~BTreeNode(){
 delete [] this ->key;
 delete [] this ->child;
}

/**************************** Class BTree ******************************/
// C & D
template <typename T>
BTree<T>::BTree(int a){
 this ->t = a;
 this ->root = new BTreeNode<T>(a, true);
}

template <typename T>
BTree<T>::~BTree(){
 this ->delete_tree(this ->root);
}

template <typename T>
void BTr

构造哈夫曼是一种经典的形编码方法,主要用于数据压缩和编码领域。构造哈夫曼的过程主要分为以下几个步骤: 1. 统计字符出现频率:首先需要统计待编码文本中每个字符出现的频率,可以通过遍历文本字符来实现。将字符频率存储于一个数组或者字典中。 2. 构建哈夫曼:基于字符频率,可以选择合适的数据结构来存储和构建哈夫曼。在构建过程中,首先将每个字符频率作为一个独立的叶子节点,然后再通过合并最小频率的节点来构造。 3. 分配编码:根据构建好的哈夫曼,给每个字符分配一个唯一的编码。从根节点开始,标记左子为0,右子为1,遍历哈夫曼至叶子节点,即可得到每个字符的编码。为了方便查找和使用编码,可以使用数组或者字典来存储字符和其编码的对应关系。 4. 编写编码代码:根据步骤3中得到的字符和编码的对应关系,编写编码函数来实现文本编码。编码函数接受待编码的文本作为输入,然后将文本中的每个字符替换为其对应的编码。 下面是一个简单的C代码示例来演示哈夫曼的构建和编码过程: ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { char character; int frequency; struct Node* left; struct Node* right; } Node; // 构建哈夫曼 Node* buildHuffmanTree(char* characters, int* frequencies, int n) { Node** nodes = (Node**)malloc(sizeof(Node*) * n); for(int i = 0; i < n; i++) { nodes[i] = (Node*)malloc(sizeof(Node)); nodes[i]->character = characters[i]; nodes[i]->frequency = frequencies[i]; nodes[i]->left = NULL; nodes[i]->right = NULL; } // 构建哈夫曼 while(n > 1) { Node* min1 = nodes[0]; int min1Index = 0; for(int i = 1; i < n; i++) { if(nodes[i]->frequency < min1->frequency) { min1 = nodes[i]; min1Index = i; } } Node* min2 = nodes[0 == min1Index ? 1 : 0]; int min2Index = 0 == min1Index ? 1 : 0; for(int i = 0; i < n; i++) { if(i != min1Index && nodes[i]->frequency < min2->frequency) { min2 = nodes[i]; min2Index = i; } } Node* parent = (Node*)malloc(sizeof(Node)); parent->character = '\0'; parent->frequency = min1->frequency + min2->frequency; parent->left = min1; parent->right = min2; nodes[min1Index] = parent; for(int i = min2Index; i < n - 2; i++) { nodes[i] = nodes[i + 1]; } nodes[n - 2] = parent; n--; } return nodes[0]; } // 分配编码 void assignCode(Node* tree, char** codes, char* code, int depth) { if(tree->left == NULL && tree->right == NULL) { codes[tree->character] = code; return; } code[depth] = '0'; code[depth + 1] = '\0'; assignCode(tree->left, codes, code, depth + 1); code[depth] = '1'; code[depth + 1] = '\0'; assignCode(tree->right, codes, code, depth + 1); } // 编码函数 char* encodeText(char* text, char** codes) { int textSize = strlen(text); int totalCodeLength = 0; char* encodedText = (char*)malloc(sizeof(char) * (textSize * 8 + 1)); for(int i = 0; i < textSize; i++) { char* code = codes[text[i]]; int codeLength = strlen(code); for(int j = 0; j < codeLength; j++) { encodedText[totalCodeLength] = code[j]; totalCodeLength++; } } encodedText[totalCodeLength] = '\0'; return encodedText; } int main() { // 示例数据 char characters[] = {'A', 'B', 'C', 'D', 'E'}; int frequencies[] = {2, 3, 4, 6, 8}; int n = sizeof(characters) / sizeof(char); // 构建哈夫曼 Node* huffmanTree = buildHuffmanTree(characters, frequencies, n); // 分配编码 char* codes[256]; char* code = (char*)malloc(sizeof(char) * 256); assignCode(huffmanTree, codes, code, 0); // 编码文本 char* text = "ABCDAEBD"; char* encodedText = encodeText(text, codes); printf("原始文本:%s\n", text); printf("编码后的文本:%s\n", encodedText); return 0; } ``` 注意,这只是一个简单的示例代码,实际应用中可能还需要考虑更多的边界条件和错误处理。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值