二叉树的遍历基本操作

一、树的存储方式

1、双亲表示法:用指针表示出每个节点的双亲(和自己的数据):根节点没有双亲,其他的节点都有自己的双亲)

2、孩子表示法:用指针指出每棵树的孩子节点,每个节点给出3个字段(数据,两棵子树)【节点字段为树的度加1】

3、双亲孩子表示法:将孩子表示法和双亲表示法结合在一起

4、孩子兄弟表示法:既表示出每一个节点第一个孩子节点,也表示出每个节点的下一个兄弟节点

二、二叉树(每个节点只有两个分支):根节点加上左子树、和右子树构成的。

1、二叉树也可能为空树,是一个有序树

2、特点:

(1)每个节点最多有两棵子树,即二叉树不存在度大于2的节点

(2)二叉树的子树有左右之分,其子树的次序不能颠倒

3、分类:

满二叉树:节点个数为2^n-1

完全二叉树:(完全二叉树,有n个节点,求其高度,当成满二叉树的格式来求:lgn

:单支树浪费空间多,完全二叉树没有任何浪费

  .h

#pragma once
# include<stdio.h>
# include<stdlib.h>
# include<string.h>
# include<malloc.h>
# include<assert.h>
typedef char DataType;
typedef struct BinTreeNode{
	struct BinTreeNode *_pLeft;//当前节点的左孩子
	struct BinTreeNode *_pRight;//当前节点的右孩子
	DataType _data;//节点里面数据的类型
}Node, *PNode;
void CreateBinTree(PNode *pRoot, DataType array[], int size, DataType invalid);
void _CreateBinTree(PNode *pRoot, DataType array[], int size, int *index, DataType invalid);
PNode BuyBinTreeNode(DataType data);
PNode CopyBinTree(PNode pRoot);
void PreOrder(PNode pRoot);
void InOrer(PNode pRoot);
void PostOrder(PNode pRoot);
void DestroyBinTree(PNode *pRoot);
//二叉树的其他操作//求二叉树节点的个数
int BinTreeSize(PNode pRoot);
//求二叉树叶子节点的个数
int BinTreeLeaf(PNode pRoot);
//求二叉树第k层节点的个数
int BinTreekLevelNode(PNode pRoot, int k);
//求二叉树的高度
int BinTreeHeight(PNode pRoot);
//判断一个节点是否在一棵二叉树中
int IsNodeInBinTree(PNode pRoot, PNode Node);
//找节点
PNode Find(PNode pRoot, DataType data);

.c

# include"tree.h"
void CreateBinTree(PNode *pRoot, DataType array[], int size, DataType invalid){
	int index = 0;
	_CreateBinTree(pRoot, array, size, &index, invalid);
}
void _CreateBinTree(PNode *pRoot, DataType array[], int size, int *index, DataType invalid){
	assert(pRoot);
	assert(index);
	if (*index < size&&array[*index] != invalid){
		*pRoot = BuyBinTreeNode(array[*index]);
		//创建根节点的左子树  
		++(*index);
		_CreateBinTree(&(*pRoot)->_pLeft, array, size, index, invalid);
		//创建右子树  
		_CreateBinTree(&(*pRoot)->_pRight, array, size, index, invalid);
	}
}
PNode BuyBinTreeNode(DataType data){
	PNode pNewNode = (PNode)malloc(sizeof(Node));
	if (NULL == pNewNode) {
		assert(0);
		return;
	}
	pNewNode->_data = data;
	pNewNode->_pLeft = NULL;
	pNewNode->_pRight = NULL; return pNewNode;
}
PNode CopyBinTree(PNode pRoot){
	PNode pNewRoot = NULL;
	//过滤空 
	if (pRoot)
		//拷贝根节点 {
		pNewRoot = BuyBinTreeNode(pRoot->_data);
if (pRoot->_pLeft)
//拷贝左子树 
pNewRoot->_pLeft = CopyBinTree(pRoot->_pLeft);
if (pRoot->_pRight)
//拷贝右子树 
pNewRoot->_pRight = CopyBinTree(pRoot->_pRight);
return pNewRoot;
}
void PreOrder(PNode pRoot){
//前序遍历(根,左,右)
if (pRoot) {
	printf("%c  ", pRoot->_data);
	PreOrder(pRoot->_pLeft);
	PreOrder(pRoot->_pRight);
}
}
void InOrer(PNode pRoot){
//中序遍历(左,根,右)
if (pRoot) {
	InOrer(pRoot->_pLeft);
	printf("%c  ", pRoot->_data);  InOrer(pRoot->_pRight);
}
}
void PostOrder(PNode pRoot){
//后序遍历(左,右,根)
if (pRoot) {
	PostOrder(pRoot->_pLeft);
	PostOrder(pRoot->_pRight);
	printf("%c  ", pRoot->_data);
}
}
void DestroyBinTree(PNode *pRoot){
	assert(pRoot);
	if (*pRoot) {  //先销毁左子树  
		DestroyBinTree(&(*pRoot)->_pLeft);
		//销毁右子树  
		DestroyBinTree(&(*pRoot)->_pRight);
		//销毁根节点  
		free(*pRoot);
		*pRoot = NULL;
	}
}
//求二叉树节点总个数
int BinTreeSize(PNode pRoot){
	if (NULL == pRoot)
		return 0;
	int left = BinTreeSize(pRoot->_pLeft);
	int right = BinTreeSize(pRoot->_pRight);
	return left + right + 1;
}
//求二叉树叶子节点的个数
int BinTreeLeaf(PNode pRoot){
	if (NULL == pRoot)
		return 0; //不用递归到空的那一次 
	if ((NULL == pRoot->_pLeft) && (NULL == pRoot->_pRight))
		return 1;
	return BinTreeLeaf(pRoot->_pLeft) + BinTreeLeaf(pRoot->_pRight);
}
//求二叉树第k层节点的个数
int BinTreekLevelNode(PNode pRoot, int k){
	if (NULL == pRoot || k <= 0)
		return 0;
	if (1 == k)
		return 1;
	return BinTreekLevelNode(pRoot->_pLeft, k - 1) + BinTreekLevelNode(pRoot->_pRight, k - 1);
}
求二叉树的高度
int BinTreeHeight(PNode pRoot){
	int left = 0;
	int right = 0;
	if (NULL == pRoot)
		return 0;
	if (NULL == pRoot->_pLeft&&NULL == pRoot->_pRight)
		return 1;
	left = BinTreeHeight(pRoot->_pLeft);
	right = BinTreeHeight(pRoot->_pRight);
	return left > right ? (left + 1) : (right + 1);
}
int IsNodeInBinTree(PNode pRoot, PNode Node){
	if (NULL == pRoot || NULL == Node)
		return 0;
	if (pRoot == Node)
		return 1;
	if (IsNodeInBinTree(pRoot->_pLeft, Node))
		return 1;
	return IsNodeInBinTree(pRoot->_pRight, Node);
}
PNode Find(PNode pRoot, DataType data){
	PNode Node = NULL;
	if (NULL == pRoot)
		return NULL;
	if (data == pRoot->_data)
		return pRoot;
	if (Node == Find(pRoot->_pLeft, data))
		return Node;
	return Find(pRoot->_pRight, data);
}

test.c

# include"Tree.h"
void Test1(){
	char *arr = "ABD###CE##F";
	PNode pRoot = NULL;
	PNode pNewRoot = NULL;
	int len = strlen(arr);
	CreateBinTree(&pRoot, arr, len, '#');
	pNewRoot = CopyBinTree(pRoot);
	PreOrder(pRoot);
	PreOrder(pNewRoot);
}
void Test2(){
	char arr[] = "ABD###CE##F";
	PNode pRoot = NULL;
	PNode pNewRoot = NULL;
	int len = strlen(arr);
	CreateBinTree(&pRoot, arr, len, '#');
	pNewRoot = CopyBinTree(pRoot);
	InOrer(pRoot); InOrer(pNewRoot);
}
void Test3(){
	char arr[] = "ABD###CE##F";
	PNode pRoot = NULL;
	PNode pNewRoot = NULL;
	int len = strlen(arr);
	CreateBinTree(&pRoot, arr, len, '#');
	pNewRoot = CopyBinTree(pRoot);
	PostOrder(pRoot);
	PostOrder(pNewRoot);
}
void test4(){
	PNode pRoot = NULL;
	PNode Node = Find(PreOrder, 'E');
	if (IsNodeInBinTree(pRoot, Node))
		printf("在");
	else  printf("不在");
}int main(){
	//Test1(); 
	//Test2(); 
	Test3(); 
	system("pause");
	return 0;
}

 

 


 

结果:

 

发布了134 篇原创文章 · 获赞 166 · 访问量 4万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 书香水墨 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览