树的存储文件

㈠ 如何将B+树存储在磁盘中

楼主问的数据写内存和写磁盘的区别1.内存存取比较快2.磁盘存取数据是持久的，内存数据在程序关闭或者无引用被垃圾回收，是短时存在的。主要的区别就是这些吧。
关于写入磁盘上，就是将内存中的数据存入磁盘的实体文件或数据库中。

㈡ 树的存储结构转换

//声明树中的类以及结点结构，文件名为tree.h
#ifndef TREE_H
#define TREE_H

template <class T>//树中结点采用孩子兄弟表示法
struct TNode
{
T data;
TNode<T> *firstchild, *rightsib;
};

template <class T>
class Tree
{
public:
Tree( ); //构造函数，初始化一棵树，其前序序列由键盘输入
~Tree(void); //析构函数，释放树中各结点的存储空间
TNode<T>* Getroot( ); //获得指向根结点的指针
void PreOrder(TNode<T> *root); //前序遍历树
void PostOrder(TNode<T> *root); //后序遍历树
void LeverOrder(TNode<T> *root); //层序遍历树
private:
TNode<T> *root; //指向根结点的头指针
void Release(TNode<T> *root); //析构函数调用
};

#endif

//定义类中的成员函数，文件名为tree.cpp
#include<iostream>
#include<string>
#include"tree.h"
using namespace std;
/*
*前置条件：树不存在
*输 入：无
*功 能：构造一棵树
*输 出：无
*后置条件：产生一棵树
*/

template<class T>
Tree<T>::Tree( )
{
const int MaxSize = 100;
int end = 0;
int front = 0;
int rear = 0; //采用顺序队列，并假定不会发生上溢
int j = 0;
TNode<T>* queue[MaxSize]; //声明一个队列
TNode<T>* tempNode; //声明指向结点类型的指针
TNode<T>* brotherNode; //工作指针
TNode<T>* q;
T ch;
cout<<"请输入创建一棵树的根结点数据"<<endl;
cin>>ch;
root = new TNode<T>;
root->data = ch;
root->firstchild = NULL;
root->rightsib = NULL;
queue[rear++] = root;
while (!end) //若继续创建树
{
T ch1,ch2;
cout<<"请输入创建一棵树的父结点数据和孩子结点数据"<<endl;
cin>>ch1>>ch2;
TNode<T>* p = new TNode<T>; //生成一个结点
p->data = ch2;
p->firstchild = NULL;
p->rightsib = NULL;
queue[rear++] = p;
tempNode = queue[front];//头结点出队，同时对头元素的标识符后移
while(ch1 != tempNode->data)
tempNode = queue[front++];
if(tempNode->firstchild == NULL) tempNode->firstchild = p;
else{
brotherNode = tempNode->firstchild; //工作指针指向结点的第一个孩子
while (brotherNode != NULL) //若第一个孩子有兄弟结点
{
q = brotherNode;
brotherNode = brotherNode->rightsib;//工作指针指向第一个孩子的右兄弟
}
q->rightsib = p;
}
cout<<"创建结束? 如果结束请按1否则请按0 "<<endl;
cin>>end;
}
}
/*
*前置条件：树已存在
*输 入：无
*功 能：释放树中各结点的存储空间
*输 出：无
*后置条件：树不存在
*/
template<class T>
Tree<T>::~Tree(void)
{
Release(root);
}
/*
*前置条件：树已存在
*输 入：无
*功 能：获取指向树根结点的指针
*输 出：指向树根结点的指针
*后置条件：树不变
*/
template<class T>
TNode<T>* Tree<T>::Getroot( )
{
return root;
}
/*
*前置条件：树已存在
*输 入：无
*功 能：前序遍历树
*输 出：树中结点的一个线性排列
*后置条件：树不变
*/
template<class T>
void Tree<T>::PreOrder(TNode<T> *root) //前序遍历树
{
if (root == NULL) return; //递归调用的结束条件
else{
cout<<root->data; //打印根节点
PreOrder(root->firstchild); //前序递归遍历root的第一个孩子
PreOrder(root->rightsib); //前序递归遍历root的右兄弟
}
}
/*
*前置条件：树已存在
*输 入：无
*功 能：后序遍历树
*输 出：树中结点的一个线性排列
*后置条件：树不变
*/
template<class T>
void Tree<T>::PostOrder(TNode<T> *root)
{
if (root == NULL) return; //递归调用的结束条件
else{
PostOrder(root->firstchild); //后序递归遍历root的第一个孩子
cout<<root->data; //打印出root结点
PostOrder(root->rightsib); //后序递归遍历root的右兄弟
}
}
/*
*前置条件：树已存在
*输 入：无
*功 能：层序遍历树
*输 出：树中结点的一个线性排列
*后置条件：树不变
*/
template<class T>
void Tree<T>::LeverOrder(TNode<T> *root)
{
const int MAX_QUEUE_SIZE = 100;
int front = 0;
int rear = 0; //采用顺序队列，并假定不会发生上溢
TNode<T>* queue[MAX_QUEUE_SIZE]; //声明一个队列
TNode<T>* tempNode; //声明指向结点类型的指针
TNode<T>* brotherNode; //工作指针

if (root == NULL) return;//循环结束条件
queue[rear++] = root; //否则结点入队
while (front != rear) //若队列中有结点
{
tempNode = queue[front++];//头结点出队，同时对头元素的标识符后移
cout<<tempNode->data; //打印出头结点
brotherNode = tempNode->firstchild; //工作指针指向结点的第一个孩子
while (brotherNode != NULL) //若第一个孩子有兄弟结点
{
queue[rear++] = brotherNode; //第一个孩子结点入队
brotherNode = brotherNode->rightsib;//工作指针指向第一个孩子的右兄弟
}
}
}
/*
*前置条件：树已经存在
*输 入：无
*功 能：释放树的存储空间，析构函数调用
*输 出：无
*后置条件：树不存在
*/
template <class T>
void Tree<T>::Release(TNode<T>* root)
{
if (root != NULL){
Release (root->firstchild); //释放第一个孩子
Release (root->rightsib); //释放右兄弟
delete root;
}
}
//有关树的实现的主函数，文件名为treemain.cpp
#include <iostream>
#include <string>
#include"tree.cpp"
using namespace std;

void main()
{
Tree<string> t; //创建一棵树
TNode<string>* p = t.Getroot( ); //获取指向根结点的指针
cout<<"------前序遍历------ "<<endl;
t.PreOrder(p);
cout<<endl;
cout<<"------后序遍历------ "<<endl;
t.PostOrder(p);
cout<<endl;
cout<<"------层序遍历------ "<<endl;
t.LeverOrder(p);
cout<<endl;
}

㈢ 树的存储结构

常用的有：1、双亲表示，2、孩子链表表示，3、双亲孩子链表表示，4、孩子兄弟链表表示

㈣ 数据结构，树的常用存储方式

存入文本文件，每行：孩子节点-父节点。
这样也方便用Hadoop进行处理。

㈤ 怎么将一个树保存到文件里

你这样保存，kd_node结构体中kd_left,kd_right中保存的是指针，当然会出错。你应该把结构体写到数组中。kd_left,kd_right中保存数组下标就行 了

㈥ 怎样把树存到磁盘中

树就是一个数据结构的链表，你把链表使用二进制流存到硬盘中，下次再把这个存在磁盘中的文件读入链表就可以了。

㈦ 如何将数据以树的形式存储在内存中

1、栈区（stack）：由编译器自动分配和释放 ，存放函数的参数值、局部变量的值等，甚至函数的调用过程都是用栈来完成。其操作方式类似于数据结构中的栈
2、堆区（heap） ：一般由程序员手动申请以及释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式类似于链表
3、全局区（静态区）（static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放空间
4、文字常量区：常量字符串就是放在这里的。 程序结束后由系统释放空间
5、程序代码区：存放函数体的二进制代码

㈧ 树的存储方法主要有哪些

三叉链表不就是存储结构，其具体实现既可以用指针实现，也可以用数组实现 至于遍历方法可以任意地在二叉树中上下

㈨ 如何在磁盘上以文件形式存储一棵树

参考以下代码： #include <stdio.h> //定义二叉树的存储结构 struct BTNode { char data; BTNode* lchild; BTNode* rchild; }BTNode; void Ctree(struct BTNode* t,char A[],int i) { if(t!=NULL) { A[i]=t->data; Ctree(t->lchild,A,i*2); Ctree(t->rchild,A,i*2+1); } else { A[i]=' '; } } int main(void) { //建立二叉链表存储结构的二叉树,以p1为根节点，p2,p3分别为p1的左右子树，p4为p3的左子树 struct BTNode p1,p2,p3,p4; struct BTNode *t=&p1; p1.data='a'; p2.data='b'; p3.data='c'; p4.data='d'; p1.lchild=&p2; p1.rchild=&p3; p2.lchild=NULL; p2.rchild=NULL; p3.lchild=&p4; p3.rchild=NULL; p4.lchild=NULL; p4.rchild=NULL; char A[20]={NULL}; //定义字符数组存储转换后的二叉树存储结构 Ctree(t,A,1); //调用上述转换算法 //显示结果 printf("以下是转换后数组的值：\n"); for(int i=1;i<20;i++) { if(A[i]!=NULL) printf("A[%d]=%c\n",i,A[i]); } return 0; }

㈩ 如何在数据库中存储一棵树

假设有如下一棵树：

这种结构下，如果查询某一个节点的直接子节点，十分容易，比如要查询D节点的子节点。