二叉树的C语言实现

最新推荐文章于 2024-05-17 00:32:32 发布
最新推荐文章于 2024-05-17 00:32:32 发布
阅读量489 收藏
点赞数 1
分类专栏： C 数据结构 文章标签： 树结构 二叉树 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38705421/article/details/107975910
版权

今天使用C语言实现通用树结构。

下面是Main.c文件：

#include <stdio.h>
#include "GTree.h"

int main()
{
	GTree *tree = GTreeCreate();
	
	if(tree != NULL)
	{
		LinkList* list = NULL;
		GTreeNode *node = NULL;
		GTreeInsertValue(tree, 1, node);
		
		node = GTreeFindValue(tree, 1);
		GTreeInsertValue(tree, 2, node);
		GTreeInsertValue(tree, 3, node);
		
		node = GTreeFindValue(tree, 2);
		GTreeInsertValue(tree, 4, node);
		GTreeInsertValue(tree, 5, node);
		GTreeInsertValue(tree, 6, node);
		
		node = GTreeFindValue(tree, 3);
		GTreeInsertValue(tree, 7, node);
		
		node = GTreeFindValue(tree, 5);
		GTreeInsertValue(tree, 8, node);
		GTreeInsertValue(tree, 9, node);
		
		node = GTreeFindValue(tree, 7);
		GTreeInsertValue(tree, 10, node);
		
		node = GTreeFindValue(tree, 11);
		printf("node = %p\n", node);
		printf("flag = %d\n", GTreeInsertValue(tree, 12, node));
		
		list = GTreeTraversal(tree);
		
		if(list != NULL)
		{
			printf("Tree One: \n");
			for(LinkListMove(list, 0); !LinkListEnd(list); LinkListNext(list))
			{
				printf("data = %d\n", LinkListCurrent(list)->data);
			}
		}
		
		node = GTreeRemoveValue(tree, 5);
		node->parent = NULL;
		
		list = LinkListDestroy(list);
		
		list = GTreeTraversal(tree);
		
		if(list != NULL)
		{
			printf("Tree Two: \n");
			for(LinkListMove(list, 0); !LinkListEnd(list); LinkListNext(list))
			{
				printf("data = %d\n", LinkListCurrent(list)->data);
			}
		}
		
		list = LinkListDestroy(list);
		tree = GTreeDestroy(tree);
		
		tree = GTreeCreate();
		GTreeInsertNode(tree, node);
		
		list = GTreeTraversal(tree);
		
		if(list != NULL)
		{
			printf("Tree Three: \n");
			for(LinkListMove(list, 0); !LinkListEnd(list); LinkListNext(list))
			{
				printf("data = %d\n", LinkListCurrent(list)->data);
			}
		}
		
		list = LinkListDestroy(list);
		tree = GTreeDestroy(tree);
	}
	
	return 0;
}

下面是GTree.h文件：

#ifndef __GTREE_H__
#define __GTREE_H__

#include "Macro.h"
#include "LinkList.h"
#include "DynamicQueue.h"

STRUCT(GTree)
{
	GTreeNode* root;
};

GTree* GTreeCreate();
GTree* GTreeDestroy(GTree *tree);
GTreeNode* GTreeNodeCreate();
GTreeNode* GTreeNodeDestroy(GTreeNode *node);
Bool GTreeInsertNode(GTree *tree, GTreeNode *node);
Bool GTreeInsertValue(GTree *tree, DataType data, GTreeNode *parent);
GTreeNode* GTreeRemoveNode(GTree *tree, GTreeNode *node);
GTreeNode* GTreeRemoveValue(GTree *tree, DataType data);
GTreeNode* GTreeFindNode(GTree *tree, GTreeNode *node);
GTreeNode* GTreeFindValue(GTree *tree, DataType data);
GTreeNode* GTreeNodeFindNode(GTreeNode *root, GTreeNode *node);
GTreeNode* GTreeNodeFindValue(GTreeNode *root, DataType data);
GTreeNode* root(GTree *tree);
int GTreeDegree(GTree *tree);
int GTreeCount(GTree *tree);
int GTreeHeight(GTree *tree);
LinkList* GTreeTraversal(GTree *tree);

#endif

下面是GTree.c文件：

#include "GTree.h"

GTreeNode* GTreeNodeCreate()	//O(1)
{
	GTreeNode *ret = MALLOC(GTreeNode, 1);
	
	if(ret != NULL)
	{
		ret->list = LinkListCreate();//O(1)
		
		if(ret->list != NULL)
		{
			ret->parent = NULL;
		}
		else
		{
			FREE(ret);
		}
	}
	
	return ret;
}

GTreeNode* GTreeNodeDestroy(GTreeNode *node)	//O(n)
{
	if(node != NULL)
	{
		if(node->list != NULL)
		{
			for(LinkListMove(node->list, 0); !LinkListEnd(node->list); LinkListNext(node->list)) //O(n)
			{
				GTreeNodeDestroy(LinkListCurrent(node->list));	//O()
			}
			
			node->list = LinkListDestroy(node->list);	//O(n)
		}
		
		FREE(node);
	}
	
	return NULL;
}

GTreeNode* GTreeNodeFindNode(GTreeNode *root, GTreeNode *node) //O(n)
{
	GTreeNode *ret = NULL;
	
	if((root != NULL) && (node != NULL))
	{
		if(root == node)
		{
			ret = node;
		}
		else
		{
			for(LinkListMove(root->list, 0); !LinkListEnd(root->list) && (ret == NULL); LinkListNext(root->list))
			{
				ret = GTreeNodeFindNode(LinkListCurrent(root->list), node);	
			}
		}
	}
	
	return ret;
}

GTreeNode* GTreeNodeFindValue(GTreeNode *root, DataType data)	//O(n)
{
	GTreeNode *ret = NULL;
	
	if(root != NULL)
	{
		if(root->data == data)
		{
			ret = root;
		}
		else
		{
			for(LinkListMove(root->list, 0); !LinkListEnd(root->list) && (ret == NULL); LinkListNext(root->list))
			{
				ret = GTreeNodeFindValue(LinkListCurrent(root->list), data);	
			}
		}
	}
	
	return ret;	
}

static int GTreeNodeDegree(GTreeNode *root)	//O(n)
{
	int ret = 0;
	
	if(root != NULL)
	{
		ret = LinkListLength(root->list);
		
		for(LinkListMove(root->list, 0); !LinkListEnd(root->list); LinkListNext(root->list))
		{
			int degree = GTreeNodeDegree(LinkListCurrent(root->list));
			
			if(degree > ret)
			{
				ret = degree;
			}
		}
	}
	
	return ret;
}

static int GTreeNodeCount(GTreeNode *root)	//O(n)
{
	int ret = 0;
	
	if(root != NULL)
	{
		ret = LinkListLength(root->list);
		
		for(LinkListMove(root->list, 0); !LinkListEnd(root->list); LinkListNext(root->list))
		{			
			ret += GTreeNodeCount(LinkListCurrent(root->list));
		}
	}
	
	return ret;
}

static int GTreeNodeHeight(GTreeNode *root)		//O(n)
{
	int ret = 0;
	
	if(root != NULL)
	{
		for(LinkListMove(root->list, 0); !LinkListEnd(root->list); LinkListNext(root->list))
		{
			int height = GTreeNodeHeight(LinkListCurrent(root->list));
			
			if(height > ret)
			{
				ret = height;
			}
		}
		
		ret++;
	}
	
	return ret;	
}

static LinkList* GTreeNodeTraversal(GTreeNode *root, LinkList *list)	//O(n^2)
{
	if((root != NULL) && (list != NULL))
	{
		DynamicQueue *queue = DynamicQueueCreate();		//O(1)
		
		if(queue != NULL)
		{
			DynamicQueueEnqueue(queue, root);			//O(1)
			
			while(DynamicQueueLength(queue) > 0)		//O()
			{
				GTreeNode *node;
				DynamicQueueDequeue(queue, &node);
				LinkListInsert(list, LinkListLength(list), node);
				
				for(LinkListMove(node->list, 0); !LinkListEnd(node->list); LinkListNext(node->list))
				{
					DynamicQueueEnqueue(queue, LinkListCurrent(node->list));
				}
			}
			
			queue = DynamicQueueDestroy(queue);
		}
	}
	
	return list;
}

GTree* GTreeCreate()		//O(1)
{
	GTree *ret = MALLOC(GTree, 1);
	
	if(ret != NULL)
	{
		ret->root = NULL;
	}
	
	return ret;
}

GTree* GTreeDestroy(GTree *tree)		//O(n)
{
	if(tree != NULL)
	{
		GTreeNodeDestroy(tree->root);
		FREE(tree);
	}
	
	return NULL;
}

Bool GTreeInsertNode(GTree *tree, GTreeNode *node)		//O(n)
{
	Bool ret = (tree != NULL) && (node != NULL);
	
	if(ret)
	{
		if(node->parent == NULL)
		{
			if(tree->root == NULL)
			{
				tree->root = node;
			}
			else
			{
				ret = false;
			}
		}
		else
		{
			GTreeNode *parent = GTreeFindNode(tree, node->parent);
			
			if(parent != NULL)
			{
				ret = LinkListInsert(parent->list, LinkListLength(parent->list), node);
			}
			else
			{
				ret = false;
			}
		}
	}
	
	return ret;
}

Bool GTreeInsertValue(GTree *tree, DataType data, GTreeNode *parent)
{
	Bool ret = (tree != NULL);
	
	if(ret)
	{
		GTreeNode *node = GTreeNodeCreate();
		
		if(node != NULL)
		{
			node->data = data;
			node->parent = parent;
			
			ret = GTreeInsertNode(tree, node);
			
			if(ret == false) node = GTreeNodeDestroy(node);
		}
		else
		{
			ret = false;
		}
	}
	
	return ret;
}

GTreeNode* GTreeRemoveNode(GTree *tree, GTreeNode *node)
{
	GTreeNode *ret = NULL;
	
	if((tree != NULL) && (node != NULL))
	{
		if(tree->root == node)
		{
			tree->root = NULL;
			ret = node;
		}
		else
		{
			GTreeNode *n = GTreeFindNode(tree, node);
			
			if(n != NULL)
			{
				int index = LinkListFind(n->parent->list, node);
				
				if(index >= 0)
				{
					LinkListDelete(n->parent->list, index, NULL);
					ret = node;					
				}
			}
		}
	}
		
	return ret;
}

GTreeNode* GTreeRemoveValue(GTree *tree, DataType data)
{
	return GTreeRemoveNode(tree, GTreeFindValue(tree, data));	
}

GTreeNode* GTreeFindNode(GTree *tree, GTreeNode *node)
{
	return ((tree != NULL) && (node != NULL)) ? GTreeNodeFindNode(tree->root, node) : NULL;
}

GTreeNode* GTreeFindValue(GTree *tree, DataType data)
{
	return (tree != NULL) ? GTreeNodeFindValue(tree->root, data) : NULL;
}

GTreeNode* root(GTree *tree)
{
	return (tree != NULL) ? tree->root : NULL;
}

int GTreeDegree(GTree *tree)
{
	return (tree != NULL) ? GTreeNodeDegree(tree->root) : -1;
}

int GTreeCount(GTree *tree)
{
	return (tree != NULL) ? GTreeNodeCount(tree->root) : -1;
}

int GTreeHeight(GTree *tree)
{
	return (tree != NULL) ? GTreeNodeHeight(tree->root) : -1;
}

LinkList* GTreeTraversal(GTree *tree)
{
	return (tree != NULL) ? GTreeNodeTraversal(tree->root, LinkListCreate()) : NULL;
}

下面是DynamicQueue.h文件：

#ifndef __DYNAMICQUEUE_H_
#define __DYNAMICQUEUE_H_

#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"

STRUCT(DynamicQueue)
{
	LinkList *list;
	int len;
};

DynamicQueue* DynamicQueueCreate(void);
DynamicQueue* DynamicQueueDestroy(DynamicQueue *queue);
int DynamicQueueLength(DynamicQueue *queue);
Bool DynamicQueueEnqueue(DynamicQueue *queue, GTreeNode *data);
Bool DynamicQueueDequeue(DynamicQueue *queue, GTreeNode **data);
Bool DynamicQueueFront(DynamicQueue *queue, GTreeNode **data);

#endif

下面是DynamicQueue.c文件：

#include "DynamicQueue.h"

DynamicQueue* DynamicQueueCreate(void)								//O(1)
{
	DynamicQueue *ret = MALLOC(DynamicQueue, 1);

	if(ret != NULL)
	{
		ret->list = LinkListCreate(); 	//O(1)
		
		if(ret->list != NULL)
		{
			ret->len = 0;
		}
		else
		{
			free(ret);
			ret = NULL;
		}
	}
	
	return ret;
}

DynamicQueue* DynamicQueueDestroy(DynamicQueue *queue)				//O(n)
{
	if(queue != NULL)
	{
		LinkListDestroy(queue->list);	//O(n)
		free(queue);
	}
	
	return NULL;
}

int DynamicQueueLength(DynamicQueue *queue)							//O(1)
{
	return (queue != NULL) ? queue->len : -1;
}

Bool DynamicQueueEnqueue(DynamicQueue *queue, GTreeNode *data)		//O(n)
{
	Bool ret = (queue != NULL);
	
	if(ret)
	{
		ret = LinkListInsert(queue->list, queue->len, data);//O(n)
		if(ret) queue->len++;
	}
	
	return ret;
}

Bool DynamicQueueDequeue(DynamicQueue *queue, GTreeNode **data)		//O(1)
{
	Bool ret = (queue != NULL);
	
	if(ret)
	{
		ret = LinkListDelete(queue->list, 0, data);	//O(1)
		if(ret) queue->len--;
	}
}

Bool DynamicQueueFront(DynamicQueue *queue, GTreeNode **data)			//(1)
{
	Bool ret = (queue != NULL) && (data != NULL);
	
	if(ret)
	{
		ret = LinkListGet(queue->list, 0, data);
	}
	
	return ret;
}

下面是LinkList.h文件：

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

#include "Macro.h"

typedef struct __structGTreeNode GTreeNode;

STRUCT(LLNode)
{
	GTreeNode* data;
	LLNode *next;
};

STRUCT(LinkList)
{
	int len;
	LLNode *next;
	LLNode *m_current;
};

struct __structGTreeNode
{
	DataType data;
	GTreeNode *parent;
	LinkList *list;
};

LinkList* LinkListCreate(void);
LinkList* LinkListDestroy(LinkList *list);
int LinkListLength(LinkList *list);
Bool LinkListInsert(LinkList *list, int i, GTreeNode* data);
Bool LinkListDelete(LinkList *list, int i, GTreeNode* *data);
int LinkListFind(LinkList *list, GTreeNode* data); 
Bool LinkListSet(LinkList *list, int i, GTreeNode* data);
Bool LinkListGet(LinkList *list, int i, GTreeNode* *data);
LLNode* LinkListMove(LinkList *list, int i);
Bool LinkListEnd(LinkList *list);
void LinkListNext(LinkList *list);
GTreeNode* LinkListCurrent(LinkList *list);

#endif

下面是LinkList.c文件：

#include "LinkList.h"

LinkList* LinkListCreate(void)		//O(1)
{
	LinkList *list = MALLOC(LinkList, 1);
	
	if(list != NULL)
	{
		list->len = 0;
		list->next = NULL;
		list->m_current = NULL;
	}
	
	return list;
}

LinkList* LinkListDestroy(LinkList *list)	//O(n)
{
	if(list != NULL)
	{
		while(list->next != NULL)
		{
			LinkListDelete(list, 0, NULL);
		}
		
		FREE(list);
	}
	
	return NULL;
}

int LinkListLength(LinkList *list)	//O(1)
{
	return (list != NULL) ? list->len : -1;
}

Bool LinkListInsert(LinkList *list, int i, GTreeNode *data)		//O(n)
{
	Bool ret = (list != NULL) && (i >= 0) && (i <= LinkListLength(list));
	
	if(ret)
	{
		LLNode *node = MALLOC(LLNode, 1);
		
		if(node != NULL)
		{			
			if(0 == i)
			{
				node->data = data;
				node->next = list->next;
				
				list->next = node;
			}
			else
			{
				LLNode *pre = LinkListMove(list, i - 1);
				
				node->data = data;
				node->next = pre->next;
				
				pre->next = node;
			}
			
			list->len++;
		}
		else
		{
			ret = false;
		}
	}
	
	return ret;
}

Bool LinkListDelete(LinkList *list, int i, GTreeNode **data)	//O(n)
{
	Bool ret = (i >= 0) && (i < LinkListLength(list));
	
	if(ret)
	{
		LLNode *node = list->next;
		
		if(0 == i)
		{
			if(data) *data = node->data;
			list->next = node->next;
		}
		else
		{
			LLNode *pre = LinkListMove(list, i - 1);
			
			node = pre->next;
			
			if(data) *data = node->data;
			
			pre->next = node->next;	
		}
		
		free(node);
		list->len--;
	}
	
	return ret;
}

Bool LinkListSet(LinkList *list, int i, GTreeNode *data)	//O(n)
{
	return ((i >= 0) && (i < LinkListLength(list))) ? (LinkListMove(list, i)->data = data, true) : false;
}

Bool LinkListGet(LinkList *list, int i, GTreeNode **data)	//O(n)
{
	return ((data != NULL) && (i >= 0) && (i < LinkListLength(list))) ? (*data = LinkListMove(list, i)->data, true) : false;
}

//下面四个配合使用用于遍历链表，时间复杂度为O(n)
LLNode* LinkListMove(LinkList *list, int i)
{
	LLNode *ret = NULL;
	
	list->m_current = NULL;
	
	if((list != NULL) && (i >= 0) && (i < LinkListLength(list)))
	{		
		LLNode *node = list->next;
		
		if(node != NULL)
		{
			int j;
			
			for(j = 0; j < i; j++)
			{
				node = node->next;	
			}
			
			ret = node;
			list->m_current = node;				
		}	
	}
	
	return ret;
}

Bool LinkListEnd(LinkList *list)
{
	return (list != NULL) ? (list->m_current == NULL) : false;
}

void LinkListNext(LinkList *list)
{
	if((list != NULL) && (list->m_current != NULL))
	{
		list->m_current = list->m_current->next; 
	}	
}

GTreeNode* LinkListCurrent(LinkList *list)
{
	return ((list != NULL) && (list->m_current != NULL)) ? list->m_current->data : (DataType)0;
}

int LinkListFind(LinkList *list, GTreeNode *data)	//O(n)
{
	int ret = -1;		
	
	if(list)
	{
		int i = 0;
		
		for(LinkListMove(list, 0); !LinkListEnd(list); LinkListNext(list), i++)
		{
			if(LinkListCurrent(list) == data)
			{
				ret = i;
				break;
			}
		}		
	}
	
	return ret;
}

下面是Macro.h文件：

#ifndef __MACRO_H__
#define __MACRO_H__

typedef char DataType;

#define deBug() printf("File = %s\nLine = %d\n", __FILE__, __LINE__)

#include <stdio.h>
#include <stdlib.h>

#ifndef __cplusplus
	typedef int Bool;
	#define true 1
	#define false 0
#else
	typedef bool Bool;
#endif 

#define MALLOC(type, size) 	(type*)malloc(sizeof(type) * size)
#define FREE(p)			(free(p), p = NULL)

#define STRUCT(type)	typedef struct __struct##type type;\
			struct __struct##type
						
#endif

下面是运行结果：

在这里插入图片描述

海天up
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树C语言实现
02-28
二叉树的实现，创建，遍历（先序、中序、后序）添加，修改，删除
红黑二叉树C语言实现.cpp
03-29
红黑二叉树.cpp
二叉树的实现（C语言数据结构）
芊樱烛渊的博客
05-23 9586
一、以下是我们需要实现的功能 #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <stdbool.h> typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; struct BinaryTreeNode* _left; stru
二叉树操作大全（C实现）
gary101818的博客
03-21 1292
以下代码包括：辅助栈（链栈）、辅助队列（顺序存储循环队列）、二叉树的两种先序建立、先序中序后序遍历（递归）、中序遍历非递归方法、层次遍历。注释充分，逻辑清晰，代码可读性强。 #include <stdio.h> #include <malloc.h> #include <stdbool.h> typedef char BiElemType; typedef struct BTNode{ BiElemType data; //数据域 struct BTN
二叉树的代码实现——C语言
最新发布
x3185531971的博客
05-17 424
【代码】二叉树的代码实现——C语言。
实现二叉树的完整创建、二叉树的先序、中序、后序遍历 代码 C语言
id_IamYang的博客
05-26 523
【代码】实现二叉树的完整创建、二叉树的先序、中序、后序遍历 代码 C语言。
最简单的二叉树的创建，c语言完整代码展示
H17260003837的博客
08-20 2964
二叉树的创建
二叉树的实现（C语言）
m0_70403090的博客
09-11 2602
如果数组a【*pi】不为空，就开辟空间来存储a【*pi】，同时（*pi）++。然后依次根据左子树，右子树来递归建立树，遇到空时返回。只有遇到叶子节点的时候才会返回1，这样左右子树层层返回相加，最后计算出叶子节点个数。用lh和rh来比较大小，这样更深一层的树就会显示出来，包含了浅一层的树。也是依次层序遍历，然后在最后一层判断遇到空后是不是一直为空。由于树是链表结构，所以用递归来依次释放节点。二叉树是采用链表的结构来实现。在访问左右子树前先打印该节点。依然采用递归来计算节点个数。其中包含了队列的使用方式。
平衡二叉树c语言代码实现
04-10
简单的用c语言代码完成率平衡二叉树的实现，最主要就是对二叉树不平衡的四种情况进行分析，最后用递归的方法对每次新添加进去的数据进行情况判断，执行相对应的函数，直至添加完毕。
C语言实现二叉树（纯新手向）
热门推荐
weixin_44606789的博客
10-16 1万+
目录 一、二叉树的基本概念 二、二叉树的初始化 三、释放二叉树 四、前中后序遍历二叉树 五、主函数和效果截图 六、拓展时间 这是我这段时间学习c语言二叉树的成果，希望对大家有所帮助，共同进步！ 一、二叉树的基本概念 二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。定义结构体可以这样设计 代码
深入浅出C语言——C语言实现二叉树
weixin_55051736的博客
11-02 2044
二叉树的遍历时按照那个某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。二叉树的基本属性例如：节点的总数、叶子节点的个数、节点值的查找、二叉树的深度，这里都统一使用递归来处理。双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；叶节点或终端节点：度为0的节点称为叶节点；子孙：以某节点为根的子树中任一节点都称为该节点的子孙。节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推。
二叉树创建C语言实现
02-24
通过链式存储结构实现二叉树的创建，包含如下操作： 1. 创建树； 2. 销毁树； 3. 清空树； 4. 插入结点； 5. 删除结点； 6. 获取结点； 7. 获取根结点； 8. 获取树的结点数； 9. 获取树的高度； 10. 获取树的度； 11. 显示二叉树。
二叉树4种遍历方法的C语言实现
11-09
采用C语言对二叉树的前序、中序、后序、层序（使用队列）遍历方法进行了实现，含一个.c文件和一个.h文件，程序的结构比较清晰，对学习二叉树和队列的相关技术具有一定参考意义（有问题可留言交流）
C语言二叉树详解
Sxy_wspsby的博客
12-03 8642
文章目录 概念 一、二叉树的性质 二、实现二叉树 总结 概念 一棵二叉树是结点的一个有限集合，该集合: 1. 或者为空 2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成 注意： 1. 二叉树不存在度大于2的结点 2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树 任意的二叉树都由下面几种情况组合而成： 二叉树中有两个非常特别的存在： 1.满二叉树： 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就
【数据结构】二叉树(C语言实现)
qq_67582098的博客
02-23 1563
本文介绍了树和二叉树的概念和结构以及二叉树链式存储结构的实现，希望对您有所帮助
C语言创建二叉树
knighkingLOL的博客
10-05 1万+
//C语言实现创建二叉树 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int DataType; typedef struct Node{ DataType Data; struct Node *lchild, *rchild; }BinTNode, *BiTree; void Create_BinTree(Bi...
c语言二叉树的创建与前序、中序、后序遍历（超详细）学习笔记
记录学习过程
10-27 7668
完整代码+运行结果。初始化二叉树的顺序是前序顺序，然后有三种遍历方式（前序、中序、后序）。看完我的文章一定会懂的。
C语言写二叉树
jakelihua
11-28 1573
简介：本文是博主当初学习阶段，用C语言实现的二叉树代码。
二叉树--C语言实现数据结构
2201_76062618的博客
07-18 1442
本文讲解二叉树的内容，较为详细
翻转二叉树c语言实现
05-08
翻转二叉树是一种常见的二叉树操作，其实现方式如下： ```c #include #include struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; }; struct TreeNode* invertTree(struct ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值