数据结构中关于二叉树的使用

最新推荐文章于 2024-05-18 09:28:18 发布

ScutEthan

最新推荐文章于 2024-05-18 09:28:18 发布

阅读量923

点赞数

分类专栏：数据结构

数据结构专栏收录该内容

6 篇文章 1 订阅

订阅专栏

文章参考自http://www.cnblogs.com/xpjiang/p/4569591.html

http://echo.vars.me/c/er-cha-shu/

1、树与树的表示

数据管理的基本操作之一：查找（根据某个给定关键字K，从集合R 中找出关键字与K 相同的记录）。一个自然的问题就是，如何实现有效率的查找？

静态查找：集合中记录是固定的，没有插入和删除操作，只有查找
动态查找：集合中记录是动态变化的，除查找，还可能发生插入和删除

静态查找——方法一：顺序查找（时间复杂度O(n)）

<span style="font-size:18px;">int SequentialSearch(StaticTable * Tbl, ElementType K)
{
    // 在表Tbl[1]~Tbl[n] 中查找关键字为K的数据元素
    int i;
    Tabl->Element[0] = K; // 建立哨兵
    for(i = Tbl->Length; Tbl->Element[i] != K; i--)
        ;
    return i; // 查找成功返回所在单元下标；不成功返回0
}</span>

静态查找——方法二：二分查找（时间复杂度O(logn)）

二分查找的启示？

二分查找判定树：

判定树上每个节点需要查找的次数刚好为该节点所在的层数
查找成功时查找次数不会超过判定树的深度
n个节点的判定树的深度为⌊log₂n⌋+1

树的一些概念

一颗N个节点的树有N-1条边

树的一些基本术语：

结点的度（Degree）：结点的子树个数
树的度：树的所有结点中最大的度数
叶节点（Leaf）：度为0的结点
父节点（Parent）：有子树的结点是其子树的根结点的父结点
子节点（Child）：若A结点是B结点的父结点，则称B结点是A结点的子结点；子结点也称孩子结点
兄弟节点（Sibling）：具有同一父结点的各结点彼此是兄弟结点
路径和路径长度：从结点n₁到n_k的路径为一个结点序列n₁，n₂，...，n_k，n_i是n_i+1的父结点，路径所包含的边的个数为路径的长度
祖先节点（Ancestor）：沿树根到某一结点路径上的所有结点都是这个结点的祖先结点
子孙节点（Descendant）：某一结点的子树中的所有结点都是这个结点子孙
节点的层次（Level）：规定根结点在1层，其它任一结点的层数时其父节点的层数加1
树的深度（Depth）：树中所有结点中的最大层次是这棵树的深度

2.二叉树及存储结构

二叉树的定义

二叉树T：一个有穷的结点集合

　　这个集合可以为空

　　若不为空，则它是由根结点和称为其左子树T_L和右子树T_R的两个不相交的二叉树组成

特殊二叉树

满二叉树(Full Binary Tree)：
除叶子结点外的所有结点均有两个子结点。节点数达到最大值。所有叶子结点必须在同一层上。
完全二叉树(Complete Binary Tree)：
若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。其实满二叉树是完全二叉树的特例，因为满二叉树已经满了，而完全并不代表满。
霍夫曼树：
每个节点要吗没有子节点，要么有两个子节点。

二叉树几个重要性质

一个二叉树第i 层的最大结点数为：2^i-1，i ≥ 1
深度为k 的二叉树有最大结点总数为：2^k-1，k ≥ 1
对任何非空二叉树T，若n₀ 表示叶结点的个数，n₂ 是度为2 的非叶结点个数，那么两者满足关系n₀ = n₂ + 1

二叉树的抽象数据类型

重要操作：

创建一个二叉树
判别BT 是否为空
遍历，按某顺序访问每个结点

常用的遍历方法：

先序——根、左子树、右子树
中序——左子树、根、右子树
后序——左子树、右子树、根
层次遍历——从上到下、从左到右

3.二叉树的构建

二叉树本来就是递归定义的

下面的代码是一个二叉树的层序遍历创建、递归版本的先中后序遍历、树的深度、左右子树的互换的过程

#include<stdio.h>
#include<string.h>
struct treeNode
{
	int data;
	treeNode *left;
	treeNode *right;
};

//层次遍历创建一颗二叉树
treeNode* creatBinaryTree(int a[], int pos, int length)
{
	treeNode *node = NULL;
	//边界条件
	if ( pos > length || a[pos] == '0')
		return NULL;
	node = new treeNode;
	node->data = a[pos];
	//递归创建
	node->left = creatBinaryTree(a, 2 * pos, length);
	node->right = creatBinaryTree(a, 2 * pos + 1, length);
	return node;

}
//前序遍历二叉树
void preOrderScanBinary(treeNode *node)
{
	if (node)
	{
		//打印节点
		printf("%d", node->data);
		//递归打印左右子树
		preOrderScanBinary(node->left);
		preOrderScanBinary(node->right);

	}

}

//中序遍历
void inOrderScanBinary(treeNode* node)
{
	if (node)
	{
		inOrderScanBinary(node->left);
		printf("%d", node->data);
		inOrderScanBinary(node->right);
	}

}

//后序遍历
void postOrderScanBinary(treeNode* node)
{
	if (node)
	{
		postOrderScanBinary(node->left);
		postOrderScanBinary(node->right);
		printf("%d", node->data);
	}

}

//求二叉树的深度
int binaryDepth(treeNode* node)
{
	if (!node)
		return 0;
	int nLeft = binaryDepth(node->left);//左子树深度
	int nRight = binaryDepth(node->right);//右子树深度
	return nLeft > nRight ? (nLeft + 1) : (nRight + 1); //树的深度=max(左子树深度，右子树深度）+1

}
//左右子树的交换
void exchangeSubTree(treeNode* node)
{
	treeNode* tempSubTree;//找一个临时节点
	if (!node)
	{
		tempSubTree = node->left;
		node->left = node->right;
		node->right = tempSubTree;
		exchangeSubTree(node->left);
		exchangeSubTree(node->right);

	}
}

int main()
{
	int length;
	printf("请输入数组的长度：\n");
	scanf("%d", &length);	
	int *a = new int[length + 10];
	printf("请输入数组元素：\n");
	fflush(stdin);
	for (int i = 1; i <= length; i++)
	{	
		scanf("%d", &a[i]);
		//fflush(stdin);
	}
	//创建一颗二叉树
	treeNode* head = creatBinaryTree(a, 1, length);
	//先序遍历
	printf("先序遍历：");
	preOrderScanBinary(head);
	//中序遍历
	printf("\n中序遍历：");
	inOrderScanBinary(head);
	//后序遍历
	printf("\n后序遍历：");
	postOrderScanBinary(head);
	//树的深度
	printf("\n树的深度：%d\n", binaryDepth(head));
	return 0;

}

下面的代码是一个二叉树先中后序遍历的迭代版本，以及层次遍历二叉树

#include<stack>
#include<iostream>
#include<stdio.h>
#include<queue>
using namespace std;

typedef struct BinaryTreeNode
{
	char value;
	struct BinaryTreeNode* lchild;
	struct BinaryTreeNode* rchild;

}Node,*BTree;

//层次遍历创建一颗二叉树
BTree creatBinaryTree(char a[], int pos, int length)
{
	BTree node = NULL;
	//边界条件
	if (pos > length || a[pos] == '0')
		return NULL;
	node = new Node;
	node->value = a[pos];
	//递归创建
	node->lchild = creatBinaryTree(a, 2 * pos, length);
	node->rchild = creatBinaryTree(a, 2 * pos + 1, length);
	return node;

}

下面是前序遍历的非递归实现

可以将每一个节点都看做是根节点，前序遍历的非递归处理过程如下：对每个节点node,有

访问node，将node入栈
判断node的左孩子节点是否为空。若为空，则将node出栈，并将node设为node的右孩子节点，重复第一步；若不为空，则将node设为node的左孩子节点。
直到node为空，且栈为空。

void preOrder_2(BTree T)
{
	stack<BTree> mStack;
	BTree root = T;
	while (root != NULL || !mStack.empty())
	{
		while (root != NULL)
		{
			printf("%c", root->value);
			mStack.push(root);
			root = root->lchild;
		}
		if (!mStack.empty())
		{
			root = mStack.top();
			mStack.pop();
			root = root->rchild;
		}

	}
}

下面是中序遍历的非递归实现

对每个节点，先访问左孩子节点，将左孩子节点看成根节点，继续访问，直到左孩子节点为空才开始访问该节点，再访问根节点，然后对于右孩子节点以相同方法访问。中序遍历的非递归处理过程如下：对每个节点node,有

node的左孩子节点不为空，则将其入栈，且将node设为node的左孩子节点。
左孩子节点为空时，将栈顶元素出栈，并访问它，且将node设为node的右孩子节点。
直到node为空，且栈为空。

<span style="font-size:18px;">void inOrder_2(BTree T)
{
	stack<BTree> mStack;
	BTree root = T;
	while (root != NULL || !mStack.empty())
	{
		while (root != NULL)
		{
			mStack.push(root);
			root = root->lchild;
		}
		if (!mStack.empty())
		{
			root = mStack.top();
			printf("%c", root->value);
			mStack.pop();
			root = root->rchild;
		}

	}
}</span>

下面是后序遍历的非递归实现

后序遍历的非递归相较于前序和中序，稍显复杂。因为其必须保证在访问根节点前，其左右孩子节点都已经被访问，且左孩子节点必须在右孩子节点前访问。后序遍历的非递归处理过程：

对每个节点node分情况讨论

将node入栈
如果node没有左右孩子节点或者左右孩子节点都已经被访问过，可以直接访问node
如果不满足第二步，则将node的右孩子节点和左孩子节点依次入栈。这样就可以保证访问的顺序是左孩子节点，右孩子节点，根节点。

<span style="font-size:18px;">void postOrder_2(BTree T)
{
	stack<BTree> mStack;
	BTree curT=NULL; //当前访问的节点
	BTree preT=NULL;//上一次访问的节点

	mStack.push(T);
	while (!mStack.empty())
	{
		curT = mStack.top();
		if ((curT->lchild == NULL && curT->rchild == NULL) || (preT != NULL && (preT == curT->lchild || preT == curT->rchild)))
		{
			mStack.pop();
			printf("%c", curT->value);
			preT = curT;
		}
		else
		{
			if (curT->rchild != NULL)
				mStack.push(curT->rchild);
			if (curT->lchild != NULL)
				mStack.push(curT->lchild);

		}

	}

}
</span>

下面是二叉树的层序遍历

层序遍历顾名思义是将二叉树的节点一层一层的读出来。层序遍历的处理过程如下：

建立一个队列，将根节点加入队列。
如果队列不空时，将队列第一个元素出队列，访问它。如果出队列的节点的左右孩子不为空，则依次加入队列。
直到队列为空，遍历结束。

<span style="font-size:18px;">void levelOrder(BTree T)
{
	queue<BTree> mQueue;
	BTree root;
	if (T == NULL)
		return;
	mQueue.push(T);

	while (!mQueue.empty())
	{
		root = mQueue.front();
		mQueue.pop();
		printf("%c", root->value);
		if (root->lchild != NULL)
			mQueue.push(root->lchild);
		if (root->rchild != NULL)
			mQueue.push(root->rchild);

	}

}

int main()
{
	int length;
	printf("请输入数组的长度：");
	scanf("%d", &length);
	char *a = new char[length + 10];
	fflush(stdin);
	printf("请输入数组的数据：");
	for (int i = 1; i <= length; i++)
		scanf("%c", &a[i]);

	BTree head = creatBinaryTree(a, 1, length);
	//先序遍历
	printf("先序遍历：");
	preOrder_2(head);
	//中序遍历
	printf("\n中序遍历：");
	inOrder_2(head);
	//后序遍历
	printf("\n后序遍历：");
	postOrder_2(head);
	//层序遍历
	printf("\n层序遍历：");
	levelOrder(head);
	
	return 0;

}</span>

下面的代码是由前序遍历和中序遍历构建二叉树

根据二叉树的前序遍历中，第一个元素必是根节点；中序遍历中根节点的左侧部分是根节点的左子树，右侧部分是根节点的右子树。由此，可以使用递归的方式构建二叉树了。


<span style="font-size:18px;">BTree rebuildTreeByPreIn(string mPreOrder, string mInOrder, int pLeft, int pRight, int mLeft, int mRight)
{
	BTree root = new Node;
	root->value = mPreOrder[pLeft];//前序遍历中第一个节点是根节点
	root->lchild = NULL;
	root->rchild = NULL;

	int rootIndex = mLeft;
	while (mPreOrder[pLeft] != mInOrder[rootIndex])//查找两个数组中的相同元素
	{
		rootIndex++;
	}
	int leftChild = rootIndex - mLeft;
	if (rootIndex > mLeft) //如果有左子树
	{
		root->lchild = rebuildTreeByPreIn(mPreOrder, mInOrder, pLeft + 1, pLeft + leftChild, mLeft, rootIndex - 1);
	}
	if (rootIndex < mRight)//如果有右子树
	{
		root->rchild = rebuildTreeByPreIn(mPreOrder, mInOrder, pLeft + leftChild + 1, pRight, rootIndex + 1, mRight);
	}
	return root;
}</span>

下面的代码是由中序遍历和后序遍历构建二叉树

与由前序遍历和中序遍历构建二叉树的方法类似，同样使用递归来建立二叉树。主要的不同是，后序遍历的特点是最后一个元素是根节点。


<span style="font-size:18px;">BTree rebuildTreeByInPost(string mInOrder, string mPostOrder, int mLeft, int mRight, int pLeft, int pRight)
{
	BTree root = new Node;
	root->value = mPostOrder[pRight];//后续遍历中最后一个节点是根节点
	root->lchild = NULL;
	root->rchild = NULL;

	int rootIndex = mLeft;
	while (mPostOrder[pRight] != mInOrder[rootIndex])
	{
		rootIndex++;
	}
	int leftChild = rootIndex - mLeft;
	if (rootIndex > mLeft) //如果有左子树
	{
		root->lchild = rebuildTreeByInPost(mInOrder, mPostOrder, mLeft, rootIndex - 1, pLeft, pLeft + leftChild - 1);	
	}
	if (rootIndex < mRight)
	{
		root->rchild = rebuildTreeByInPost(mInOrder, mPostOrder, rootIndex + 1, mRight, pLeft + leftChild, pRight - 1);
	}
	return root;
}</span>

下面的代码为求二叉树中节点的个数（递归）、二叉树的深度（递归）、打印二叉树中根到叶子节点的路径（递归）、判断二叉树是否结构相同（递归）

typedef struct Bin_Tree
{
	int value;
	BinTree* right;
	BinTree* left;
} BinTree;

//二叉树中节点的个数

int NumOfTree(BinTree* root)
{
	if (root == NULL)
		return 0;
	return (NumOfTree(root->right) + NumOfTree(root->left)) + 1;//左子树结点个数+右子树节点个数+1
}
//二叉树的深度
int Depth(BinTree* root)
{
	if (root == NULL)
		return 0;
	int left = Depth(root->left);
	int right = Depth(root->right);
	return (left > right ? left : right) + 1;//左子树深度和右子树深度的最大值加上1
}

//二叉树中根到叶子节点的路径
void Routh(BinTree* root, vector<BinTree*>& vec) //vec为路径的记录
{
	if (root == NULL)
		return;
	vec.push_back(root);
	if (root->left == NULL && root->right == NULL)
	{
		vector<BinTree*>::iterator itr = vec.begin();
		for (; itr != vec.end(); itr++)
		{
			cout << (*itr)->value << endl;
		}
		cout << "----" << endl;

	}
	Routh(root->left, vec);
	Routh(root->right, vec);
	vec.pop_back();

}

//判断两颗二叉树是否结构相同
bool JudgeSame(BinTree* first, BinTree* second)
{
	if (first == NULL && second == NULL)
		return true;
	if ((first == NULL && second != NULL) || (first != NULL && second == NULL))
		return false;
	if (first->value != second->value)
		return false;
	return (JudgeSame(first->left, second->left) && JudgeSame(first->right, second->right));

}

ScutEthan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构中关于二叉树的使用

文章参考自http://www.cnblogs.com/xpjiang/p/4569591.htmlhttp://echo.vars.me/c/er-cha-shu/1、树与树的表示数据管理的基本操作之一：查找（根据某个给定关键字K，从集合R 中找出关键字与K 相同的记录）。一个自然的问题就是，如何实现有效率的查找？静态查找：集合中记录是固定的，没有插入和删除操作，
复制链接

扫一扫

专栏目录