树、二叉树_二叉树csdn-CSDN博客

本文链接：https://blog.csdn.net/johnnyzhunan/article/details/52234406

树

树形结构是一种非常重要的非线性数据结构。树形结构是一种结点之间有分支，且具有层次关系的一种结构

一、树的定义：

在计算机科学中，树是指由n个结点（n>=0）组成的又穷集合D以及D上的关系集合R所构成的结构，通常用T表示。在此基础上，树还需要满足一下几个条件：

1.当n=0时，该结点集合为空。此时，树被称为空树。

2.在任意一个非空树中，有且仅有一个根节点。

3.当n>1的时候，除去根结点（root）以外的其余结点可以分为m个（m>0）互不相交的子集D1,D2,……,Dm。每一个这样的子集Di（i<=m）本身又是一个树，这些树称为根结点(root)的子树。

其中，第三条展现了树具有递归的特点：一棵非空树是由若干个子树构成的，而这些子树又可以拆成更小的子树。

二、相关概念：

1、结点的度：一个结点拥有的子树的数量称为该结点的度。直观地看，就是该结点所拥有的子结点的数量。

2、树的度：树中各个结点度最多的那个结点所拥有的度数，即为这棵树的度。

3、结点的层次：从树的根结点开始，根结点为第一层，根结点的子结点为第二层，第二层结点的子结点为第三层……以下面这棵树为例：A结点为第一层，B,C,D结点为第二层，E,F,G,H结点为第三层，I,J结点为第四层。

4、树的深度：树中结点所拥有的最大的层数为该树的深度，如：上面那棵树的深度为4。

5、森林：n（n>=0）棵互不相交的树所组成的集合称为森林。

6、叶子节点：度为0的结点被称为叶子节点。

三、树的性质：

树有这样几条比较重要的性质：

性质1：非空树的结点总数等于树中所有结点的度之和再加上1.

性质2：深度为k的非空树的第i层最多有k^(i-1)个结点（i>=1）。这个性质我不知道是什么鬼？

性质3：深度为h的k叉树（树的度为k）最多有（k^h-1）/(k-1)个结点。（等比数列的和的公式即可证明）

性质4：具有n个结点的k叉树的最小深度为(int)(logk(n*(k-1)+1))。

四、树的基本操作：

树具有以下几种基本操作：

（1）构建一棵树，即：初始化操作。

（2）判断树是否为空。

（3）返回一棵树的根结点。

（4）求指定结点的父结点。

（5）求指定结点的所欲子结点。

（6）求指定结点（非叶子结点）的第i个子结点。

（7）求一棵树的高度。

（8）为指定结点添加子结点。

（9）求一棵树的高度。

（10）求一棵以S为根结点的子树插入到以T为根结点的树中，作为结点m的第i棵子树。

（11）对一棵树进行遍历，按照某个次序依次输出所有结点。

（12）求树中指定结点的兄弟结点。

（13）求某个结点的位置。

三、森林：指的是多颗树的集合。

二叉树

一、二叉树定义

二叉树是一种典型的树形结构，在编程实践中应用广泛。它的特点是每个结点至多有两棵子树，即：度为2。并且二叉树是有序树，其子树有左右子树之分，不可任意颠倒顺序。

二叉树的形态有以下几种，如图所示：

a.空二叉树

b.仅含有一个根结点的二叉树

c.仅有左子树的二叉树

d.仅有右子树的二叉树

e.既含有左子树也含有右子树的二叉树

二、二叉树的性质

性质1：具有n个结点的非空二叉树有且仅有n-1个分支。

性质2：非空二叉树的第i层最多有2^(i-1)个分支。

性质3：深度为k的二叉树最多有2^k-1个结点。

性质4：在任意非空二叉树中，若叶子节点的数目为n0，度为2的结点数目为n2，则n0 = n2+1成立。

性质5：具有n(n>0)个结点的完全二叉树的深度为k = (int)(n/2)。

性质6：若一棵具有n个结点的完全二叉树的所有结点按照从上到下、从左到右的顺序依次对结点从1开始编号。则编号为i的结点具有以下的性质：

（1）如果i=1，则该结点为根结点，无双亲结点（或者说父结点）。

（2）如果i>1，则该结点的双亲结点编号为（int）（i/2）。

（3）若2*i<=n，则编号为i的结点做孩子编号为2*i；若2*i>n，则该结点没有左孩子。

（4）若2*i+1 <=n，则编号为i的结点的右孩子编号为2*i + 1；若2*i +1 > n，则该结点无右孩子。

三、树、二叉树和森林之间的转换

1.树转换为二叉树：

2.森林转化为二叉树：

3.二叉树转化为普通树：

4.二叉树转换为森林：

四、二叉树的基本操作

二叉树是树的一种，二叉树的基本操作就是在普通树的基础上进行了一些小小的改动，主要包括：

（1）构建二叉树。

（2）二叉树的遍历。

（3）求一个结点的父结点。

（4）求一个结点i的左（右）孩子结点。

（5）求出一个结点的左兄弟结点或者右兄弟结点。

（6）求一棵二叉树的高度。

（7）将一棵二叉树插入另一棵二叉树的结点i，作为i的左（右）子树。

（8）删除结点i的左子树或者右子树。

（9）销毁一棵二叉树。

（10）求二叉树一个结点i的深度。

五、二叉树的遍历：

有四种方式：前序遍历、中序遍历、后序遍历和层序遍历。

1.前序遍历：先访问根结点、再访问左子树、最后访问右子树。

2.中序遍历：先访问左子树、再访问根结点、最后访问右子树。

3.后序遍历：先访问左子树、再访问右子树、最后访问根结点。

4.层序遍历：先访问根结点、再按照从左到右的顺序访问第二层、再按照从左到右的顺序访问第三层……以此类推，直到所有节点都被遍历。

代码实现：二叉树的存储可以用数组去存储，也可以用链式存储。

#include<iostream>
using namespace std;
///二叉树的构建
void CreateBinaryTree(char* T, int i, int Max)
{
    char c;
    cout<<"输入结点编号为"<<i<<"的结点的值："<<endl;
    cin>>c;
    T[i] = c;
    if(c=='#'||i>=Max)///将输入#作为结束标志
    {
        return;
    }

    int leftChild = 2*i;
    int rightChild = 2*i + 1;
    CreateBinaryTree(T,leftChild,Max);
    CreateBinaryTree(T,rightChild,Max);
}

///前序遍历
void PreOrderShow(char* T,int i,int Max)
{
    if(i>=Max||T[i]=='#')
    {
        return;
    }
    int leftChild = 2*i;
    int rightChild = 2*i + 1;

    cout<<T[i]<<" ";
    PreOrderShow(T,leftChild,Max);
    PreOrderShow(T,rightChild,Max);
}

///中序遍历
void InOrderShow(char* T,int i,int Max)
{
    if(i>=Max||T[i]=='#')
    {
        return;
    }
    int leftChild = 2*i;
    int rightChild = 2*i + 1;

    InOrderShow(T,leftChild,Max);
    cout<<T[i]<<" ";
    InOrderShow(T,rightChild,Max);
}

///后序遍历
void PostOrderShow(char* T,int i,int Max)
{
    if(i>=Max||T[i]=='#')
    {
        return;
    }
    int leftChild = 2*i;
    int rightChild = 2*i + 1;

    PostOrderShow(T,leftChild,Max);
    PostOrderShow(T,rightChild,Max);
    cout<<T[i]<<" ";
}

int main()
{
    char T[100];
    cout<<"构建一棵树："<<endl;
    CreateBinaryTree(T,1,100);
    cout<<"前序遍历的结果：";
    PreOrderShow(T,1,100);
    cout<<endl;

    cout<<"中序遍历的结果：";
    InOrderShow(T,1,100);
    cout<<endl;

    cout<<"后序遍历的结果：";
    PostOrderShow(T,1,100);
    cout<<endl;

    return 0;
}

2.链式存储：

#include<iostream>
#include<vector>
#include<deque>
using namespace std;
typedef char DataType;

struct BinaryTreeNode//定义结点
{
	BinaryTreeNode(DataType d)
	{
		data = d;
		left = nullptr;
		right = nullptr;
	}

	DataType data;
	BinaryTreeNode* left;  ///左子树
	BinaryTreeNode* right; ///右子树
};

void CreateBinaryTree(BinaryTreeNode* &node)//二叉树的构建
{
	if (node == nullptr)
	{
		DataType x;
		cout << "输入新的元素：" << endl;
		cin >> x;
		if (x != '#')
		{
			node = new BinaryTreeNode(x);
		}
		else
		{
			return;
		}
	}

	CreateBinaryTree(node->left);
	CreateBinaryTree(node->right);
}
///前序遍历
void PreOrderShow(BinaryTreeNode* node)
{
	if (node == nullptr)
	{
		return;
	}

	cout << node->data << " ";
	PreOrderShow(node->left);
	PreOrderShow(node->right);
}
///中序遍历
void InOrderShow(BinaryTreeNode* node)
{
	if (node == nullptr)
	{
		return;
	}

	InOrderShow(node->left);
	cout << node->data << " ";
	InOrderShow(node->right);
}
///后序遍历
void PostOrderShow(BinaryTreeNode* node)
{
	if (node == nullptr)
	{
		return;
	}

	PostOrderShow(node->left);
	PostOrderShow(node->right);
	cout << node->data << " ";
}
//层序遍历
void LayOrderShow(BinaryTreeNode* node)
{
	deque<BinaryTreeNode*> queue;
	if (node != nullptr)
	{
		queue.push_back(node);
		while (!queue.empty())
		{
			auto tmp = queue.front();
			cout << tmp->data << " ";
			queue.pop_front();
			if (tmp->left != nullptr)
			{
				queue.push_back(tmp->left);
			}

			if (tmp->right != nullptr)
			{
				queue.push_back(tmp->right);
			}
		}
	}
}
///删除结点
void deleteNode(BinaryTreeNode* &node)
{
	if (node == nullptr)
	{
		return;
	}
	deleteNode(node->left);
	deleteNode(node->right);
	delete node;
	node = nullptr; //结点删除了之后还得置空
	
}
//求树的深度，利用深度优先搜索的原理
int getDepth(BinaryTreeNode* node)
{
	static int maxDepth = 0;
	static int currentDepth = 0;

	if (node == nullptr)
	{
		return 0;
	}
	else
	{
		currentDepth++;
		if (node->left != nullptr)
		{
			getDepth(node->left);
			currentDepth--;
		}

		if (node->right != nullptr)
		{
			getDepth(node->right);
			currentDepth--;
		}

		if (node->left == nullptr&&node->right == nullptr&&maxDepth < currentDepth)
		{
			maxDepth = currentDepth;
		}
	}
	return maxDepth;
}

int main()
{
	BinaryTreeNode* root = new BinaryTreeNode('A');
	cout << "创建一棵树：" << endl;
	CreateBinaryTree(root);

	cout << "前序遍历的结果：";
	PreOrderShow(root);
	cout << endl;

	cout << "中序遍历的结果：";
	InOrderShow(root);
	cout << endl;

	cout << "后序遍历的结果：";
	PostOrderShow(root);
	cout << endl;

	cout << "层序遍历的结果：";
	LayOrderShow(root);
	cout << endl;

	cout << "树的深度为：";
	cout << getDepth(root) << endl;

	cout << "删除根结点的左子树" << endl;
	deleteNode(root->left);

	cout << "此时树的前序遍历结果为：";
	PreOrderShow(root);
	cout << endl;

	cout << "中序遍历结果为：";
	InOrderShow(root);
	cout << endl;

	cout << "后序遍历结果为：";
	PostOrderShow(root);
	cout << endl;

	cout << "层序遍历结果为：";
	LayOrderShow(root);
	cout << endl;

	system("pause");
	return 0;
}