堆树在C语言中的实现
我正在为即将到来的暑期课程用c语言练习数据结构。我正在尝试实现一个二进制堆树。我只是想知道我的代码是否正确或者是否可以改进。我有许多实用功能来制作和打印树堆树在C语言中的实现,c,tree,binary-tree,binary-heap,C,Tree,Binary Tree,Binary Heap,我正在为即将到来的暑期课程用c语言练习数据结构。我正在尝试实现一个二进制堆树。我只是想知道我的代码是否正确或者是否可以改进。我有许多实用功能来制作和打印树 #include <stdlib.h> #include <stdio.h> typedef struct Node{ int value; struct Node * left; struct Node * right; }Node; int heightOfTree(Node * root)
#include <stdlib.h>
#include <stdio.h>
typedef struct Node{
int value;
struct Node * left;
struct Node * right;
}Node;
int heightOfTree(Node * root);
/*arring data in tree.*/
void reheapify(Node * N){
Node * M;
int V1,V2,temp;
V1 = N->value;
while(N->left != NULL && N->right != NULL){
if (N->left->value > N->right->value){
M = N->left;
}
else if (N->left->value < N->right->value){
M = N->right;
}
V2 = M->value;
if (V1 >= V2){
return;
} else {
temp = N -> value;
N -> value = M -> value;
M -> value = temp;
N = M;
V1 = N -> value;
}
}
}
void printLevel(Node * root, int level){
if (root == NULL) return;
//if (level == 1) printf("%d ",root -> value);
if (level == 1) reheapify(root);
else if (level > 1){
printLevel(root -> left, level-1);
printLevel(root -> right, level-1);
}
}
void heapify(Node * heap){
int height = heightOfTree(heap);
for(int i = height;i >= 1;i--) printLevel(heap,i);
}
/*building and printing tree*/
Node *newEmptyTree(void) {
Node *new = malloc(sizeof (Node));
if (new == NULL) {
printf("Failed allocation.\n");
return NULL;
}
new->value = 0;
new->left = NULL;
new->right = NULL;
return new;
}
// make a heap from part of an array
Node *heap_from_array(int arr[], int index, int elements) {
// when we're past the end of the array, there's nothing to do anymore
if (index >= elements) return NULL;
// Otherwise, get us a new tree
Node *this = newEmptyTree();
// store current element
this->value = arr[index];
// fill left subtree
this->left = heap_from_array(arr, 2*index + 1, elements);
// fill right
this->right = heap_from_array(arr, 2*index + 2, elements);
// done, return the thing
return this;
}
void printPre(Node * root){
Node * parent = root;
if (parent == NULL) return;
printf("%d ",parent -> value);
printPre(parent -> left);
printPre(parent -> right);
}
int heightOfTree(Node * root){
if (root == NULL) return 0;
else{
int leftHieght = heightOfTree(root -> left);
int rightHeight = heightOfTree(root -> right);
if (leftHieght > rightHeight) return leftHieght+1;
else return rightHeight+1;
}
}
int main(void){
int array[] = {2,4,5,7,3,10,8,1,9,6};
Node * heap = NULL;
heap = heap_from_array(array,0,10);
printf("Height of tree: %d\n",heightOfTree(heap));
printPre(heap);
printf("\n");
heapify(heap);
printPre(heap);
printf("\n");
return 0;
}
#包括
#包括
类型定义结构节点{
int值；
结构节点*左；
结构节点*右；
}节点；
树的内部高度（节点*根）；
/*在树中排列数据*/
无效重新调整（节点*N）{
节点*M；
int V1、V2、temp；
V1=N->数值；
而（N->left！=NULL&&N->right！=NULL）{
如果（N->left->value>N->right->value）{
M=N->左；
}
否则如果（N->left->valueright->value）{
M=N->右；
}
V2=M->值；
如果（V1>=V2）{
返回；
}否则{
温度=N->数值；
N->value=M->value；
M->值=温度；
N=M；
V1=N->数值；
}
}
}
无效打印级别（节点*根，整数级别）{
if（root==NULL）返回；
//如果（级别==1）printf（“%d”，根->值）；
如果（级别==1）重新安置（根）；
否则，如果（级别>1）{
打印级别（根->左，级别1）；
打印级别（根->右，级别1）；
}
}
void heapify（节点*堆）{
int height=树的高度（堆）；
对于（int i=高度；i>=1；i--）打印级别（堆，i）；
}
/*建筑和印刷树*/
节点*newEmptyTree（void）{
Node*new=malloc（sizeof（Node））；
if（new==NULL）{
printf（“分配失败。\n”）；
返回NULL；
}
新建->值=0；
新建->左=空；
新建->右=空；
归还新的；
}
//从数组的一部分生成堆
节点*堆来自数组（int arr[]，int索引，int元素）{
//当我们越过阵列的末端时，就没有什么可做的了
如果（索引>=元素）返回NULL；
//否则，给我们一棵新树
Node*this=newEmptyTree（）；
//存储当前元素
此->值=arr[索引]；
//填充左子树
this->left=heap\u from\u数组（arr，2*索引+1，元素）；
//填补权利
这->右=堆来自数组（arr，2*索引+2，元素）；
//好了，把东西还给我
归还这个；
}
void printPre（节点*根）{
节点*父节点=根节点；
if（parent==NULL）返回；
printf（“%d”，父项->值）；
printPre（父级->左侧）；
printPre（父级->右侧）；
}
int heightOfTree（节点*根）{
if（root==NULL）返回0；
否则{
int lefthight=树的高度（根->左）；
int rightHeight=树的高度（根->右）；
如果（LeftHight>rightHeight）返回LeftHight+1；
否则返回rightHeight+1；
}
}
内部主（空）{
int数组[]={2,4,5,7,3,10,8,1,9,6}；
Node*heap=NULL；
heap=数组（数组，0,10）中的heap\u；
printf（“树的高度：%d\n”，树的高度（堆））；
printPre（堆）；
printf（“\n”）；
heapify（堆）；
printPre（堆）；
printf（“\n”）；
返回0；
}
lefthight>rightweeth