数据结构-树

最新推荐文章于 2024-04-30 20:59:13 发布
最新推荐文章于 2024-04-30 20:59:13 发布
阅读量594 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fzubbsc/article/details/31735419
版权

1、树的定义：树是算法中常用的数据结构。以下给出针对于二叉树、以及二叉搜索树的代码实现。

2、代码实现

（1）二叉树

<span style="font-size:18px;"><span style="font-size:14px;">/*bitree.h*/
#ifndef BITREE_H
#define BITREE_H
#include<stdlib.h>

/*define a structure for binary tree nodes*/
typedef struct BiTreeNode_
{
	void	*data;
	struct BiTreeNode_ *left;
	struct BiTreeNode_ *right;
}BiTreeNode;

/*define a stucture for binary tree*/
typedef struct BiTree_
{
	int	size;
	int (*compare)(const void *key1,const void *key2);
	void (*destroy)(void *data);
	BiTreeNode *root;
}BiTree;

/*public interface*/
void bitree_init(BiTree *tree,void (*destroy)(void *data));
void bitree_destroy(BiTree *tree);
int bitree_ins_left(BiTree *tree,BiTreeNode *node,const void *data);
int bitree_ins_right(BiTree *tree,BiTreeNode *node,const void *data); 
void bitree_rem_left(BiTree *tree,BiTreeNode *node);
void bitree_rem_right(BiTree *tree,BiTreeNode *node);
int bitree_merge(BiTree *merge,BiTree *left,BiTree *right,const void *data);
#define bitree_size(tree)	((tree)->size)
#define bitree_root(tree)	((tree)->root)
#define bitree_is_eob(tree)	((node)==NULL)
#define bitree_is_leaf(tree)	((node)->left==NULL && (node)->right==NULL)
#define bitree_data(node)	((node)->data)
#define bitree_left(node)	((node)->left)
#define bitree_right(node)	((node)->right)

#endif
</span></span>

 
<span style="font-size:18px;"><span style="font-size:14px;">/*bitree.c*/
#include<stdlib.h>
#include<string.h>
#include"bitree.h"

void bitree_init(BiTree *tree,void (*destroy)(void *data))
{
	/*initialize the binary tree*/
	tree->size=0;
	tree->destroy=destroy;
	tree->root=NULL;
	return ;
}


void bitree_destroy(BiTree *tree)
{
	/*remove all the nodes from the tree*/
	bitree_rem_left(tree,NULL);

	/*clear the structure*/
	memset(tree,0,sizeof(BiTree));
	return;
}


int bitree_ins_left(BiTree *tree,BiTreeNode *node,const void *data)
{
	BiTreeNode *new_node,**position;

	/*determine where to insert the node*/
	if(node==NULL)
	{
		/*allow insertion at the root only in an empty tree*/
		if(bitree_size(tree)>0)
			return -1;
		position=&tree->root;
	}
	else
	{
		/*normally allow insertion only at the end of a branch*/
		if(bitree_left(node)!=NULL)
			return -1;
		position=&node->left;
	}

	/*allocate storage for the node*/
	if((new_node=(BiTreeNode *)malloc(sizeof(BiTreeNode)))==NULL)
		return -1;

	/*insert the node into the tree*/
	new_node->data=(void *)data;
	new_node->left=NULL;
	new_node->right=NULL;
	*position=new_node;

	/*adjust the size of the tree to account for the inserted node*/
	tree->size++;
	return 0;
}


int bitree_ins_right(BiTree *tree,BiTreeNode *node,const void *data)
{
		BiTreeNode *new_node,**position;

	/*determine where to insert the node*/
	if(node==NULL)
	{
		/*allow insertion at the root only in an empty tree*/
		if(bitree_size(tree)>0)
			return -1;
		position=&tree->root;
	}
	else
	{
		/*normally allow insertion only at the end of a branch*/
		if(bitree_left(node)!=NULL)
			return -1;
		position=&node->right;
	}

	/*allocate storage for the node*/
	if((new_node=(BiTreeNode *)malloc(sizeof(BiTreeNode)))==NULL)
		return -1;

	/*insert the node into the tree*/
	new_node->data=(void *)data;
	new_node->left=NULL;
	new_node->right=NULL;
	*position=new_node;

	/*adjust the size of the tree to account for the inserted node*/
	tree->size++;
	return 0;
}


void bitree_rem_left(BiTree *tree,BiTreeNode *node)
{
	BiTreeNode **position;

	/*do not allow removal from an empty tree*/
	if(bitree_size(tree)==0)
		return;
	/*determine where to remove node*/
	if(node==NULL)
		position=&tree->root;
	else
		position=&node->left;

	/*remove the nodes*/
	if(*position!=NULL)
	{
		bitree_rem_left(tree,*position);
		bitree_rem_right(tree,*position);
		if(tree->destroy!=NULL)
		{
			/*call a user-defined function to free dynamically allocated data*/
			tree->destroy((*position)->data);
		}
		free(*position);
		*position=NULL;

		/*adjust the size of the tree to account for the removed node*/
		tree->size--;
	}
	return ;
}


void bitree_rem_right(BiTree *tree,BiTreeNode *node)
{
	BiTreeNode **position;

	/*do not allow removal from an empty tree*/
	if(bitree_size(tree)==0)
		return;
	/*determine where to remove node*/
	if(node==NULL)
		position=&tree->root;
	else
		position=&node->right;

	/*remove the nodes*/
	if(*position!=NULL)
	{
		bitree_rem_left(tree,*position);
		bitree_rem_right(tree,*position);
		if(tree->destroy!=NULL)
		{
			/*call a user-defined function to free dynamically allocated data*/
			tree->destroy((*position)->data);
		}
		free(*position);
		*position=NULL;

		/*adjust the size of the tree to account for the removed node*/
		tree->size--;
	}
	return ;
}


int bitree_merge(BiTree *merge,BiTree *left,BiTree *right,const void *data)
{
	/*initialize the merged tree*/
	bitree_init(merge,left->destroy);

	/*insert the data for the root node of the merged tree*/
	if(bitree_ins_left(merge,NULL,data)!=0)
	{
		bitree_destroy(merge);
		return -1;
	}

	/*merge the two binary trees into a single binary tree*/
	bitree_root(merge)->left=bitree_root(left);
	bitree_root(merge)->right=bitree_root(right);

	/*adjust the size of the new binary tree*/
	merge->size=merge->size+bitree_size(left)+bitree_size(right);

	/*do not let original trees access the merged nodes*/
	left->root=NULL;
	left->size=0;
	right->root=NULL;
	right->size=0;

	return 0;
}
</span></span>

应用实例：

后续补上

（2）二叉搜索树

<span style="font-size:18px;"><span style="font-size:14px;">/*bistree.h 二叉搜索树*/
#ifndef BISTREE_H
#define BISTREE_H
#include "bitree.h"

/*define balance factors for AVL trees*/
#define		AVL_LFT_HEAVY		1
#define		AVL_BALANCED		0
#define		AVL_RGT_HEAVY		-1

/*define a structure for node in AVL trees*/
typedef struct AvlNode_
{
	void *data;
	int hidden;
	int factor;
}AvlNode;

/*implement binary search trees as binary trees*/
typedef BiTree BisTree;

/*public interface*/
void bistree_init(BisTree *tree,int (*compare)(const void *key1,const void *key2),void (*destroy)(void *data));
void bistree_destroy(BisTree *tree);
int bistree_insert(BisTree *tree,const void *data);
int bistree_remove(BisTree *tree,const void *data);
int bistree_lookup(BisTree *tree,void **data);
#define bistree_size(tree) ((tree)->size)

#endif</span></span>

 
<span style="font-size:18px;"><span style="font-size:14px;">/*bistree.c二叉搜索树*/
#include<stdlib.h>
#include<string.h>
#include"bistree.h"

static void destroy_right(BisTree *tree,BiTreeNode *node);

static void rotate_left(BiTreeNode **node)
{
	BiTreeNode *left,*grandchild;
	left=bitree_left(*node);
	if(((AvlNode *)bitree_data(left))->factor==AVL_LFT_HEAVY)
	{
		/*Perform an LL rotation*/
		bitree_left(*node)=bitree_right(left);
		bitree_right(left)=*node;
		((AvlNode *)bitree_data(*node))->factor=AVL_BALANCED;
		((AvlNode *)bitree_data(left))->factor=AVL_BALANCED;
		*node=left;
	}
	else
	{
		/*perform an LR rotation*/
		grandchild=bitree_right(left);
		bitree_right(left)=bitree_left(grandchild);
		bitree_left(grandchild)=left;
	    bitree_left(*node)=bitree_left(grandchild);
		bitree_right(grandchild)=*node;

		switch(((AvlNode *)bitree_data(grandchild))->factor)
		{
		case AVL_LFT_HEAVY:
			((AvlNode *)bitree_data(*node))->factor=AVL_RGT_HEAVY;
			((AvlNode *)bitree_data(left))->factor=AVL_BALANCED;
			break;
		case AVL_BALANCED:
			((AvlNode *)bitree_data(*node))->factor=AVL_BALANCED;
			((AvlNode *)bitree_data(left))->factor=AVL_BALANCED;
			break;
		case AVL_RGT_HEAVY:
			((AvlNode *)bitree_data(*node))->factor=AVL_BALANCED;
			((AvlNode *)bitree_data(left))->factor=AVL_LFT_HEAVY;
			break;
		}
		((AvlNode *)bitree_data(grandchild))->factor=AVL_BALANCED;
		*node=grandchild;
	}
	return;
}


static void rotate_right(BiTreeNode **node)
{
	BiTreeNode *right,*grandchild;
	right=bitree_right(*node);
	if(((AvlNode *)bitree_data(right))->factor==AVL_RGT_HEAVY)
	{
		/*Perform an RR rotation*/
		bitree_right(*node)=bitree_left(right);
		bitree_right(right)=*node;
		((AvlNode *)bitree_data(*node))->factor=AVL_BALANCED;
		((AvlNode *)bitree_data(right))->factor=AVL_BALANCED;
		*node=right;
	}
	else
	{
		/*perform an RL rotation*/
		grandchild=bitree_left(right);
		bitree_left(right)=bitree_right(grandchild);
		bitree_right(grandchild)=right;
	    bitree_right(*node)=bitree_left(grandchild);
		bitree_left(grandchild)=*node;

		switch(((AvlNode *)bitree_data(grandchild))->factor)
		{
		case AVL_LFT_HEAVY:
			((AvlNode *)bitree_data(*node))->factor=AVL_BALANCED;
			((AvlNode *)bitree_data(right))->factor=AVL_RGT_HEAVY;
			break;
		case AVL_BALANCED:
			((AvlNode *)bitree_data(*node))->factor=AVL_BALANCED;
			((AvlNode *)bitree_data(right))->factor=AVL_BALANCED;
			break;
		case AVL_RGT_HEAVY:
			((AvlNode *)bitree_data(*node))->factor=AVL_LFT_HEAVY;
			((AvlNode *)bitree_data(right))->factor=AVL_BALANCED;
			break;
		}
		((AvlNode *)bitree_data(grandchild))->factor=AVL_BALANCED;
		*node=grandchild;
	}
	return;
	 
}


static void destroy_left(BisTree *tree,BiTreeNode *node)
{
	BiTreeNode **position;

	/*do not allow destruction of an empty tree*/
	if(bitree_size(tree)==0)
		return;

	/*determine where to destroy nodes*/
	if(node==NULL)
		position=&tree->root;
	else 
		position=&node->left;

	/*destroy the nodes*/
	if(*position !=NULL)
	{
		destroy_left(tree,*position);
		destroy_right(tree,*position);
		if(tree->destroy!=NULL)
		{
			/*call a user-define function to free dynamically allocated data*/
			tree->destroy(((AvlNode *)(*position)->data)->data);
		}

		/*Free the AVL data in the node,then free the node itself*/
		free((*position)->data);
		free(*position);
		*position=NULL;

		/*Ajust the size*/
		tree->size--;
	}
	return ;
	
}


static void destroy_right(BisTree *tree,BiTreeNode *node)
{
	BiTreeNode **position;

	/*do not allow destruction of an empty tree*/
	if(bitree_size(tree)==0)
		return;

	/*determine where to destroy nodes*/
	if(node==NULL)
		position=&tree->root;
	else 
		position=&node->right;

	/*destroy the nodes*/
	if(*position !=NULL)
	{
		destroy_left(tree,*position);
		destroy_right(tree,*position);
		if(tree->destroy!=NULL)
		{
			/*call a user-define function to free dynamically allocated data*/
			tree->destroy(((AvlNode *)(*position)->data)->data);
		}

		/*Free the AVL data in the node,then free the node itself*/
		free((*position)->data);
		free(*position);
		*position=NULL;

		/*Ajust the size*/
		tree->size--;
	}
	return ;
	
}


static int insert(BisTree *tree,BiTreeNode **node,const void *data,int *balanced)
{
	AvlNode *avl_data;
	int cmpval,retval;

	/*insert the data into the tree*/
	if(bitree_is_eob(*node))
	{
		/*handle insertion into an empty tree*/
		if((avl_data=(AvlNode *)malloc(sizeof(AvlNode)))==NULL)
			return -1;
		avl_data->factor=AVL_BALANCED;
		avl_data->hidden=0;
		avl_data->data=(void *)data;
		return bitree_ins_left(tree, *node,avl_data);
	}
	else
	{
		/*handle insertion into a tree that is not empty*/
		cmpval=tree->compare(data,((AvlNode *)bitree_data(*node))->data);
		if(cmpval<0)
		{
			/*move to  the left*/
			if(bitree_is_eob(bitree_left(*node)))
			{
				if((avl_data=(AvlNode *)malloc(sizeof(AvlNode *)))==NULL)
					return -1;
				avl_data->factor=AVL_BALANCED;
				avl_data->hidden=0;
				avl_data->data=(void *)data;
				if(bitree_ins_left(tree,*node,avl_data)!=0)
					return -1;
				*balanced=0;
			}
			else
			{
				if((retval=insert(tree,&bitree_left(*node),data,balanced))!=0)
				{	
					return retval;
				}
			}

			/*ensure that the tree remains balanced*/
			if(!(*balanced))
			{
				switch(((AvlNode *)bitree_data(*node))->factor)
				{
				case AVL_LFT_HEAVY:
					rotate_left(node);
					*balanced=1;
					break;
				case AVL_BALANCED:
					((AvlNode *)bitree_data(*node))->factor=AVL_LFT_HEAVY;
					break;
				case AVL_RGT_HEAVY:
					((AvlNode *)bitree_data(*node))->factor=AVL_BALANCED;
					*balanced=1;
					break;
				}
			}
		}
		
		else if(cmpval>0)
		{
			/*move to  the right*/
			if(bitree_is_eob(bitree_right(*node)))
			{
				if((avl_data=(AvlNode *)malloc(sizeof(AvlNode *)))==NULL)
					return -1;
				avl_data->factor=AVL_BALANCED;
				avl_data->hidden=0;
				avl_data->data=(void *)data;
				if(bitree_ins_right(tree,*node,avl_data)!=0)
					return -1;
				*balanced=0;
			}
			else
			{
				if((retval=insert(tree,&bitree_right(*node),data,balanced))!=0)
				{	
					return retval;
				}
			}

			/*ensure that the tree remains balanced*/
			if(!(*balanced))
			{
				switch(((AvlNode *)bitree_data(*node))->factor)
				{
				case AVL_LFT_HEAVY:
					((AvlNode *)bitree_data(*node))->factor=AVL_BALANCED;
					*balanced=1;
					break;
				case AVL_BALANCED:
					((AvlNode *)bitree_data(*node))->factor=AVL_RGT_HEAVY;
					break;
				case AVL_RGT_HEAVY:
					rotate_right(node);
					*balanced=1;
					break;
				}
			}
		}

		else
		{
			/*handle finding a copy for the data*/
			if(!((AvlNode *)bitree_data(*node))->hidden)
			{
				/*do nothing since the data is in the tree and not hidden*/
				return 1;
			}
			else
			{
				/*insert the new data and mask it as no hidden*/
				if(tree->destroy!=NULL)
				{
					/*destroy the hidden data since it is being replaced*/
					tree->destroy(((AvlNode *)bitree_data(*node))->data);
				}
				((AvlNode *)bitree_data(*node))->data=(void *)data;
				((AvlNode *)bitree_data(*node))->hidden=0;

				/*do not rebalance because the tree structure is unchanged*/
				*balanced=1;
			}
		}

	}
	return 0;

}


static int hide(BisTree *tree,BiTreeNode *node,const void *data)
{
	int cmpval,retval;
	if(bitree_is_eob(node))
	{
		/*return that the data was not found*/
		return -1;
	}
	cmpval=tree->compare(data,((AvlNode *)bitree_data(node))->data);
	if(cmpval<0)
	{
		/*move to the left*/
		retval=hide(tree,bitree_left(node),data);
	}
	else if(cmpval>0)
	{
		/*move to the right*/
		retval=hide(tree,bitree_right(node),data);
	}
	else
	{
		/*mark the node as hidden*/
		((AvlNode *)bitree_data(node))->hidden=1;
		retval=0;
	}
	return retval;

}


static int lookup(BisTree *tree,BiTreeNode *node,void **data)
{
	int cmpval,retval;
	if(bitree_is_eob(node))
	{
		/*return that the data was not found*/
		return -1;
	}
	cmpval=tree->compare(*data,((AvlNode *)bitree_data(node))->data);
	if(cmpval<0)
	{
		/*move to the left*/
		retval=lookup(tree,bitree_left(node),data);
	}
	else if(cmpval>0)
	{
		/*move to the riht*/
		retval=lookup(tree,bitree_right(node),data);
	}
	else
	{
		if(!((AvlNode *)bitree_data(node))->hidden)
		{
			/*pass back the data from the tree*/
			*data=((AvlNode *)bitree_data(node))->data;
			retval=0;
		}
		else
		{
			/*return that the data was no found*/
			return -1;
		}
	}

	return retval;
}


void bistree_init(BisTree *tree,int (*compare)(const void *key1,const void *key2),void (*destroy)(void *data))
{
	/*initialize the tree*/
	bitree_init(tree,destroy);
	tree->compare=compare;
	return;
}


void bistree_destroy(BisTree *tree)
{
	/*destroy all node in the tree*/
	destroy_left(tree,NULL);
	memset(tree,0,sizeof(BisTree));
	return;
}


int bistree_insert(BisTree *tree,const void *data)
{
	int balanced=0;
	return insert(tree,&bitree_root(tree),data,&balanced);
}


int bistree_remove(BisTree *tree,const void *data)
{
	return hide(tree,bitree_root(tree),data);
}


int bistree_lookup(BisTree *tree,void **data)
{
	return lookup(tree,bitree_root(tree),data);
}</span></span>

应用实例：

后续补上

 

fzubbsc之雕虫小技
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研党 《数据结构（C语言版）》 严蔚敏BiTree基本操作
小维天使001 Blog
08-14 2018
好久没有更新了。主要看高数了。专业课放了一放。最近又看了看二叉树，学到了很多以前没有注意到的细节。//BiTree.h #ifndef _BITREE_H_ #define _BITREE_H_#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0typedef char ElemType; typedef int S
Educoder头歌数据结构-树和二叉树及其应用
qq_50848214的博客
11-13 1万+
头歌实践平台答案educoder 数据结构-树和二叉树及其应用 第1关二叉树的创建ss /************************************************************* date: March 2019 二叉树的创建 实现文件 **************************************************************/ BiTree CreateBiTree() // 利用先序遍历创建二叉树，返回根指针。 {
python数据结构-树
漫漫行程路
02-14 8286
树 树是数据元素之间具有层次关系的非线性结构，由n个节点构成的有限集合，节点数为0的树叫空树 树： 有且仅有一个被称为根的节点 其余节点可分为m个互不相交的有限集合，每个集合又构成一棵树，叫做根节点的子树 树中的元素具有一对多的逻辑关系 除根节点以外，每个数据元素可以有多个后继但有且仅有一个前驱 树是递归定义的 节点的路径：根节点到该节点所经过节点的顺序排序 路径的长度：路径的长度指的是路径中包含的分支数 节点的度：节点的度指的是节点拥有的子树的数目 树的度：树的度指的是树中所有节点的度的最大值 叶节点
数据结构：树(Tree)【详解】
热门推荐
UniqueUnit的博客
02-26 14万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
数据结构-树和二叉树-PPT
02-04
数据结构-树和二叉树-PPT
数据结构-树和图的使用
03-25
数据结构-树的使用以及图的基本用法（C语言）； 其中包含，平衡二叉树，二叉排序树，特殊二叉树等等； 使用非递归遍历以及层次遍历； 图，计算最短路径方法；
java版数据结构-树结构
07-16
java版数据结构-树结构；java版数据结构-树结构；java版数据结构-树结构；java版数据结构-树结构；java版数据结构-树结构；java版数据结构-树结构；
数据结构-树的简介.pdf
09-16
数据结构-树的简介.pdf
数据结构===栈
yajunjiao的专栏
04-30 362
栈是一种先进后出的数据结构。它的操作受限。栈，是一种先进后出，或者后进先出的数据结构。跟数组和链表相比，有一定的限制性。毕竟，它也有自己的适用场景，比如：函数调用，表达式求值等等。栈有2个操作，入栈，出栈。时间复杂度都是O(1)。
数据结构––复杂度
2301_80190473的博客
04-27 1072
是一个数学表达式，是对一个算法在运行过程中临时占用额外存储空间大小的量度空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。
JSON转CSV：使用Java处理复杂数据结构
qq_33326733的博客
04-29 128
在数据处理和分析的世界中，经常需要将数据从一种格式转换为另一种更便于处理或分析的格式。本文将详细介绍如何使用Java语言，配合Jackson和Apache Commons CSV库，将嵌套的JSON数据转换成CSV格式。通过上述步骤，我们不仅学会了如何处理和转换嵌套的JSON数据，还确保了数据的完整性和灵活性。为了进一步提高效率和可读性，可以考虑添加异常处理和数据验证的逻辑，确保在处理大量或复杂数据时的健壮性。首先，确保你的Java项目中引入了必要的库。中的数据，并将其转换为CSV格式。
数据结构九：线性表之链式队列的设计
weixin_47040031的博客
04-30 346
现在，我们可以知道，其实从本质上来讲，链式队列就是重新设计头节点的单链表结构，并且只允许头删和尾插（队尾入队头出）；对于循环队列与链队列的比较，可以从两方面来考虑，从时间上，其实它们的基本操作都是常数时间，即都为O(1)的，不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销，如果入队出队频繁，则两者还是有细微差异。对于空间上来说，循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题。
acwing算法提高之数据结构--可持久化数据结构
YMWM_的博客
04-30 155
acwing算法提高之数据结构--可持久化数据结构
数据结构系列-二叉树之前序遍历
in_seattle的博客
04-26 428
这篇文章，我们主要的内容是对二叉树当中的前历的算法进行讲解，二叉树中的算法所要求实现的是 从根到左子树再到右子树的遍历顺序，可能这样不太好理解，我们拿一张图片进行解释，我们先来分析一下这个的实现逻辑是什么，按照根节点，左子树，右子树的顺序，我们先来判断一下这个应该实现的结果是什么。在这里，我们将空也表现了出来，那下面，我们就讲解一下怎么用代码实现这个过程。假设在这个二叉树当中，我们要实现二叉树遍历当中的前历，我们应该怎么做呢。这些代码我们在前面就详细的进行了展开，在这里我们就不进行详细的讲解。
二叉树：数据结构的分形之美
2301_78804510的博客
04-30 743
树是一种非线性的数据结构，它是由n(n>=0)个有限结点组成一个具有层次关系的集合。把他叫做树是因为它看起来像一棵倒挂的树，也就说它的根朝上，而叶朝下的。
算法与数据结构 数组
最新发布
2301_80790320的博客
04-30 97
在一个由若干个排列整齐的数组成的正方形中，图中任意一横行、一纵行的几个数之和都相等，具有这种性质的图表，称为“幻方”。按目前填写幻方的方法，是把幻方分成了三类，即奇数阶幻方、双偶阶幻方、单偶阶幻方。奇数阶幻方的方法比较简单，这里只考查奇数阶幻方的程序。输入30以内的任一奇数n，自动输出n*n阶幻方。口诀：“1”居上行正中央，依次斜填切莫忘，上出框时往下填，右出框时左边放，排重便在下格填，右上排重一个样！
编写一个经典C语言数据结构-树
08-08
树(Tree)是一种非线性的数据结构，它由n(n>=0)个结点构成，其中一个结点为根结点，其余结点可分为m(m>=0)个互不相交的子集T1、T2、……、Tm，其中每一个子集本身又是一棵树，并称为根的子树。树的特点是：每个结点有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值