树的基本操作

最新推荐文章于 2022-10-19 21:21:23 发布
最新推荐文章于 2022-10-19 21:21:23 发布
阅读量1.3k 收藏 13
点赞数 1
分类专栏： 数据结构和算法 c/c++ 文章标签： 树的基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QZFZZ/article/details/9386135
版权 
//Tree.h

#ifndef TREE_H
#define TREE_H

#include <stdio.h>
#include <stdlib.h>
#define ERROR -1 
#define OVERFLOW -2 
#define SUCCESS 0

struct _Node
{
	int iValue;
	struct _Node* pParent;
	struct _Node* pChildren;
	struct _Node* pRSibling;
	struct _Node* pLSibling;
};

typedef struct _Node Node;

typedef struct
{
	Node* pRoot;//Root
	int iDepth;//树的层数
	int iSize;//树的结点数
	int iLeaves;//树的叶子数 暂未使用
}Tree;

Tree* InitTree();
void ClearTree( Tree** pTree );
void DestroyTree( Tree** pTree );
int TreeEmpty( Tree* pTree );
int GetTreeDepth( Tree* pTree );
Node* GetRoot( Tree* pTree );
void Assign( Tree* pTree, Node* pNode, Node* pValue );
Node* GetParent( Tree* pTree, Node* pNode );
Node* GetLeftChild( Tree* pTree, Node* pNode );
Node* GetRightChild( Tree* pTree, Node* pNode );
Node* GetLeftSibling( Tree* pTree, Node* pNode );
Node* GetRightSibling( Tree* pTree, Node* pNode );
int InsertSiblingBefore( Tree* pTree, Node* pNode, Node* pValue );
int InsertChildBefore( Tree* pTree, Node* pNode, Node* pValue );
int InsertSiblingAfter( Tree* pTree, Node* pNode, Node* pValue );
void DeleteEntireNode( Node* pNode );
void DeleteNode( Tree* pTree, Node* pNode );
int AppendChild( Tree* pTree, Node* pNode, Node* pValue );
void PrintNode( Node* pNode );
void PreTraverseTree( Node* pNode );
void PostTraverseTree( Node* pNode );
Node* CreateNode( int iValue );

#endif


//Tree.c

#include "Tree.h"


Tree* InitTree()
{//初始化树
	Tree* pTree = (Tree*)malloc( sizeof( Tree ) );

	if( !pTree )
		return NULL;

	pTree->iDepth = 0;
	pTree->iSize = 0;
	pTree->iLeaves = 0;
	pTree->pRoot = NULL;

	return pTree;
}

Node* CreateNode( int iValue )
{
	Node* pNode = (Node*)malloc( sizeof( Node ) );

	if( !pNode )
		return NULL;

	pNode->pChildren = NULL;
	pNode->pLSibling = NULL;
	pNode->pParent = NULL;
	pNode->pRSibling = NULL;

	pNode->iValue = iValue;

	return pNode;
}

void ClearTree( Tree** pTree )
{//清空 树
	if( !(*pTree) )
		return;

	DeleteEntireNode( (*pTree)->pRoot );
	
	(*pTree)->iSize = 0;
	(*pTree)->iDepth = 0;
	(*pTree)->iLeaves = 0;
	
	(*pTree)->pRoot = NULL;

}

void DestroyTree( Tree** pTree )
{//销毁树
	ClearTree( pTree );

	free( *pTree );
	*pTree = NULL;

}

int TreeEmpty( Tree* pTree )
{//测试树是否为空
	if( !pTree || 0 == pTree->iSize )
		return 0;

	return pTree->iSize;
}

int GetTreeDepth( Tree* pTree )
{//树的深度
	if( !pTree || 0 == pTree->iSize )
		return 0;

	return pTree->iDepth;

}

Node* GetRoot( Tree* pTree )
{//树的根
	if( !pTree )
		return NULL;

	return pTree->pRoot;
}

void Assign( Tree* pTree, Node* pNode, Node* pValue )
{//给结点赋值
	if( !pTree || 0 == pTree->iSize || !pNode || !pValue )
		return;

	pNode->iValue = pValue->iValue;
}

Node* GetParent( Tree* pTree, Node* pNode )
{//取结点的父结点
	if( !pTree || 0 == pTree->iSize || !pNode )
		return NULL;

	return pNode->pParent;
}

Node* GetLeftChild( Tree* pTree, Node* pNode )
{//取结点pNode的最左端孩子
	if( !pTree || 0 == pTree->iSize || !pNode || !pNode->pChildren )
		return NULL;

	return pNode->pChildren;
}

Node* GetRightChild( Tree* pTree, Node* pNode )
{//取结点pNode的最右端孩子
	if( !pTree || pTree->iSize == 0 || !pNode->pChildren )
		return NULL;

	Node* pTmp = pNode->pChildren;

	Node* pPrior = NULL;
	while( pTmp )
	{
		pPrior = pTmp;

		pTmp = pTmp->pRSibling;
	}

	return pPrior;
}

Node* GetLeftSibling( Tree* pTree, Node* pNode )
{//pNode的左侧兄弟
	if( !pTree || 0 == pTree->iSize || !pNode || !pNode->pLSibling )
		return NULL;

	return pNode->pLSibling;
}

Node* GetRightSibling( Tree* pTree, Node* pNode )
{//pNode的右侧兄弟
	if( !pTree || pTree->iSize == 0 || !pNode || !pNode->pRSibling )
		return NULL;

	return pNode->pRSibling;
}

int InsertSiblingBefore( Tree* pTree, Node* pNode, Node* pValue )
{//pNode之前插入结点pValue为pNode的左侧兄弟
	if( !pTree || !pNode || !pValue ) 
		return -1;

	Node* pLSibling = GetLeftSibling( pTree, pNode );
	if( pLSibling )
	{
		pLSibling->pRSibling = pValue;
		pNode->pLSibling = pValue;

		pValue->pLSibling = pLSibling;
		pValue->pRSibling = pNode;
	}
	else
	{
		Node* pParent = GetParent( pTree, pNode );

		if( !pParent )
			return ERROR;

		pParent->pChildren = pValue;
		pValue->pLSibling = NULL;
		pValue->pRSibling = pNode;
		pNode->pLSibling = pValue;
	}

	return SUCCESS;
}

int InsertChildBefore( Tree* pTree, Node* pNode, Node* pValue )
{//在某个孩子结点之前插入结点

	if( !pTree || 0 == pTree->iSize || !pNode || !pValue )
		return -1;

	if( !pNode->pLSibling )
	{
		pNode->pLSibling = pValue;
		
		pValue->pLSibling = NULL;
		pValue->pChildren = NULL;
		pValue->pRSibling = pNode;

	}
	else
	{
		pNode->pLSibling->pRSibling = pValue;
		pValue->pLSibling = pNode->pLSibling;

		pValue->pRSibling = pNode;
		pNode->pLSibling = pValue;
	}

	pValue->pParent = GetParent( pTree, pNode );

	return 0;
}

int InsertSiblingAfter( Tree* pTree, Node* pNode, Node* pValue )
{//pNode之后插入pValue为后侧兄弟

	if( !pTree || 0 == pTree->iSize || !pNode || !pValue )
		return -1;

	if( pNode->pRSibling )
	{//有右兄弟
		pNode->pRSibling->pLSibling = pValue;
		pValue->pRSibling = pNode->pRSibling;

		pNode->pRSibling = pValue;
		pValue->pLSibling = pNode;
	}
	else
	{//无右兄弟
		pValue->pLSibling = pNode;
		pValue->pChildren = NULL;
		pValue->pRSibling = NULL;

		pNode->pRSibling = pValue;
	}

	pValue->pParent = GetParent( pTree, pNode );

	return 0;
}

void DeleteEntireNode( Node* pNode )
{
	if( !pNode )
		return;

	Node* pCur = pNode->pChildren;
	while( pCur )
	{
		pCur = pCur->pRSibling;
	}

	delete pNode;

}

void DeleteNode( Tree* pTree, Node* pNode )
{//删除pNode结点
	if( !pTree || !pTree->iSize || !pNode )
		return;

	if( pNode->pLSibling )
	{//存在左兄弟
		if( pNode->pRSibling )
		{
			pNode->pLSibling->pRSibling = pNode->pRSibling;
			pNode->pRSibling->pLSibling = pNode->pLSibling;
		}
		else
		{
			pNode->pLSibling->pRSibling = NULL;
		}
	}
	else if( pNode->pRSibling )
	{//存在右兄弟
		Node* pParent = GetParent(  pTree, pNode );

		if( !pParent )
		{
			pParent->pChildren = pNode->pRSibling;
			pParent->pChildren->pLSibling = NULL;

		}

	}

	DeleteEntireNode( pNode );

}

int AppendChild( Tree* pTree, Node* pNode, Node* pValue )
{//追加孩子结点
	if( !pTree || !pNode || !pValue )
		return -1;

	Node* pTmp = GetRightChild( pTree, pNode );

	if( !pTmp )
	{
		pNode->pChildren = pValue;

	}
	else
	{
		pTmp->pRSibling = pValue;
		pValue->pLSibling = pTmp;
	}

	pValue->pParent = pNode;
	pTree->iSize++;

	return 0;
}


void PrintNode( Node* pNode )
{//输出结点
	if( pNode )
		printf( "%d ", pNode->iValue );
}

void PreTraverseTree( Node* pNode )
{//前序遍历树

	if( !pNode )
		return;

	PrintNode( pNode );//根

	Node* pCur = pNode->pChildren;
	while( pCur )
	{
		PreTraverseTree( pCur );
		pCur = pCur->pRSibling;
	}

}

void PostTraverseTree( Node* pNode )
{//后序遍历树
	if( !pNode )
		return;

	Node* pCur = pNode->pChildren;
	while( pCur )
	{
		PostTraverseTree( pCur );
		pCur = pCur->pRSibling;
	}

	PrintNode( pNode );
}

int main( int argc, char* argv[] )
{
	Tree* pTree = InitTree();
	
	pTree->pRoot = CreateNode( 0 );

	AppendChild( pTree, pTree->pRoot, CreateNode( 1 ) );
	AppendChild( pTree, pTree->pRoot, CreateNode( 2 ) );
	AppendChild( pTree, pTree->pRoot, CreateNode( 3 ) );
	AppendChild( pTree, pTree->pRoot, CreateNode( 4 ) );
	InsertChildBefore( pTree, GetRightChild( pTree, pTree->pRoot ), CreateNode( 5 ) );
	InsertSiblingBefore( pTree, GetRightChild( pTree, pTree->pRoot ), CreateNode( 6 ));

	puts( "后序" );
	PostTraverseTree( pTree->pRoot );
	
	puts( "" );
	puts( "前序" );
	PreTraverseTree( pTree->pRoot );

	puts( "" );
	puts( "左右兄弟" );
	PrintNode( GetLeftSibling( pTree, GetRightChild( pTree, pTree->pRoot )));
	puts( "" );


	//删除最后一个结点
	DeleteNode( pTree, GetRightChild( pTree, pTree->pRoot ) );

	PreTraverseTree( pTree->pRoot );

	puts( "Clear Tree..." );
	ClearTree( &pTree );

	DestroyTree( &pTree );

	if( pTree )
		PreTraverseTree( pTree->pRoot );

	return 0;
}


风知前
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POSTGRESQL 树基本操作
12-24
POSTGRESQL 树基本操作POSTGRESQL 树基本操作POSTGRESQL 树基本操作
二叉树的基本操作
热门推荐
Daioo 随笔
04-21 11万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
B树及其基本操作（查找、插入、删除）
薛定谔的猫的博客
11-24 4894
文章目录B树的基本概念B树的高度 B树的基本概念 B树，又称为多路平衡查找树。 一棵m阶B树是一棵平衡的mmm叉查找树，它或者是空树，或者是满足以下性质的树： 1、 每个结点最多有mmm棵子树（即至多含m−1m-1m−1个关键字），并具有如下结构：n, P0, K1, P1, K2, P2, ... , Kn, Pnn,\ P_0,\ K_1,\ P_1,\ K_2, \ P_2, \ ...\ ,\ K_n,\ P
二叉搜索树的操作及其实现
yanxiang3306
10-19 4123
具体逻辑为：当树空的时候直接new一个结点即可，不空的情况下，当我们要插入一个元素的时候我们需要知道它的前一个元素，这样我们才能实现插入操作，插入的位置都是为空的，所以我们要查找到它适合的位置即可。它的查找方式是这样的：如果我们要查找6这个数字，那么我们从根节点开始，遇到根节点的val是5,6>5,所以我们要往右搜寻，遇到7的时候，6
二叉树基本操作代码
qq_42862882的博客
04-30 5059
import java.io.UnsupportedEncodingException; import java.util.*; public class treeTest { public static void main(String[] args) throws ClassNotFoundException, UnsupportedEncodingException { // ...
树的基本操作(一)
涂印的博客
09-21 2246
Lintcode刷题，求树的高度，判断树的平衡性
树的定义和基本操作
forwardyzk的专栏
12-29 6682
树(一般树) 定义和基本操作 树的术语 树的结构特点 树的基本操作 树的存储结构 树的遍历 定义和基本操作树是n(n>=0)个结点的有限集合.当n=0时,集合为空,称为空树.在任意一颗非空树中,有且仅有一个特定的结点称为根.当n>1时,除根结点以外的其余结点可分成m(m>=0)个不相交的有限结点集合T1,T2….Tm.其中每个集合本身也是一棵树,称为根的子树. 其中: (1)有且仅有一个称
二叉排序树/二叉查找树及其基本操作
qq_44111805的博客
02-07 5376
一、二叉排序树 二叉排序树，又称二叉查找树（BST(Binary Sort/Search Tree) ）或者是一棵空树，或者是具有下列特性的二叉树： （1）若左子树非空，则左子树上所有结点的值均小于根结点的值。 （2）若右子树非空，则右子树删所有结点的值均大于根结点的值。 （3）左右子树分别为一棵二叉排序树。 根据二叉排序树的定义，左子树结点值<根结点值<右子树结点值，则对二叉排序树进行中序遍历，可以得到一个递增的有序序列。如果有相同的值，可以将该节点放在左子节点或右子节点。 E.g：下图所示的
数据结构之二叉排序树的基本操作
bsqetuo的博客
08-25 3068
二叉排序树的创建，查找，删除
链式二叉树的基本操作（建议收藏！！！）
2021dragon的博客
05-07 8558
文章目录二叉树的深度优先遍历前序遍历中序遍历后序遍历二叉树的广度优先遍历层序遍历结点的个数叶子结点的个数第k层结点的个数值为x的结点树的最大深度判断二叉树是否是完全二叉树判断二叉树是否是单值二叉树判断二叉树是否是对称二叉树判断二叉树是否是平衡二叉树判断二叉树是否是另一棵二叉树的子树判断两棵二叉树是否相同翻转二叉树二叉树的销毁二叉树的深度遍历（接口型题目）前序遍历中序遍历后序遍历 typedef char BTDataType;//结点中存储的元素类型（以char为例） typedef struct BTN
红黑树基本操作算法
10-12
红黑树插入删除算法，检查了几次都没有错误，算法导论
二叉排序树基本操作
11-11
二叉排序树的基本操作，创建、插入数据、删除数据、中序遍历、销毁
二叉查找树基本操作.rar
07-06
二叉查找树基本操作的实现代码，源自大可爱.
二叉树基本操作
qzfzz的博客
07-21 4370
二叉树基本操作 包括初始化二叉树 清空二叉树 销毁二叉树 添加子结点 二叉树的深度 二叉树的叶子数目等
C字符串简单压缩
qzfzz的博客
08-04 4286
#include <iostream> #include <stdlib.h> //#include <algorithm> using namespace std; void stringZip( const char* pInputStr, long lInputLen, char* pOutputStr ) { if( !pInputStr || ...
php7扩展开中的hash遍历
qzfzz的博客
08-12 4033
PHP7已经发布半年有余了，其扩展开发方法相较PHP5相差很大，这里简单的介绍一下php7中如何遍历hash 先来看一下php5中如何遍历hash的 -------------------------------------------------------------------------------------------- HashPosition pos_value;
不使用字符串库函数实现字符串复制的几种方法
qzfzz的博客
08-01 3926
不使用字符串函数实现字符串复制的几种方法方法
二叉排序树基本操作的实现
最新发布
09-02
二叉排序树也称为二叉搜索树，它是一种特殊的二叉树，满足以下性质： 1. 左子树中的所有节点的值均小于根节点的值；...以上是二叉排序树基本操作的实现。你可以根据需要调用这些函数来操作二叉排序树。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值