关于二叉树一些接口的实现--【数据结构】

最新推荐文章于 2021-05-08 17:18:49 发布
最新推荐文章于 2021-05-08 17:18:49 发布
阅读量407 收藏 3
点赞数 2
文章标签： 数据结构 二叉树的基本实现 C语言 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eternal_01/article/details/80167453
版权

     树，好像生活中大家随处可见，今天写的是关于我们数据结构中的二叉树，所谓的二叉树--》结点的一个有限集合，该集合或者为空，或者是由一个根节点+左子树+右子树组成；

    下面是对二叉树一些接口的实现，主要包括以下几部分：

       1. 二叉树创建 --》2. 二叉树拷贝 --》3. 前序遍历---递归 --》4.  前序遍历---非递归 --》5. 中序遍历---递归 --》6. 中序遍历---非递归 --》7. 后续遍历---递归 --》8. 后续遍历---非递归 --》9. 层序遍历 --》10. 二叉树的销毁 --》11. 二叉树的镜像---非递归 --》12. 二叉树的镜像---递归 --》13. 求二叉树中结点的个数 --》14.  求二叉树中叶子结点的个数 --15. 求二叉树中第K层结点的个数 --》16. 求二叉树的高度 --》17.  在二叉树中查找值为data的结点，找到返回该结点，否则返回空 --》18. 检测一个节点是否在二叉树中 --》19.  检测一棵树是否为完全二叉树

 下面是对这些接口实现的代码：

#define _CRT_SECURE_NO_WARNINGS 0;
#include <assert.h>
#include <stdlib.h>
#include "bin_tree.h"
#include <stdio.h>
#include "stack.h"
#include "queue .h"

//创建结点
pBTNode BuyNode(BTDataType data)
{
	pBTNode pNewNode = (pBTNode)malloc(sizeof(BTNode));
	if (NULL == pNewNode)
		assert(pNewNode);

	pNewNode->_data = data;
	pNewNode->_pLeft = NULL;
	pNewNode->_pRight = NULL;
	return pNewNode;
}
// 二叉树创建 --->前序遍历
void  creatTree(pBTNode* pRoot, BTDataType arr[], int size, BTDataType invoild)
{ 
	assert(pRoot);
	int index = 0;
	_creatTree(pRoot, arr, size, &index, invoild);
}

void _creatTree(pBTNode* pRoot, BTDataType arr[], int size, int *index, BTDataType invoild)
{
	assert(pRoot);
	assert(index);

	if (*index < size && arr[*index] != invoild)
	{
		*pRoot = BuyNode(arr[*index]);

		++(*index);
		_creatTree(&(*pRoot)->_pLeft, arr, size, index, invoild);

		++(*index);
		_creatTree(&(*pRoot)->_pRight, arr, size, index, invoild);
	}
}

// 二叉树拷贝 --前序遍历
pBTNode CopyBinTree(pBTNode pRoot)
{
	pBTNode pCur=NULL;
	if (pRoot)
	{
		pCur = BuyNode(pRoot->_data);

		if (pRoot->_pLeft)
		pCur->_pLeft=CopyBinTree(pRoot->_pLeft);

		if (pRoot->_pRight)
		pCur->_pRight=CopyBinTree(pRoot->_pRight);
	}
	    return pCur;
}

// 前序遍历---递归 
void PreOrder(pBTNode pRoot)
{
	if (pRoot)
	{
		printf("%c ", pRoot->_data);
		PreOrder(pRoot->_pLeft);
		PreOrder(pRoot->_pRight);
	}	
}

// 前序遍历---非递归 
void PreOrderNor(pBTNode pRoot)
{
	Stack s;
	pBTNode pCur = NULL;
	if (NULL == pRoot)
		return;

	StackInit(&s);
	pCur = pRoot;
	while (pCur)
	{
		printf("%c ", pCur->_data);
		if (pCur->_pRight)
			StackPush(&s, pCur->_pRight);

		if (pCur->_pLeft)
		{
			pCur = pCur->_pLeft;
			continue;
		}

		if (IsEmptyStack(&s))
			return;

		pCur = StackTop(&s);
		StackPop(&s);

	}
}

// 中序遍历---递归 
void InOrder(pBTNode pRoot)
{
	if (pRoot)
	{
		if (pRoot->_pLeft)
			InOrder(pRoot->_pLeft);

		printf("%c ", pRoot->_data);

		if (pRoot->_pRight)
			InOrder(pRoot->_pRight);
	}
}

 //中序遍历---非递归 
void InOrderNor(pBTNode pRoot)
{
	pBTNode pCur = NULL;
	Stack s;
	StackInit(&s);
	if (NULL == pRoot)
		return;

	pCur = pRoot;
	while (pCur || !IsEmptyStack(&s))
	{
		if (pCur != NULL)
		{
			StackPush(&s, pCur);
			pCur = pCur->_pLeft;
		}
		else
		{
			pCur = StackTop(&s);
			StackPop(&s);
			printf("%c ", pCur->_data);
			pCur = pCur->_pRight;
		}
	}
}

// 后序遍历---递归 
void PostOrder(pBTNode pRoot)
{
	if (pRoot)
	{
		if (pRoot->_pLeft)
			PostOrder(pRoot->_pLeft);

		if (pRoot->_pRight)
			PostOrder(pRoot->_pRight);

		printf("%c ", pRoot->_data);
	}
}

// 后序遍历---非递归 
void PostOrderNor(pBTNode pRoot)
{
	pBTNode pCur = NULL;
	pBTNode pTop = NULL;
	pBTNode pPrev = NULL;
	Stack s;
	StackInit(&s);
	if (NULL == pRoot)
		return;

	pCur = pRoot;
	while (pCur || !IsEmptyStack(&s))
	{
		while(pCur != NULL)
		{
			StackPush(&s, pCur);
			pCur = pCur->_pLeft;
		}
			pTop = StackTop(&s);
			if (pTop->_pRight!=NULL && pTop->_pRight!=pPrev)
			{
				pCur = pTop->_pRight;
			}
			else
			{
				printf("%c ", pTop->_data);
				pPrev = pTop;
				StackPop(&s);
			}
	}
}

//层序遍历--循环
void LevelOrderNor(pBTNode pRoot)
{
	Queue q;
	QueueInit(&q);
	if (pRoot)
	{
		QueuePush(&q, pRoot);
		while (!QueueEmpty(&q))
		{
			pRoot = q._pHead->_data;
			QueuePop(&q);
			printf("%c ", pRoot->_data);
			if (pRoot->_pLeft)
				QueuePush(&q, pRoot->_pLeft);

			if (pRoot->_pRight)
				QueuePush(&q, pRoot->_pRight);		
		}
	}
}

// 二叉树的销毁 
void DetroyBinTree(pBTNode* pRoot)
{
	assert(pRoot);
	if (*pRoot)
	{
		if ((*pRoot)->_pLeft)
			DetroyBinTree(&(*pRoot)->_pLeft);

		if ((*pRoot)->_pRight)
			DetroyBinTree(&(*pRoot)->_pRight);

		free(*pRoot);
		*pRoot = NULL;
	}
}

// 二叉树的镜像---非递归 
void MirrorBinTreeNor(pBTNode* pRoot)
{
	assert(pRoot);
	Queue q;
	QueueInit(&q);

	if (*pRoot)
	{
		pBTNode pCur = *pRoot;
		QueuePush(&q, pCur);
		while (!QueueEmpty(&q))
		{
			pCur = q._pHead->_data;
			QueuePop(&q);
			if (pCur->_pLeft)
				QueuePush(&q, pCur->_pLeft);

			if (pCur->_pRight)
				QueuePush(&q, pCur->_pRight);

			if (pCur->_pLeft || pCur->_pRight)
			{
				BTNode* temp = pCur->_pLeft;
				pCur->_pLeft = pCur->_pRight;
				pCur->_pRight = temp;
			}
		}
	}
}

// 二叉树的镜像---递归 
void MirrorBinTree(pBTNode* pRoot)
{
	assert(pRoot);
	if (*pRoot)
	{
		pBTNode pCur = *pRoot;
		pBTNode pTemp = NULL;
		if (NULL==pCur->_pLeft && NULL==pCur->_pRight)
			return;

		pTemp = pCur->_pLeft;
		pCur->_pLeft = pCur->_pRight;
		pCur->_pRight = pTemp;

		if (pCur->_pLeft)
			MirrorBinTree(&pCur->_pLeft);

		if (pCur->_pRight)
			MirrorBinTree(&pCur->_pRight);
	}

}

// 求二叉树中结点的个数 
int BinTreeSize(pBTNode pRoot)
{
	if (NULL == pRoot)
		return 0;
	
	return 1 + BinTreeSize(pRoot->_pLeft) + BinTreeSize(pRoot->_pRight);
}

// 求二叉树中叶子结点的个数 
int BinTreeLeaf(pBTNode pRoot)
{
	if (NULL == pRoot)
		return 0;

	if (NULL == pRoot->_pLeft && NULL == pRoot->_pRight)
		return 1;

	return BinTreeLeaf(pRoot->_pLeft) + BinTreeLeaf(pRoot->_pRight);;
}
 

// 求二叉树的高度 
int BinTreeHeight(pBTNode pRoot)
{
	int treeHeight = 0;
	if (pRoot)
	{
		int leftHeight = BinTreeHeight(pRoot->_pLeft);
		int rightHeight = BinTreeHeight(pRoot->_pRight);
		treeHeight = leftHeight > rightHeight ? leftHeight+1 : rightHeight+1;
	}
	return treeHeight;
}

// 求二叉树中第K层结点的个数 
int BinTreeKLevelNode(pBTNode pRoot, int K)
{
	if (NULL == pRoot || (K<=0 || K>BinTreeHeight(pRoot)))
		return 0;

	 if (1 == K)
		return 1;

	return BinTreeKLevelNode(pRoot->_pLeft, K - 1) + BinTreeKLevelNode(pRoot->_pRight, K - 1);
}

// 在二叉树中查找值为data的结点，找到返回该结点，否则返回空 
pBTNode Find(pBTNode pRoot, BTDataType data)
{
	pBTNode pCur = NULL;
	if (pRoot)
	{
		if (pRoot->_data == data)
			return pRoot;
		else
		{
			if (NULL == pRoot->_pLeft && NULL == pRoot->_pRight)
				return NULL;
			else
			{
				if ((pCur = Find(pRoot->_pLeft, data)) != NULL || (pCur = Find(pRoot->_pRight, data)) != NULL)
					return pCur;
			}
		}
	}
	return NULL;
}

// 检测一个节点是否在二叉树中 
int IsNodeInBinTree(pBTNode pRoot, pBTNode pNode)
{
	int ret = 0;
	if (pRoot)
	{
		if (pRoot == pNode)
			return 1;
		else
		{
			if (NULL == pRoot->_pLeft && NULL == pRoot->_pRight)
				return 0;

			if ((ret = IsNodeInBinTree(pRoot->_pLeft, pNode)) || (ret = IsNodeInBinTree(pRoot->_pRight, pNode)))
				return ret;
		}
	}
	return 0;
}

// 检测一棵树是否为完全二叉树 
int IsCompleteBinTree(pBTNode pRoot)
{
	Queue q;
	pBTNode pCur;
	QueueInit(&q);

	if (NULL == pRoot)    //空树
		return 1;

	if (NULL == pRoot->_pLeft && NULL == pRoot->_pRight)  //只有一个结点
		return 1;

	QueuePush(&q, pRoot);  
	while (q._pHead->_data!=NULL)       //多个结点进行处置
	{
		pCur = q._pHead->_data;
		QueuePop(&q);
		QueuePush(&q,pCur->_pLeft);
		QueuePush(&q,pCur->_pRight);
	}
	while (!QueueEmpty(&q))
	{
		if (q._pHead->_data != NULL)
			return 0;

		QueuePop(&q);
	}
	return 1;
}

 下面是这些接口的测试代码：

#define _CRT_SECURE_NO_WARNINGS 0;
#include <stdio.h>
#include "bin_tree.h"
//测试拷贝二叉树
void testCopyBinTree(pBTNode pRoot)
{
	pBTNode pCur = NULL;
	pCur = CopyBinTree(pRoot);
}
//测试二叉树
void testBinTree()
{
	pBTNode pRoot = NULL;
	int ret;
	pBTNode pCur = NULL;
	BTDataType str[] = { 'A', 'B', 'D', '#', '#', '#', 'C', 'E', '#', '#', 'F' };
	int size = sizeof(str);
	creatTree(&pRoot, str, size, '#');
	testCopyBinTree(pRoot);
	printf("前序遍历--递归---》");
	PreOrder(pRoot);
	printf("\n");
	printf("前序遍历--循环---》");
	PreOrderNor(pRoot);
	printf("\n");
	printf("中序遍历--递归---》");
	InOrder(pRoot);
	printf("\n");
	printf("中序遍历--循环---》");
	InOrderNor(pRoot);
	printf("\n");
	printf("后序遍历--递归---》");
	PostOrder(pRoot);
	printf("\n");
	printf("后序遍历--循环---》");
	PostOrderNor(pRoot);
	printf("\n");
	printf("层序遍历--循环---》");
	LevelOrderNor(pRoot);
	//DetroyBinTree(&pRoot);
	printf("\n");
	printf("前序遍历--循环---镜像后》");
	MirrorBinTreeNor(&pRoot);
	printf("\n");
	printf("前序遍历--递归---镜像后》");
	PreOrderNor(pRoot);
	MirrorBinTree(&pRoot);

	 ret=BinTreeSize(pRoot);
	 ret=BinTreeLeaf(pRoot);
	 ret=BinTreeHeight(pRoot);
	 ret = BinTreeKLevelNode(pRoot, 6);
	 pCur= Find(pRoot, 'E');
	 ret=IsNodeInBinTree(pRoot, pCur);

	///创建完全二叉树///
	pBTNode pRoot = NULL;
	int ret;
	BTDataType str[] = { 'A', 'B', 'D', '#', '#', 'E', '#', '#', 'C', 'F'};
	BTDataType str[] = { ' ' };
	int size = sizeof(str);
	creatTree(&pRoot, str, size, '#');
	ret = IsCompleteBinTree(pRoot);
}
int main()
{
	testBinTree();
	system("pause");
	return 0;
}

      ///分（结）隔（束）符//

陌上人如玉_0
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构二叉树接口实现
01-01
数据结构二叉树接口实现
二叉树的简单接口
码城的博客
03-30 724
二叉树的简单操作
二叉树的接口
wyqwilliam的博客
09-28 274
2.定义二叉树接口 public interface BinaryTree { /** * 是否空树 * @return */ public boolean isEmpty(); /** * 树结点数量 * @return */ public int size(); /** * 获取二叉树的高度 * @return */ public int...
二叉树的相关接口实现
aixintianshideshouhu的博客
11-02 276
一、4.1二叉树链式结构的遍历 所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做 的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。 前序/中序/后序的递归结构遍历：是根据访问结点操作发生位置命名 NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍...
二叉树的接口的实现
翟黎明的博客
10-09 190
接口 typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; struct BinaryTreeNode* _left; struct BinaryTreeNode* _right; }BTNode; // 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树 BTNode* B...
数据结构第五章-树与二叉树 二叉树的C语言实现代码
最新发布
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到的代码 代码中包含以下内容： 1. 二叉树相关头文件： - 二叉链表的数据类型声明 - 链队列结点类型声明 - 链队列类型声明 - 二叉树基本功能（二叉树的...
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
11-13
在本项目中，我们主要探讨的是数据结构领域中的一个重要概念——平衡二叉树，并通过Java编程语言进行实现。平衡二叉树是一种特殊的二叉搜索树，它的左右子树的高度差不超过1，从而保证了树的平衡性，进一步提高了...
java 数据结构二叉树的实现代码
09-01
在Java中，数据结构中的二叉树是一种重要的抽象数据类型，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在本文中，我们将深入探讨如何使用Java实现二叉树，并通过接口、节点类和具体实现来...
data-structures:数据结构Go实现
04-14
在Go语言中实现数据结构，我们可以利用其强大的语法特性和内存管理能力来创建高效的算法和程序。以下是标题"数据结构:数据结构Go实现"和描述中涉及的数据结构的详细说明： 1. **列表**： 列表是一种线性数据结构，...
【数据结构】—— 二叉树相关接口的实现
chenxiyuehh的博客
01-31 240
公共头文件common.h #pragma once #include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;assert.h&gt; #include&lt;stdlib.h&gt; typedef char BTDatatype; typedef struct BinaryTreeNode { BTDatatype _d...
二叉树节点ADT接口(Java算法源码)
01-20
/* * 二叉树节点ADT接口 */ package dsa; public interface BinTreePosition extends Position { //判断是否有父亲（为使代码描述简洁） public boolean hasParent(); //返回当前节点的父节点 public BinTreePosition getParent(); //设置当前节点的父节点 public void setParent(BinTreePosition p); //判断是否为叶子 public boolean isLeaf(); //判断是否为左孩子（为使代码描述简洁） public boolean isLChild(); //判断是否有左孩子（为使代码描述简洁） public boolean hasLChild(); //返回当前节点的左孩子 public BinTreePosition getLChild(); //设置当前节点的左孩子（注意：this.lChild和c.parent都不一定为空） public void setLChild(BinTreePosition c); //判断是否为右孩子（为使代码描述简洁） public boolean isRChild(); //判断是否有右孩子（为使代码描述简洁） public boolean hasRChild(); //返回当前节点的右孩子 public BinTreePosition getRChild(); //设置当前节点的右孩子（注意：this.rChild和c.parent都不一定为空） public void setRChild(BinTreePosition c); //返回当前节点后代元素的数目 public int getSize(); //在孩子发生变化后，更新当前节点及其祖先的规模 public void updateSize(); //返回当前节点的高度 public int getHeight(); //在孩子发生变化后，更新当前节点及其祖先的高度 public void updateHeight(); //返回当前节点的深度 public int getDepth(); //在父亲发生变化后，更新当前节点及其后代的深度 public void updateDepth(); //按照中序遍历的次序，找到当前节点的直接前驱 public BinTreePosition getPrev(); //按照中序遍历的次序，找到当前节点的直接后继 public BinTreePosition getSucc(); //断绝当前节点与其父亲的父子关系 //返回当前节点 public BinTreePosition secede(); //将节点c作为当前节点的左孩子 public BinTreePosition attachL(BinTreePosition c); //将节点c作为当前节点的右孩子 public BinTreePosition attachR(BinTreePosition c); //前序遍历 public Iterator elementsPreorder(); //中序遍历 public Iterator elementsInorder(); //后序遍历 public Iterator elementsPostorder(); //层次遍历 public Iterator elementsLevelorder(); }
二叉树基本接口的实现
TANGY的博客
01-05 258
首先声明结构体 #pragma once #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;malloc.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;assert.h&amp;gt; typedef char BTDataType; typedef struct BinaryTreeNode { BTDat
二叉树相关接口
qq_41268108的博客
08-22 191
#pragma once #include "Stack.h" #include "Queue.h" #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;assert.h&gt; #include &lt;stdlib.h&gt; typedef char BTDataType; //孩子兄弟表示法：表示出每一个结点的第...
二叉树的接口定义及实现
小哥哥咯的博客
08-10 792
/*tree.h --- ADT接口定义*/#ifndef TREE_H_INCLUDED #define TREE_H_INCLUDED #include<stdbool.h>typedef struct item { char petname[20]; char petkind[20]; }Item;#define MAXITEM 10 typedef struct node {
二叉树常用接口
不积极分子
09-03 160
二叉树问题用递归来解决时 是从叶子结点 往根的方向 从下往上来实现的 求结点个数 关系：总结点个数 = 根 + 左子树结点个数 + 右子树结点 个数 终止条件： root == NULL； int size(Node*root) { if (root == NULL) return 0; int left = size(root->left); int right = size...
【数据结构】二叉树接口的实现(用c语言实现）
qq_42270373的博客
10-27 399
二叉树 概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二又树组成。 二叉树的特点: 1.每个结点最多有两棵子树，即二叉树不存在度大于2的结点。2.二又树的子树有左右之分，其子树的次序不能颠倒   特殊的二叉树       1.满二叉树:一个二叉树，如果每一个层的结点数都达到最大值，则这个二又树就是满二叉树。也就是说，如果...
数据结构复习笔记——二叉树的常用接口的实现（c语言）
sjp11的博客
05-08 2064
树二叉树的存储方式二叉树接口的实现1.前序遍历2.中序遍历3.后序遍历4.求树中的节点个数5.树的叶子节点个数6.层序遍历7.判断一棵树是否为完全二叉树8.求二叉树的最大深度完！ 二叉树的存储方式 顺序结构 顺序结构是用数组进行存储，一般只适用于完全二叉树，普通树的使用会由空间浪费。 2.链式结构 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地.
数据结构：二叉树的实现(二叉树接口的超详细C语言实现)
zw的博客
03-17 586
文章目录1. 概念1.1 二叉树的链式结构2. 接口实现2.1 通过前序遍历的数组构建二叉树2.2 二叉树销毁2.3 二叉树节点个数2.4 二叉树叶子节点个数2.5 二叉树第k层节点个数2.6 二叉树查找值为x的节点2.7 二叉树前序遍历2.8 二叉树中序遍历2.9 二叉树后序遍历2.10 层序遍历2.11 判断二叉树是否是完全二叉树 1. 概念 关于二叉树的详细概念，大家可以看我之前写的二叉树(二叉树的概念及性质证明)，本节就不再做过多描述。 但有一点要说明的是在二叉树这一数据结构面前，单独一个二叉树的
二叉树接口及其应用
Melody_1208的专栏
10-14 949
 二叉树为连接于一对二叉树的一个外部节点或内部节点，这两棵二叉树分别称为这个节点的左子树和右子树。这个定义表明，二叉树本身就是一个抽象的数学概念。当我们制定计算机表示方式时，就是在制定一个具体实现。这种情形与用float表示实数，用int表示整数等没有区别。当我们绘制一颗树，根节点通过与左边的左子树以及右边的右子树连接，此时，就是在选择一种方便的具体表示方式。我们开发那些应用和操作二叉树的程序时，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值